X-Git-Url: https://git.toastfreeware.priv.at/philipp/winterrodeln/wrpylib.git/blobdiff_plain/b8f1420b5a8e061cfa64f001ccd3207ca9f582b2..f6c4fcdf278c631e8900c06845eebfe36aa5dc51:/tests/test_wrvalidators.py diff --git a/tests/test_wrvalidators.py b/tests/test_wrvalidators.py index 4883676..8b2fd82 100644 --- a/tests/test_wrvalidators.py +++ b/tests/test_wrvalidators.py @@ -1,30 +1,210 @@ #!/usr/bin/python3.4 -# -*- coding: iso-8859-15 -*- -import collections -import wrpylib.wrvalidators -import formencode import unittest from wrpylib.wrvalidators import * +# optional converter +# ------------------ -class TestConverter(unittest.TestCase): +class TestOpt(unittest.TestCase): def test_from_str(self): - self.assertEqual(Converter.from_str('abc'), 'abc') - self.assertEqual(Converter.from_str(''), '') + self.assertEqual(None, opt_from_str('', str_from_str)) + self.assertEqual('abc', opt_from_str('abc', str_from_str)) + self.assertEqual(None, opt_from_str('', int_from_str)) + self.assertEqual(4, opt_from_str('4', int_from_str)) def test_to_str(self): - self.assertEqual(Converter.to_str('abc'), 'abc') - self.assertEqual(Converter.to_str(''), '') - self.assertEqual(Converter.to_str(42), '42') + self.assertEqual('', opt_to_str(None, str_to_str)) + self.assertEqual('abc', opt_to_str('abc', str_to_str)) + self.assertEqual('', opt_to_str(None, int_to_str)) + self.assertEqual('4', opt_to_str(4, int_to_str)) +# "no" converter +# -------------- + +class TestNoGermanConverter(unittest.TestCase): + def test_from_str(self): + self.assertEqual((True, 'abc'), no_german_from_str('abc', req_str_from_str)) + self.assertEqual((False, None), no_german_from_str('Nein', req_str_from_str)) + with self.assertRaises(ValueError): + no_german_from_str('', req_str_from_str) + + def test_to_str(self): + self.assertEqual('abc', no_german_to_str((True, 'abc'), str_to_str)) + self.assertEqual('Nein', no_german_to_str((False, None), str_to_str)) + + +# "optional"/"no" converter +# ------------------------- + +class TestOptNoGerman(unittest.TestCase): + def test_from_str(self): + self.assertEqual((True, 'abc'), opt_no_german_from_str('abc', str_from_str)) + self.assertEqual((False, None), opt_no_german_from_str('Nein', str_from_str)) + self.assertEqual((None, None), opt_no_german_from_str('', str_from_str)) + + def test_to_str(self): + self.assertEqual('abc', opt_no_german_to_str((True, 'abc'), str_to_str)) + self.assertEqual('Nein', opt_no_german_to_str((False, None), str_to_str)) + self.assertEqual('', opt_no_german_to_str((None, None), str_to_str)) + + +# choice converter +# ---------------- + +class TestCoice(unittest.TestCase): + def setUp(self): + self.choices = ['abc', 'def', 'ghi'] + + def test_from_str(self): + self.assertEqual('abc', choice_from_str('abc', self.choices)) + self.assertEqual('ghi', choice_from_str('ghi', self.choices)) + with self.assertRaises(ValueError): + choice_from_str('jkl', self.choices) + + +# dictkey converter +# ----------------- + +class TestDictkey(unittest.TestCase): + def setUp(self): + self.choices = {'abc': '1', 'def': '2', 'ghi': '3'} + + def test_from_str(self): + self.assertEqual('abc', dictkey_from_str('1', self.choices)) + self.assertEqual('ghi', dictkey_from_str('3', self.choices)) + with self.assertRaises(ValueError): + dictkey_from_str('4', self.choices) + + def test_to_str(self): + self.assertEqual('1', dictkey_to_str('abc', self.choices)) + self.assertEqual('3', dictkey_to_str('ghi', self.choices)) + + +# enum/"list" converter +# --------------------- + +class TestEnumConverter(unittest.TestCase): + def test_from_str(self): + self.assertEqual([], enum_from_str('', str_from_str)) + self.assertEqual(['abc'], enum_from_str('abc', str_from_str)) + self.assertEqual(['abc', 'def'], enum_from_str('abc; def', str_from_str)) + self.assertEqual(['abc', 'def', 'ghi'], enum_from_str('abc; def;ghi', str_from_str)) + + def test_to_str(self): + self.assertEqual('abc; def; ghi', enum_to_str(['abc', 'def', 'ghi'], str_to_str)) + self.assertEqual('abc', enum_to_str(['abc'], str_to_str)) + self.assertEqual('', enum_to_str([''], str_to_str)) + self.assertEqual('', enum_to_str([], str_to_str)) + + +# value/comment converter +# ----------------------- + +class TestValueCommentConverter(unittest.TestCase): + def test_from_str(self): + self.assertEqual(('abc', 'defg'), value_comment_from_str('abc (defg)', str_from_str, str_from_str)) + self.assertEqual(('abc', ''), value_comment_from_str('abc ()', str_from_str, str_from_str)) + self.assertEqual(('', 'def'), value_comment_from_str('(def)', str_from_str, str_from_str)) + self.assertEqual(('ab', '(cd)'), value_comment_from_str('ab ((cd))', str_from_str, str_from_str)) + self.assertEqual(('ab', '(c(d)[(]))'), value_comment_from_str('ab ((c(d)[(])))', str_from_str, str_from_str)) + self.assertEqual(('ab(', 'cd'), value_comment_from_str('ab( (cd)', str_from_str, str_from_str)) + self.assertEqual(('abcd ', 'ef'), value_comment_from_str('abcd (ef)', str_from_str, str_from_str)) + self.assertEqual(('abc', ''), value_comment_from_str('abc', str_from_str, str_from_str, comment_optional=True)) + self.assertEqual(('a(bc)de', 'fg'), value_comment_from_str('a(bc)de (fg)', str_from_str, str_from_str)) + self.assertEqual(('a(bc)de', 'fg'), value_comment_from_str('a(bc)de (fg)', str_from_str, str_from_str, comment_optional=True)) + self.assertEqual(('a(bc)de', 'f(g)'), value_comment_from_str('a(bc)de (f(g))', str_from_str, str_from_str)) + self.assertEqual(('a(bc)de', 'f(g)'), value_comment_from_str('a(bc)de (f(g))', str_from_str, str_from_str, comment_optional=True)) + self.assertEqual(('a(bc)de', None), value_comment_from_str('a(bc)de', str_from_str, opt_str_from_str, comment_optional=True)) + with self.assertRaises(ValueError): + value_comment_from_str('abc (', str_from_str, str_from_str) + with self.assertRaises(ValueError): + value_comment_from_str('abc )', str_from_str, str_from_str) + with self.assertRaises(ValueError): + value_comment_from_str('abc (def)g', str_from_str, str_from_str) + with self.assertRaises(ValueError): + value_comment_from_str('abc (b))', str_from_str, str_from_str) + with self.assertRaises(ValueError): + value_comment_from_str('abc', str_from_str, str_from_str) + with self.assertRaises(ValueError): + value_comment_from_str('abc(def)', str_from_str, str_from_str) + + def test_to_str(self): + self.assertEqual('abc (defg)', value_comment_to_str(('abc', 'defg'), str_to_str, str_to_str)) + self.assertEqual('abc ()', value_comment_to_str(('abc', ''), str_to_str, str_to_str)) + self.assertEqual('(def)', value_comment_to_str(('', 'def'), str_to_str, str_to_str)) + self.assertEqual('ab ((cd))', value_comment_to_str(('ab', '(cd)'), str_to_str, str_to_str)) + self.assertEqual('ab ((c(d)[(])))', value_comment_to_str(('ab', '(c(d)[(]))'), str_to_str, str_to_str)) + self.assertEqual('ab( (cd)', value_comment_to_str(('ab(', 'cd'), str_to_str, str_to_str)) + self.assertEqual('abcd (ef)', value_comment_to_str(('abcd', 'ef'), str_to_str, str_to_str)) + self.assertEqual('abc', value_comment_to_str(('abc', ''), str_to_str, str_to_str, comment_optional=True)) + self.assertEqual('a(bc)de (fg)', value_comment_to_str(('a(bc)de', 'fg'), str_to_str, str_to_str)) + self.assertEqual('a(bc)de (fg)', value_comment_to_str(('a(bc)de', 'fg'), str_to_str, str_to_str, comment_optional=True)) + self.assertEqual('a(bc)de (f(g))', value_comment_to_str(('a(bc)de', 'f(g)'), str_to_str, str_to_str)) + self.assertEqual('a(bc)de (f(g))', value_comment_to_str(('a(bc)de', 'f(g)'), str_to_str, str_to_str, comment_optional=True)) + self.assertEqual('a(bc)de', value_comment_to_str(('a(bc)de', None), str_to_str, opt_str_to_str, comment_optional=True)) + + +# string converter +# ---------------- + +class TestStr(unittest.TestCase): + def test_from_str(self): + self.assertEqual('', str_from_str('')) + self.assertEqual('abc', str_from_str('abc')) + + def test_to_str(self): + self.assertEqual('', str_to_str('')) + self.assertEqual('abc', str_to_str('abc')) + + +class TestReqStr(unittest.TestCase): + def test_from_str(self): + self.assertEqual('abc', req_str_from_str('abc')) + self.assertEqual(' ', req_str_from_str(' ')) + with self.assertRaises(ValueError): + req_str_from_str('') + + +class TestOptStr(unittest.TestCase): + def test_from_str(self): + self.assertEqual('abc', opt_str_from_str('abc')) + self.assertEqual(' ', opt_str_from_str(' ')) + self.assertEqual(None, opt_str_from_str('')) + + def test_to_str(self): + self.assertEqual('abc', opt_str_to_str('abc')) + self.assertEqual(' ', opt_str_to_str(' ')) + self.assertEqual('', opt_str_to_str(None)) + + +# optional no or string converter +# ------------------------------- + +class TestOptNoOrStr(unittest.TestCase): + def test_from_str(self): + self.assertEqual((False, None), opt_no_or_str_from_str('Nein')) + self.assertEqual((True, 'Nur Wochenende'), opt_no_or_str_from_str('Nur Wochenende')) + self.assertEqual((True, 'Ja'), opt_no_or_str_from_str('Ja')) + self.assertEqual((None, None), opt_no_or_str_from_str('')) + + def test_to_str(self): + self.assertEqual('Nein', opt_no_or_str_to_str((False, None))) + self.assertEqual('Nur Wochenende', opt_no_or_str_to_str((True, 'Nur Wochenende'))) + self.assertEqual('Ja', opt_no_or_str_to_str((True, 'Ja'))) + self.assertEqual('', opt_no_or_str_to_str((None, None))) + + +# integer converter +# ----------------- + class TestInt(unittest.TestCase): def test_from_str(self): - self.assertEqual(int_from_str('42'), 42) - self.assertEqual(int_from_str('+42'), 42) - self.assertEqual(int_from_str('-20'), -20) - self.assertEqual(int_from_str('0', min=0), 0) - self.assertEqual(int_from_str('10', max=10), 10) + self.assertEqual(42, int_from_str('42')) + self.assertEqual(42, int_from_str('+42')) + self.assertEqual(-20, int_from_str('-20')) + self.assertEqual(0, int_from_str('0', min=0)) + self.assertEqual(10, int_from_str('10', max=10)) with self.assertRaises(ValueError): int_from_str('abc') with self.assertRaises(ValueError): @@ -39,17 +219,17 @@ class TestInt(unittest.TestCase): int_from_str('0d') def test_to_str(self): - self.assertEqual(int_to_str(20), '20') - self.assertEqual(int_to_str(-20), '-20') - self.assertEqual(int_to_str(0), '0') + self.assertEqual('20', int_to_str(20)) + self.assertEqual('-20', int_to_str(-20)) + self.assertEqual('0', int_to_str(0)) class TestOptInt(unittest.TestCase): def test_from_str(self): - self.assertEqual(opt_int_from_str('42'), 42) - self.assertEqual(opt_int_from_str('+42'), 42) - self.assertEqual(opt_int_from_str('-20'), -20) - self.assertEqual(opt_int_from_str(''), None) + self.assertEqual(42, opt_int_from_str('42')) + self.assertEqual(42, opt_int_from_str('+42')) + self.assertEqual(-20, opt_int_from_str('-20')) + self.assertEqual(None, opt_int_from_str('')) with self.assertRaises(ValueError): opt_int_from_str('abc') with self.assertRaises(ValueError): @@ -58,373 +238,520 @@ class TestOptInt(unittest.TestCase): opt_int_from_str('0d') def test_to_str(self): - self.assertEqual(opt_int_to_str(20), '20') - self.assertEqual(opt_int_to_str(-20), '-20') - self.assertEqual(opt_int_to_str(0), '0') - self.assertEqual(opt_int_to_str(None), '') + self.assertEqual('20', opt_int_to_str(20)) + self.assertEqual('-20', opt_int_to_str(-20)) + self.assertEqual('0', opt_int_to_str(0)) + self.assertEqual('', opt_int_to_str(None)) -class TestEnumConverter(unittest.TestCase): +class TestOptUInt(unittest.TestCase): def test_from_str(self): - self.assertEqual(enum_from_str(''), []) - self.assertEqual(enum_from_str('abc'), ['abc']) - self.assertEqual(enum_from_str('abc; def'), ['abc', 'def']) - self.assertEqual(enum_from_str('abc; def;ghi'), ['abc', 'def', 'ghi']) + self.assertEqual(42, opt_uint_from_str('42')) + self.assertEqual(0, opt_uint_from_str('0')) + self.assertEqual(None, opt_uint_from_str('')) + with self.assertRaises(ValueError): + opt_uint_from_str('-1') def test_to_str(self): - self.assertEqual(enum_to_str(['abc', 'def', 'ghi']), 'abc; def; ghi') - self.assertEqual(enum_to_str(['abc']), 'abc') - self.assertEqual(enum_to_str(['']), '') - self.assertEqual(enum_to_str([]), '') + self.assertEqual('20', opt_uint_to_str(20)) + self.assertEqual('0', opt_uint_to_str(0)) + self.assertEqual('', opt_uint_to_str(None)) -class TestDateTime(unittest.TestCase): - def test_from_str(self): - self.assertEqual(DateTime.from_str('2015-12-31 23:07:42'), datetime.datetime(2015, 12, 31, 23, 7, 42)) +# bool converter +# -------------- - def test_to_str(self): - self.assertEqual(DateTime.to_str(datetime.datetime(2015, 12, 31, 23, 7, 42)), '2015-12-31 23:07:42') - - -class TestDifficultyGerman(unittest.TestCase): +class TestBoolGerman(unittest.TestCase): def test_from_str(self): - self.assertEqual(difficulty_german_from_str('leicht'), 1) - self.assertEqual(difficulty_german_from_str('mittel'), 2) - with self.assertRaises(ValueError): - difficulty_german_from_str('dontknow') + self.assertEqual(True, bool_german_from_str('Ja')) + self.assertEqual(True, opt_bool_german_from_str('Ja')) + self.assertEqual(False, bool_german_from_str('Nein')) + self.assertEqual(False, opt_bool_german_from_str('Nein')) + self.assertEqual(None, opt_bool_german_from_str('')) with self.assertRaises(ValueError): - difficulty_german_from_str('') + bool_german_from_str('Vielleicht') + opt_bool_german_from_str('Vielleicht') + bool_german_from_str('') def test_to_str(self): - self.assertEqual(difficulty_german_to_str(1), 'leicht') + self.assertEqual('Ja', bool_german_to_str(True)) + self.assertEqual('Ja', opt_bool_german_to_str(True)) + self.assertEqual('Nein', bool_german_to_str(False)) + self.assertEqual('Nein', opt_bool_german_to_str(False)) + self.assertEqual('', opt_bool_german_to_str(None)) + +# tristate converter +# ------------------ class TestTristateGerman(unittest.TestCase): def test_from_str(self): - self.assertEqual(tristate_german_from_str('Ja'), 1.0) - self.assertEqual(tristate_german_from_str('Teilweise'), 0.5) - self.assertEqual(tristate_german_from_str('Nein'), 0) + self.assertEqual(1.0, tristate_german_from_str('Ja')) + self.assertEqual(0.5, tristate_german_from_str('Teilweise')) + self.assertEqual(0, tristate_german_from_str('Nein')) with self.assertRaises(ValueError): tristate_german_from_str('') with self.assertRaises(ValueError): tristate_german_from_str('Vielleicht') def test_to_str(self): - self.assertEqual(tristate_german_to_str(1.0), 'Ja') - self.assertEqual(tristate_german_to_str(0.5), 'Teilweise') - self.assertEqual(tristate_german_to_str(0.0), 'Nein') + self.assertEqual('Ja', tristate_german_to_str(1.0)) + self.assertEqual('Teilweise', tristate_german_to_str(0.5)) + self.assertEqual('Nein', tristate_german_to_str(0.0)) class TestOptTristateGerman(unittest.TestCase): def test_from_str(self): - self.assertEqual(opt_tristate_german_from_str('Ja'), 1.0) - self.assertEqual(opt_tristate_german_from_str('Teilweise'), 0.5) - self.assertEqual(opt_tristate_german_from_str('Nein'), 0) - self.assertEqual(opt_tristate_german_from_str(''), None) + self.assertEqual(1.0, opt_tristate_german_from_str('Ja')) + self.assertEqual(0.5, opt_tristate_german_from_str('Teilweise')) + self.assertEqual(0, opt_tristate_german_from_str('Nein')) + self.assertEqual(None, opt_tristate_german_from_str('')) with self.assertRaises(ValueError): opt_tristate_german_from_str('Vielleicht') def test_to_str(self): - self.assertEqual(opt_tristate_german_to_str(1.0), 'Ja') - self.assertEqual(opt_tristate_german_to_str(0.5), 'Teilweise') - self.assertEqual(opt_tristate_german_to_str(0.0), 'Nein') - self.assertEqual(opt_tristate_german_to_str(None), '') + self.assertEqual('Ja', opt_tristate_german_to_str(1.0)) + self.assertEqual('Teilweise', opt_tristate_german_to_str(0.5)) + self.assertEqual('Nein', opt_tristate_german_to_str(0.0)) + self.assertEqual('', opt_tristate_german_to_str(None)) +# tristate with comment converter +# ------------------------------- + class TestOptTristateGermanComment(unittest.TestCase): def test_from_str(self): - self.assertEqual(opt_tristate_german_comment_from_str('Ja'), (1.0, None)) - self.assertEqual(opt_tristate_german_comment_from_str('Teilweise'), (0.5, None)) - self.assertEqual(opt_tristate_german_comment_from_str('Nein'), (0, None)) - self.assertEqual(opt_tristate_german_comment_from_str('Teilweise (nur ganz oben nicht)'), (0.5, 'nur ganz oben nicht')) - self.assertEqual(opt_tristate_german_comment_from_str(''), (None, None)) + self.assertEqual((1.0, None), opt_tristate_german_comment_from_str('Ja')) + self.assertEqual((0.5, None), opt_tristate_german_comment_from_str('Teilweise')) + self.assertEqual((0, None), opt_tristate_german_comment_from_str('Nein')) + self.assertEqual((0.5, 'nur ganz oben nicht'), opt_tristate_german_comment_from_str('Teilweise (nur ganz oben nicht)')) + self.assertEqual((None, None), opt_tristate_german_comment_from_str('')) with self.assertRaises(ValueError): opt_tristate_german_from_str('Vielleicht') with self.assertRaises(ValueError): opt_tristate_german_from_str('(Ja)') def test_to_str(self): - self.assertEqual(opt_tristate_german_comment_to_str((1.0, None)), 'Ja') - self.assertEqual(opt_tristate_german_comment_to_str((0.5, None)), 'Teilweise') - self.assertEqual(opt_tristate_german_comment_to_str((0.0, None)), 'Nein') - self.assertEqual(opt_tristate_german_comment_to_str((None, None)), '') + self.assertEqual('Ja', opt_tristate_german_comment_to_str((1.0, None))) + self.assertEqual('Teilweise', opt_tristate_german_comment_to_str((0.5, None))) + self.assertEqual('Nein', opt_tristate_german_comment_to_str((0.0, None))) + self.assertEqual('', opt_tristate_german_comment_to_str((None, None))) -class TestLonLat(unittest.TestCase): +# url converter +# ------------- + +class TestUrl(unittest.TestCase): def test_from_str(self): - self.assertEqual(lonlat_from_str('47.076207 N 11.453553 E'), LonLat(11.453553, 47.076207)) + self.assertEqual('http://www.winterrodeln.org/wiki/Arzler_Alm/', url_from_str('http://www.winterrodeln.org/wiki/Arzler_Alm/')) + self.assertEqual('http://www.winterrodeln.org/wiki/Nösslachhütte/', url_from_str('http://www.winterrodeln.org/wiki/Nösslachhütte/')) + self.assertEqual('https://www.winterrodeln.org/wiki/Nösslachhütte/', url_from_str('https://www.winterrodeln.org/wiki/Nösslachhütte/')) with self.assertRaises(ValueError): - lonlat_from_str('47.076207 N 11.453553') + url_from_str('mailto:office@example.com') + with self.assertRaises(ValueError): + url_from_str('/wiki/Arzler_Alm/') def test_to_str(self): - self.assertEqual(lonlat_to_str(LonLat(11.453553, 47.076207)), '47.076207 N 11.453553 E') + self.assertEqual('http://www.winterrodeln.org/wiki/Arzler_Alm/', url_to_str('http://www.winterrodeln.org/wiki/Arzler_Alm/')) + self.assertEqual('http://www.winterrodeln.org/wiki/Nösslachhütte/', url_to_str('http://www.winterrodeln.org/wiki/Nösslachhütte/')) + self.assertEqual('https://www.winterrodeln.org/wiki/Nösslachhütte/', url_to_str('https://www.winterrodeln.org/wiki/Nösslachhütte/')) -class TestValueCommentConverter(unittest.TestCase): +# webauskunft converter +# --------------------- + +class TestWebauskunft(unittest.TestCase): def test_from_str(self): - self.assertEqual(value_comment_from_str('abc (defg)'), ('abc', 'defg')) - self.assertEqual(value_comment_from_str('abc ()'), ('abc', '')) - self.assertEqual(value_comment_from_str('(def)'), ('', 'def')) - self.assertEqual(value_comment_from_str('ab((cd))'), ('ab', '(cd)')) - self.assertEqual(value_comment_from_str('ab((c(d)[(])))'), ('ab', '(c(d)[(]))')) - self.assertEqual(value_comment_from_str('ab((cd)'), ('ab(', 'cd')) - self.assertEqual(value_comment_from_str('abcd (ef) '), ('abcd', 'ef')) - self.assertEqual(value_comment_from_str('abc', comment_optional=True), ('abc', '')) - with self.assertRaises(ValueError): - value_comment_from_str('abc (') - with self.assertRaises(ValueError): - value_comment_from_str('abc )') - with self.assertRaises(ValueError): - value_comment_from_str('abc (def)g') - with self.assertRaises(ValueError): - value_comment_from_str('abc (b))') - with self.assertRaises(ValueError): - value_comment_from_str('abc') + self.assertEqual((True, 'http://www.example.com/current'), webauskunft_from_str('http://www.example.com/current')) + self.assertEqual((None, None), webauskunft_from_str('')) + self.assertEqual((False, None), webauskunft_from_str('Nein')) def test_to_str(self): - self.assertEqual(value_comment_to_str(('abc', 'defg')), 'abc (defg)') - self.assertEqual(value_comment_to_str(('abc', '')), 'abc ()') - self.assertEqual(value_comment_to_str(('', 'def')), '(def)') - self.assertEqual(value_comment_to_str(('ab', '(cd)')), 'ab ((cd))') - self.assertEqual(value_comment_to_str(('ab', '(c(d)[(]))')), 'ab ((c(d)[(])))') - self.assertEqual(value_comment_to_str(('ab(', 'cd')), 'ab( (cd)') - self.assertEqual(value_comment_to_str(('abcd', 'ef')), 'abcd (ef)') - self.assertEqual(value_comment_to_str(('abc', ''), comment_optional=True), 'abc') + self.assertEqual('http://www.example.com/current', webauskunft_to_str((True, 'http://www.example.com/current'))) + self.assertEqual('', webauskunft_to_str((None, None))) + self.assertEqual('Nein', webauskunft_to_str((False, None))) -class TestNoGermanConverter(unittest.TestCase): +# wikipage converter +# ------------------ + +class TestWikipage(unittest.TestCase): def test_from_str(self): - self.assertEqual(no_german_from_str('abc'), (True, 'abc')) - self.assertEqual(no_german_from_str('Nein'), (False, None)) + self.assertEqual('[[Birgitzer Alm]]', wikipage_from_str('[[Birgitzer Alm]]')) with self.assertRaises(ValueError): - no_german_from_str('') + wikipage_from_str('[[') + with self.assertRaises(ValueError): + wikipage_from_str('') + with self.assertRaises(ValueError): + wikipage_from_str('Birgitzer Alm') def test_to_str(self): - self.assertEqual(no_german_to_str((True, 'abc')), 'abc') - self.assertEqual(no_german_to_str((False, None)), 'Nein') + self.assertEqual('[[Birgitzer Alm]]', wikipage_to_str('[[Birgitzer Alm]]')) -class TestOptNoGerman(unittest.TestCase): +class TestOptWikipageEnum(unittest.TestCase): def test_from_str(self): - self.assertEqual(opt_no_german_from_str('abc'), (True, 'abc')) - self.assertEqual(opt_no_german_from_str('Nein'), (False, None)) - self.assertEqual(opt_no_german_from_str(''), (None, None)) + self.assertEqual(['[[Birgitzer Alm]]', '[[Kemater Alm]]'], opt_wikipage_enum_from_str('[[Birgitzer Alm]]; [[Kemater Alm]]')) + self.assertEqual(['[[Birgitzer Alm]]'], opt_wikipage_enum_from_str('[[Birgitzer Alm]]')) + self.assertEqual([], opt_wikipage_enum_from_str('Nein')) + self.assertEqual(None, opt_wikipage_enum_from_str('')) def test_to_str(self): - self.assertEqual(opt_no_german_to_str((True, 'abc')), 'abc') - self.assertEqual(opt_no_german_to_str((False, None)), 'Nein') - self.assertEqual(opt_no_german_to_str((None, None)), '') + self.assertEqual('[[Birgitzer Alm]]; [[Kemater Alm]]', opt_wikipage_enum_to_str(['[[Birgitzer Alm]]', '[[Kemater Alm]]'])) + self.assertEqual('[[Birgitzer Alm]]', opt_wikipage_enum_to_str(['[[Birgitzer Alm]]'])) + self.assertEqual('Nein', opt_wikipage_enum_to_str([])) + self.assertEqual('', opt_wikipage_enum_to_str(None)) -class TestLiftGermanValidator(unittest.TestCase): +# email converter +# --------------- + +class TestEmail(unittest.TestCase): + def setUp(self): + self.good_addresses = ['office@example.com', 'winter+rodeln@localhost', 'joe.doe@exämple.com'] + self.bad_addresses = ['öffice@example.com', 'winter rodeln@localhost', 'www.winterrodeln.org', 'mailto:info@example.com', 'info@example.com.'] + def test_from_str(self): - self.assertEqual(lift_german_from_str(''), None) - self.assertEqual(lift_german_from_str('Nein'), []) - self.assertEqual(lift_german_from_str('Sessellift'), [('Sessellift', None)]) - self.assertEqual(lift_german_from_str('Gondel (nur bis zur Hälfte)'), [('Gondel', 'nur bis zur Hälfte')]) - self.assertEqual(lift_german_from_str('Sessellift; Taxi'), [('Sessellift', None), ('Taxi', None)]) - self.assertEqual(lift_german_from_str('Sessellift (Wochenende); Taxi (6 Euro)'), [('Sessellift', 'Wochenende'), ('Taxi', '6 Euro')]) + for value in self.good_addresses: + self.assertEqual(value, email_from_str(value)) + for value in self.bad_addresses: + with self.assertRaises(ValueError): + email_from_str(value) def test_to_str(self): - self.assertEqual(lift_german_to_str(None), '') - self.assertEqual(lift_german_to_str([]), 'Nein') - self.assertEqual(lift_german_to_str([('Sessellift', None)]), 'Sessellift') - self.assertEqual(lift_german_to_str([('Gondel', 'nur bis zur Hälfte')]), 'Gondel (nur bis zur Hälfte)') - self.assertEqual(lift_german_to_str([('Sessellift', None), ('Taxi', None)]), 'Sessellift; Taxi') - self.assertEqual(lift_german_to_str([('Sessellift', 'Wochenende'), ('Taxi', '6 Euro')]), 'Sessellift (Wochenende); Taxi (6 Euro)') + for value in self.good_addresses: + self.assertEqual(value, email_to_str(value)) -class TestNightLightDays(unittest.TestCase): +class TestMaskedEmail(unittest.TestCase): def test_from_str(self): - self.assertEqual(nightlightdays_from_str(''), (None, None)) - self.assertEqual(nightlightdays_from_str('2 (Mo, Di)'), (2, 'Mo, Di')) - self.assertEqual(nightlightdays_from_str('7'), (7, None)) - self.assertEqual(nightlightdays_from_str('0'), (0, None)) - self.assertEqual(nightlightdays_from_str('(keine Ahnung)'), (None, 'keine Ahnung')) + self.assertEqual(('office@example.com', False), masked_email_from_str('office@example.com')) + self.assertEqual(('office@example.com', True), masked_email_from_str('office(at)example.com')) with self.assertRaises(ValueError): - nightlightdays_from_str('8') - with self.assertRaises(ValueError): - nightlightdays_from_str('5 (Montag') + masked_email_from_str('office@example.com', masked_only=True) with self.assertRaises(ValueError): - nightlightdays_from_str('5.2') + masked_email_from_str('off ice@example.com') def test_to_str(self): - self.assertEqual(nightlightdays_to_str((None, None)), '') - self.assertEqual(nightlightdays_to_str((2, 'Mo, Di')), '2 (Mo, Di)') - self.assertEqual(nightlightdays_to_str((7, None)), '7') - self.assertEqual(nightlightdays_to_str((0, None)), '0') + self.assertEqual('office@example.com', masked_email_to_str(('office@example.com', False))) + self.assertEqual('office(at)example.com', masked_email_to_str(('office@example.com', True))) + self.assertEqual('office()example.com', masked_email_to_str(('office@example.com', True), '()')) -class TestSledRental(unittest.TestCase): +class TestEmails(unittest.TestCase): def test_from_str(self): - self.assertEqual(sledrental_from_str(''), None) - self.assertEqual(sledrental_from_str('Nein'), []) - self.assertEqual(sledrental_from_str('Talstation'), [('Talstation', None)]) - self.assertEqual(sledrental_from_str('Talstation (unten)'), [('Talstation', 'unten')]) - self.assertEqual(sledrental_from_str('Talstation (unten); Mittelstation'), [('Talstation', 'unten'), ('Mittelstation', None)]) + self.assertEqual(None, emails_from_str('')) + self.assertEqual([], emails_from_str('Nein')) + self.assertEqual([(('info@example.com', False), None)], emails_from_str('info@example.com')) + self.assertEqual([(('info@example.com', True), None)], emails_from_str('info(at)example.com')) + self.assertEqual([(('info@example.com', False), 'Office')], emails_from_str('info@example.com (Office)')) + self.assertEqual([(('info@example.com', False), None), (('home@example.com', False), 'Privat')], emails_from_str('info@example.com; home@example.com (Privat)')) with self.assertRaises(ValueError): - sledrental_from_str('(unten)') + emails_from_str('nein') with self.assertRaises(ValueError): - sledrental_from_str('Talstation (unten); ; Mittelstation') + emails_from_str('info@example.com; ho me@example.com (Privat)') def test_to_str(self): - self.assertEqual(sledrental_to_str(None), '') - self.assertEqual(sledrental_to_str([]), 'Nein') - self.assertEqual(sledrental_to_str([('Talstation', None)]), 'Talstation') - self.assertEqual(sledrental_to_str([('Talstation', 'unten')]), 'Talstation (unten)') - self.assertEqual(sledrental_to_str([('Talstation', 'unten'), ('Mittelstation', None)]), 'Talstation (unten); Mittelstation') + self.assertEqual('', emails_to_str(None)) + self.assertEqual('Nein', emails_to_str([])) + self.assertEqual('info@example.com', emails_to_str([(('info@example.com', False), None)])) + self.assertEqual('info@example.com (Office)', emails_to_str([(('info@example.com', False), 'Office')])) + self.assertEqual('info@example.com; home@example.com (Privat)', emails_to_str([(('info@example.com', False), None), (('home@example.com', False), 'Privat')])) -class TestSingleCachet(unittest.TestCase): +# phone converter +# --------------- + +class TestPhoneNumber(unittest.TestCase): def test_from_str(self): - self.assertEqual(single_cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 2009 mittel'), ('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')) - self.assertEqual(single_cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 2013 schwer'), ('Tiroler Naturrodelbahn-Gütesiegel', '2013', 'schwer')) + self.assertEqual('+43-699-123456789', phone_number_from_str('+43-699-123456789')) + self.assertEqual('+43-69945', phone_number_from_str('+43-69945')) + self.assertEqual('+43-512-507-6418', phone_number_from_str('+43-512-507-6418')) with self.assertRaises(ValueError): - single_cachet_german_from_str('') + phone_number_from_str('+43-') with self.assertRaises(ValueError): - single_cachet_german_from_str('Salzburger Naturrodelbahn-Gütesiegel 2013 schwer') + phone_number_from_str('0512123456789') + + def test_to_str(self): + self.assertEqual('+43-699-123456789', phone_number_to_str('+43-699-123456789')) + self.assertEqual('+43-69945', phone_number_to_str('+43-69945')) + self.assertEqual('+43-512-507-6418', phone_number_to_str('+43-512-507-6418')) + + +class TestOptPhoneCommentEnum(unittest.TestCase): + def test_from_str(self): + self.assertEqual(opt_phone_comment_enum_from_str(''), None) + self.assertEqual([], opt_phone_comment_enum_from_str('Nein')) + self.assertEqual([('+43-512-123456', 'untertags')], opt_phone_comment_enum_from_str('+43-512-123456 (untertags)')) + self.assertEqual([('+43-512-1234', 'untertags'), ('+43-664-123456', 'Alm')], opt_phone_comment_enum_from_str('+43-512-1234 (untertags); +43-664-123456 (Alm)')) + self.assertEqual([('+43-512-1234', None), ('+43-664-123456', 'Sommer')], opt_phone_comment_enum_from_str('+43-512-1234; +43-664-123456 (Sommer)', True)) with self.assertRaises(ValueError): - single_cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 4013 schwer') + opt_phone_comment_enum_from_str('+43-512-123456+ (untertags)') with self.assertRaises(ValueError): - single_cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 13 schwer') + opt_phone_comment_enum_from_str('+43-512-123456') + + def test_to_str(self): + self.assertEqual('', opt_phone_comment_enum_to_str(None)) + self.assertEqual('Nein', opt_phone_comment_enum_to_str([])) + self.assertEqual('+43-512-123456 (untertags)', opt_phone_comment_enum_to_str([('+43-512-123456', 'untertags')])) + self.assertEqual('+43-512-1234 (untertags); +43-664-123456 (Alm)', opt_phone_comment_enum_to_str([('+43-512-1234', 'untertags'), ('+43-664-123456', 'Alm')])) + self.assertEqual('+43-512-1234; +43-664-123456 (Sommer)', opt_phone_comment_enum_to_str([('+43-512-1234', None), ('+43-664-123456', 'Sommer')], True)) + + +# longitude/latitude converter +# ---------------------------- + +class TestLonLat(unittest.TestCase): + def test_from_str(self): + self.assertEqual(LonLat(11.453553, 47.076207), lonlat_from_str('47.076207 N 11.453553 E')) with self.assertRaises(ValueError): - single_cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 2013 schwerer') + lonlat_from_str('47.076207 N 11.453553') def test_to_str(self): - self.assertEqual(single_cachet_german_to_str(('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')), 'Tiroler Naturrodelbahn-Gütesiegel 2009 mittel') - self.assertEqual(single_cachet_german_to_str(('Tiroler Naturrodelbahn-Gütesiegel', '2013', 'schwer')), 'Tiroler Naturrodelbahn-Gütesiegel 2013 schwer') + self.assertEqual('47.076207 N 11.453553 E', lonlat_to_str(LonLat(11.453553, 47.076207))) -class TestCachetGerman(unittest.TestCase): +# difficulty converter +# -------------------- + +class TestDifficultyGerman(unittest.TestCase): def test_from_str(self): - self.assertEqual(cachet_german_from_str(''), None) - self.assertEqual(cachet_german_from_str('Nein'), []) - self.assertEqual(cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 2009 mittel'), [('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')]) - self.assertEqual(cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 2013 schwer; Tiroler Naturrodelbahn-Gütesiegel 2009 mittel'), - [('Tiroler Naturrodelbahn-Gütesiegel', '2013', 'schwer'), ('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')]) + self.assertEqual(1, difficulty_german_from_str('leicht')) + self.assertEqual(2, difficulty_german_from_str('mittel')) with self.assertRaises(ValueError): - cachet_german_from_str('Ja') + difficulty_german_from_str('dontknow') with self.assertRaises(ValueError): - cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 2013 schwer Tiroler Naturrodelbahn-Gütesiegel 2009 mittel') + difficulty_german_from_str('') def test_to_str(self): - self.assertEqual(cachet_german_to_str(None), '') - self.assertEqual(cachet_german_to_str([]), 'Nein') - self.assertEqual(cachet_german_to_str([('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')]), 'Tiroler Naturrodelbahn-Gütesiegel 2009 mittel') - self.assertEqual(cachet_german_to_str([('Tiroler Naturrodelbahn-Gütesiegel', '2013', 'schwer'), ('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')]), - 'Tiroler Naturrodelbahn-Gütesiegel 2013 schwer; Tiroler Naturrodelbahn-Gütesiegel 2009 mittel') + self.assertEqual('leicht', difficulty_german_to_str(1)) -class TestUrl(unittest.TestCase): +# avalanches converter +# -------------------- + +class TestAvalancesGermanConverter(unittest.TestCase): def test_from_str(self): - self.assertEqual(url_from_str('http://www.winterrodeln.org/wiki/Arzler_Alm/'), 'http://www.winterrodeln.org/wiki/Arzler_Alm/') - self.assertEqual(url_from_str('http://www.winterrodeln.org/wiki/Nösslachhütte/'), 'http://www.winterrodeln.org/wiki/Nösslachhütte/') - self.assertEqual(url_from_str('https://www.winterrodeln.org/wiki/Nösslachhütte/'), 'https://www.winterrodeln.org/wiki/Nösslachhütte/') + self.assertEqual(1, avalanches_german_from_str('kaum')) + self.assertEqual(1, opt_avalanches_german_from_str('kaum')) + self.assertEqual(2, avalanches_german_from_str('selten')) + self.assertEqual(2, opt_avalanches_german_from_str('selten')) + self.assertEqual(3, avalanches_german_from_str('gelegentlich')) + self.assertEqual(3, opt_avalanches_german_from_str('gelegentlich')) + self.assertEqual(4, avalanches_german_from_str('häufig')) + self.assertEqual(4, opt_avalanches_german_from_str('häufig')) + self.assertEqual(None, opt_avalanches_german_from_str('')) with self.assertRaises(ValueError): - url_from_str('mailto:office@example.com') + avalanches_german_from_str('immer') with self.assertRaises(ValueError): - url_from_str('/wiki/Arzler_Alm/') + opt_avalanches_german_from_str('immer') + with self.assertRaises(ValueError): + avalanches_german_from_str('') def test_to_str(self): - self.assertEqual(url_to_str('http://www.winterrodeln.org/wiki/Arzler_Alm/'), 'http://www.winterrodeln.org/wiki/Arzler_Alm/') - self.assertEqual(url_to_str('http://www.winterrodeln.org/wiki/Nösslachhütte/'), 'http://www.winterrodeln.org/wiki/Nösslachhütte/') - self.assertEqual(url_to_str('https://www.winterrodeln.org/wiki/Nösslachhütte/'), 'https://www.winterrodeln.org/wiki/Nösslachhütte/') + self.assertEqual('kaum', avalanches_german_to_str(1)) + self.assertEqual('kaum', opt_avalanches_german_to_str(1)) + self.assertEqual('selten', avalanches_german_to_str(2)) + self.assertEqual('selten', opt_avalanches_german_to_str(2)) + self.assertEqual('gelegentlich', avalanches_german_to_str(3)) + self.assertEqual('gelegentlich', opt_avalanches_german_to_str(3)) + self.assertEqual('häufig', avalanches_german_to_str(4)) + self.assertEqual('häufig', opt_avalanches_german_to_str(4)) + self.assertEqual('', opt_avalanches_german_to_str(None)) -class TestWebauskunft(unittest.TestCase): +# lift converter +# -------------- + +class TestLiftGermanValidator(unittest.TestCase): def test_from_str(self): - self.assertEqual(webauskunft_from_str('http://www.example.com/current'), (True, 'http://www.example.com/current')) - self.assertEqual(webauskunft_from_str(''), (None, None)) - self.assertEqual(webauskunft_from_str('Nein'), (False, None)) + self.assertEqual(lift_german_from_str(''), None) + self.assertEqual([], lift_german_from_str('Nein')) + self.assertEqual([('Sessellift', None)], lift_german_from_str('Sessellift')) + self.assertEqual([('Gondel', 'nur bis zur Hälfte')], lift_german_from_str('Gondel (nur bis zur Hälfte)')) + self.assertEqual([('Sessellift', None), ('Taxi', None)], lift_german_from_str('Sessellift; Taxi')) + self.assertEqual([('Sessellift', 'Wochenende'), ('Taxi', '6 Euro')], lift_german_from_str('Sessellift (Wochenende); Taxi (6 Euro)')) def test_to_str(self): - self.assertEqual(webauskunft_to_str((True, 'http://www.example.com/current')), 'http://www.example.com/current') - self.assertEqual(webauskunft_to_str((None, None)), '') - self.assertEqual(webauskunft_to_str((False, None)), 'Nein') + self.assertEqual('', lift_german_to_str(None)) + self.assertEqual('Nein', lift_german_to_str([])) + self.assertEqual('Sessellift', lift_german_to_str([('Sessellift', None)])) + self.assertEqual('Gondel (nur bis zur Hälfte)', lift_german_to_str([('Gondel', 'nur bis zur Hälfte')])) + self.assertEqual('Sessellift; Taxi', lift_german_to_str([('Sessellift', None), ('Taxi', None)])) + self.assertEqual('Sessellift (Wochenende); Taxi (6 Euro)', lift_german_to_str([('Sessellift', 'Wochenende'), ('Taxi', '6 Euro')])) -class TestPhoneNumber(unittest.TestCase): +# public transport converter +# -------------------------- + +class TestPublicTransportGerman(unittest.TestCase): def test_from_str(self): - self.assertEqual(phone_number_from_str('+43-699-123456789'), '+43-699-123456789') - self.assertEqual(phone_number_from_str('+43-69945'), '+43-69945') - self.assertEqual(phone_number_from_str('+43-512-507-6418'), '+43-512-507-6418') + self.assertEqual(1, public_transport_german_from_str('Sehr gut')) + self.assertEqual(1, opt_public_transport_german_from_str('Sehr gut')) + self.assertEqual(2, public_transport_german_from_str('Gut')) + self.assertEqual(2, opt_public_transport_german_from_str('Gut')) + self.assertEqual(3, public_transport_german_from_str('Mittelmäßig')) + self.assertEqual(3, opt_public_transport_german_from_str('Mittelmäßig')) + self.assertEqual(4, public_transport_german_from_str('Schlecht')) + self.assertEqual(4, opt_public_transport_german_from_str('Schlecht')) + self.assertEqual(5, public_transport_german_from_str('Nein')) + self.assertEqual(5, opt_public_transport_german_from_str('Nein')) + self.assertEqual(6, public_transport_german_from_str('Ja')) + self.assertEqual(6, opt_public_transport_german_from_str('Ja')) + self.assertEqual(None, opt_public_transport_german_from_str('')) + with self.assertRaises(ValueError): + public_transport_german_from_str('') + with self.assertRaises(ValueError): + public_transport_german_from_str('Naja') + with self.assertRaises(ValueError): + opt_public_transport_german_from_str('Naja') + + def test_to_str(self): + self.assertEqual('Sehr gut', public_transport_german_to_str(1)) + self.assertEqual('Sehr gut', opt_public_transport_german_to_str(1)) + self.assertEqual('Gut', public_transport_german_to_str(2)) + self.assertEqual('Gut', opt_public_transport_german_to_str(2)) + self.assertEqual('Mittelmäßig', public_transport_german_to_str(3)) + self.assertEqual('Mittelmäßig', opt_public_transport_german_to_str(3)) + self.assertEqual('Schlecht', public_transport_german_to_str(4)) + self.assertEqual('Schlecht', opt_public_transport_german_to_str(4)) + self.assertEqual('Nein', public_transport_german_to_str(5)) + self.assertEqual('Nein', opt_public_transport_german_to_str(5)) + self.assertEqual('Ja', public_transport_german_to_str(6)) + self.assertEqual('Ja', opt_public_transport_german_to_str(6)) + self.assertEqual('', opt_public_transport_german_to_str(None)) + + +# cachet converter +# ---------------- + +class TestSingleCachet(unittest.TestCase): + def test_from_str(self): + self.assertEqual(('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel'), single_cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 2009 mittel')) + self.assertEqual(('Tiroler Naturrodelbahn-Gütesiegel', '2013', 'schwer'), single_cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 2013 schwer')) with self.assertRaises(ValueError): - phone_number_from_str('+43-') + single_cachet_german_from_str('') with self.assertRaises(ValueError): - phone_number_from_str('0512123456789') + single_cachet_german_from_str('Salzburger Naturrodelbahn-Gütesiegel 2013 schwer') + with self.assertRaises(ValueError): + single_cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 4013 schwer') + with self.assertRaises(ValueError): + single_cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 13 schwer') + with self.assertRaises(ValueError): + single_cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 2013 schwerer') + with self.assertRaises(ValueError): + single_cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel schwer') + with self.assertRaises(ValueError): + single_cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 2013') def test_to_str(self): - self.assertEqual(phone_number_to_str('+43-699-123456789'), '+43-699-123456789') - self.assertEqual(phone_number_to_str('+43-69945'), '+43-69945') - self.assertEqual(phone_number_to_str('+43-512-507-6418'), '+43-512-507-6418') + self.assertEqual('Tiroler Naturrodelbahn-Gütesiegel 2009 mittel', single_cachet_german_to_str(('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel'))) + self.assertEqual('Tiroler Naturrodelbahn-Gütesiegel 2013 schwer', single_cachet_german_to_str(('Tiroler Naturrodelbahn-Gütesiegel', '2013', 'schwer'))) -class TestTelefonauskunft(unittest.TestCase): +class TestCachetGerman(unittest.TestCase): def test_from_str(self): - self.assertEqual(telefonauskunft_from_str(''), None) - self.assertEqual(telefonauskunft_from_str('Nein'), []) - self.assertEqual(telefonauskunft_from_str('+43-512-123456 (untertags)'), [('+43-512-123456', 'untertags')]) - self.assertEqual(telefonauskunft_from_str('+43-512-1234 (untertags); +43-664-123456 (Alm)'), [('+43-512-1234', 'untertags'), ('+43-664-123456', 'Alm')]) + self.assertEqual(cachet_german_from_str(''), None) + self.assertEqual([], cachet_german_from_str('Nein')) + self.assertEqual([('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')], cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 2009 mittel')) + self.assertEqual([('Tiroler Naturrodelbahn-Gütesiegel', '2013', 'schwer'), ('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')], + cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 2013 schwer; Tiroler Naturrodelbahn-Gütesiegel 2009 mittel')) with self.assertRaises(ValueError): - telefonauskunft_from_str('+43-512-123456+ (untertags)') + cachet_german_from_str('Ja') with self.assertRaises(ValueError): - telefonauskunft_from_str('+43-512-123456') + cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 2013 schwer Tiroler Naturrodelbahn-Gütesiegel 2009 mittel') def test_to_str(self): - self.assertEqual(telefonauskunft_to_str(None), '') - self.assertEqual(telefonauskunft_to_str([]), 'Nein') - self.assertEqual(telefonauskunft_to_str([('+43-512-123456', 'untertags')]), '+43-512-123456 (untertags)') - self.assertEqual(telefonauskunft_to_str([('+43-512-1234', 'untertags'), ('+43-664-123456', 'Alm')]), '+43-512-1234 (untertags); +43-664-123456 (Alm)') + self.assertEqual('', cachet_german_to_str(None)) + self.assertEqual('Nein', cachet_german_to_str([])) + self.assertEqual('Tiroler Naturrodelbahn-Gütesiegel 2009 mittel', cachet_german_to_str([('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')])) + self.assertEqual('Tiroler Naturrodelbahn-Gütesiegel 2013 schwer; Tiroler Naturrodelbahn-Gütesiegel 2009 mittel', cachet_german_to_str([('Tiroler Naturrodelbahn-Gütesiegel', '2013', 'schwer'), ('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')])) -class TestEmail(unittest.TestCase): - def setUp(self): - self.good_addresses = ['office@example.com', 'winter+rodeln@localhost', 'joe.doe@exämple.com'] - self.bad_addresses = ['öffice@example.com', 'winter rodeln@localhost', 'www.winterrodeln.org', 'mailto:info@example.com', 'info@example.com.'] +# night light days converter +# -------------------------- +class TestNightLightDays(unittest.TestCase): def test_from_str(self): - for value in self.good_addresses: - self.assertEqual(value, email_from_str(value)) - for value in self.bad_addresses: - with self.assertRaises(ValueError): - email_from_str(value) + self.assertEqual((None, None), nightlightdays_from_str('')) + self.assertEqual((2, 'Mo, Di'), nightlightdays_from_str('2 (Mo, Di)')) + self.assertEqual((7, None), nightlightdays_from_str('7')) + self.assertEqual((0, None), nightlightdays_from_str('0')) + self.assertEqual((None, 'keine Ahnung'), nightlightdays_from_str('(keine Ahnung)')) + with self.assertRaises(ValueError): + nightlightdays_from_str('8') + with self.assertRaises(ValueError): + nightlightdays_from_str('5 (Montag') + with self.assertRaises(ValueError): + nightlightdays_from_str('5.2') def test_to_str(self): - for value in self.good_addresses: - self.assertEqual(value, email_to_str(value)) + self.assertEqual('', nightlightdays_to_str((None, None))) + self.assertEqual('2 (Mo, Di)', nightlightdays_to_str((2, 'Mo, Di'))) + self.assertEqual('7', nightlightdays_to_str((7, None))) + self.assertEqual('0', nightlightdays_to_str((0, None))) + + +# string with optional comment enum/list converter +# ------------------------------------------------ + +class TestOptStrOptCommentEnum(unittest.TestCase): + def test_from_str(self): + self.assertEqual(None, opt_str_opt_comment_enum_from_str('')) + self.assertEqual([], opt_str_opt_comment_enum_from_str('Nein')) + self.assertEqual([('Talstation', None)], opt_str_opt_comment_enum_from_str('Talstation')) + self.assertEqual([('Talstation', 'unten')], opt_str_opt_comment_enum_from_str('Talstation (unten)')) + self.assertEqual([('Talstation', 'unten'), ('Mittelstation', None)], opt_str_opt_comment_enum_from_str('Talstation (unten); Mittelstation')) + with self.assertRaises(ValueError): + opt_str_opt_comment_enum_from_str('(unten)') + with self.assertRaises(ValueError): + opt_str_opt_comment_enum_from_str('Talstation (unten); ; Mittelstation') + + def test_to_str(self): + self.assertEqual('', opt_str_opt_comment_enum_to_str(None)) + self.assertEqual('Nein', opt_str_opt_comment_enum_to_str([])) + self.assertEqual('Talstation', opt_str_opt_comment_enum_to_str([('Talstation', None)])) + self.assertEqual('Talstation (unten)', opt_str_opt_comment_enum_to_str([('Talstation', 'unten')])) + self.assertEqual('Talstation (unten); Mittelstation', opt_str_opt_comment_enum_to_str([('Talstation', 'unten'), ('Mittelstation', None)])) -class TestBox(unittest.TestCase): +# wikibox converter +# ----------------- + +class TestWikibox(unittest.TestCase): def test_from_str(self): value = '{{MyTemplate|apple=2|banana=5}}' - converter_dict = OrderedDict([('apple', opt_int_converter), ('banana', opt_int_converter)]) - result = box_from_str(value, 'MyTemplate', converter_dict) - self.assertEqual(result['apple'], 2) - self.assertEqual(result['banana'], 5) + converter_dict = OrderedDict([('apple', opt_uint_converter), ('banana', opt_uint_converter)]) + result = wikibox_from_str(value, 'MyTemplate', converter_dict) + self.assertEqual(2, result['apple']) + self.assertEqual(5, result['banana']) value = '{{MyTemplate\n | apple = 2 \n| banana = 5 }}' - result = box_from_str(value, 'MyTemplate', converter_dict) - self.assertEqual(result['apple'], 2) - self.assertEqual(result['banana'], 5) + result = wikibox_from_str(value, 'MyTemplate', converter_dict) + self.assertEqual(2, result['apple']) + self.assertEqual(5, result['banana']) with self.assertRaises(ValueError): - box_from_str(value, 'myTemplate', converter_dict) + wikibox_from_str(value, 'myTemplate', converter_dict) with self.assertRaises(ValueError): value = '{{MyTemplate|apple=2|banana=five}}' - box_from_str(value, 'MyTemplate', converter_dict) + wikibox_from_str(value, 'MyTemplate', converter_dict) with self.assertRaises(ValueError): value = '{{MyTemplate|apple=2}}' - box_from_str(value, 'MyTemplate', converter_dict) + wikibox_from_str(value, 'MyTemplate', converter_dict) with self.assertRaises(ValueError): value = '{{MyTemplate|apple=2|banana=5|cherry=6}}' - box_from_str(value, 'MyTemplate', converter_dict) + wikibox_from_str(value, 'MyTemplate', converter_dict) def test_to_str(self): value = OrderedDict([('apple', 2), ('banana', 5)]) - converter_dict = OrderedDict([('apple', opt_int_converter), ('banana', opt_int_converter)]) - result = box_to_str(value, 'MyTemplate', converter_dict) - self.assertEqual(result, '{{MyTemplate|apple=2|banana=5}}') + converter_dict = OrderedDict([('apple', opt_uint_converter), ('banana', opt_uint_converter)]) + result = wikibox_to_str(value, 'MyTemplate', converter_dict) + self.assertEqual('{{MyTemplate|apple=2|banana=5}}', result) + +# Rodelbahnbox converter +# ---------------------- class TestRodelbahnbox(unittest.TestCase): def setUp(self): @@ -433,164 +760,135 @@ class TestRodelbahnbox(unittest.TestCase): '''{{Rodelbahnbox | Position = 46.807218 N 12.806522 E | Position oben = 46.799014 N 12.818658 E -| Höhe oben = 1046 +| Höhe oben = 1046 | Position unten = -| Höhe unten = -| Länge = 3500 +| Höhe unten = +| Länge = 3500 | Schwierigkeit = mittel | Lawinen = kaum -| Betreiber = Bringungsgemeinschaft Kreithof-Dolomitenhütte -| Öffentliche Anreise = Schlecht -| Aufstieg möglich = Ja +| Betreiber = Bringungsgemeinschaft Kreithof-Dolomitenhütte +| Öffentliche Anreise = Schlecht +| Aufstieg möglich = Ja | Aufstieg getrennt = Teilweise | Gehzeit = 75 | Aufstiegshilfe = Taxi; Sonstige (PKW bis Kreithof) | Beleuchtungsanlage = Ja | Beleuchtungstage = 7 | Rodelverleih = Nein -| Gütesiegel = Tiroler Naturrodelbahn-Gütesiegel 2009 mittel +| Gütesiegel = Tiroler Naturrodelbahn-Gütesiegel 2009 mittel | Webauskunft = http://www.lienzerdolomiten.info/at/tobogorpt.html -| Telefonauskunft = +43-664-2253782 (Dolomitenhütte) +| Telefonauskunft = +43-664-2253782 (Dolomitenhütte) | Bild = Dolomitenrodelbahn Tristach 2011-12-22 oberer Bereich.jpg -| In Übersichtskarte = Ja +| In Übersichtskarte = Ja | Forumid = 139 }}''' def test_from_str(self): value = rodelbahnbox_from_str(self.value) - self.assertEqual(value['Position'], LonLat(12.806522, 46.807218)) - self.assertEqual(value['Position oben'], LonLat(12.818658, 46.799014)) - self.assertEqual(value['Höhe oben'], 1046) - self.assertEqual(value['Position unten'], LonLat(None, None)) - self.assertEqual(value['Höhe unten'], None) - self.assertEqual(value['Länge'], 3500) - self.assertEqual(value['Schwierigkeit'], 2) - self.assertEqual(value['Lawinen'], 1) - self.assertEqual(value['Betreiber'], 'Bringungsgemeinschaft Kreithof-Dolomitenhütte') - self.assertEqual(value['Öffentliche Anreise'], 4) - self.assertEqual(value['Aufstieg möglich'], True) - self.assertEqual(value['Aufstieg getrennt'], (0.5, None)) - self.assertEqual(value['Gehzeit'], 75) - self.assertEqual(value['Aufstiegshilfe'], [('Taxi', None), ('Sonstige', 'PKW bis Kreithof')]) - self.assertEqual(value['Beleuchtungsanlage'], (1.0, None)) - self.assertEqual(value['Beleuchtungstage'], (7, None)) - self.assertEqual(value['Rodelverleih'], []) - self.assertEqual(value['Gütesiegel'], [('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')]) - self.assertEqual(value['Webauskunft'], (True, 'http://www.lienzerdolomiten.info/at/tobogorpt.html')) - self.assertEqual(value['Telefonauskunft'], [('+43-664-2253782', 'Dolomitenhütte')]) - self.assertEqual(value['Bild'], 'Dolomitenrodelbahn Tristach 2011-12-22 oberer Bereich.jpg') - self.assertEqual(value['In Übersichtskarte'], True) - self.assertEqual(value['Forumid'], 139) + self.assertEqual(LonLat(12.806522, 46.807218), value['Position']) + self.assertEqual(LonLat(12.818658, 46.799014), value['Position oben']) + self.assertEqual(1046, value['Höhe oben']) + self.assertEqual(LonLat(None, None), value['Position unten']) + self.assertEqual(None, value['Höhe unten']) + self.assertEqual(3500, value['Länge']) + self.assertEqual(2, value['Schwierigkeit']) + self.assertEqual(1, value['Lawinen']) + self.assertEqual('Bringungsgemeinschaft Kreithof-Dolomitenhütte', value['Betreiber']) + self.assertEqual(4, value['Öffentliche Anreise']) + self.assertEqual(True, value['Aufstieg möglich']) + self.assertEqual((0.5, None), value['Aufstieg getrennt']) + self.assertEqual(75, value['Gehzeit']) + self.assertEqual([('Taxi', None), ('Sonstige', 'PKW bis Kreithof')], value['Aufstiegshilfe']) + self.assertEqual((1.0, None), value['Beleuchtungsanlage']) + self.assertEqual((7, None), value['Beleuchtungstage']) + self.assertEqual([], value['Rodelverleih']) + self.assertEqual([('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')], value['Gütesiegel']) + self.assertEqual((True, 'http://www.lienzerdolomiten.info/at/tobogorpt.html'), value['Webauskunft']) + self.assertEqual([('+43-664-2253782', 'Dolomitenhütte')], value['Telefonauskunft']) + self.assertEqual('Dolomitenrodelbahn Tristach 2011-12-22 oberer Bereich.jpg', value['Bild']) + self.assertEqual(True, value['In Übersichtskarte']) + self.assertEqual(139, value['Forumid']) def test_to_str(self): value = OrderedDict([ ('Position', LonLat(12.806522, 46.807218)), ('Position oben', LonLat(12.818658, 46.799014)), - ('Höhe oben', 1046), + ('Höhe oben', 1046), ('Position unten', LonLat(None, None)), - ('Höhe unten', None), - ('Länge', 3500), + ('Höhe unten', None), + ('Länge', 3500), ('Schwierigkeit', 2), ('Lawinen', 1), - ('Betreiber', 'Bringungsgemeinschaft Kreithof-Dolomitenhütte'), - ('Öffentliche Anreise', 4), - ('Aufstieg möglich', True), + ('Betreiber', 'Bringungsgemeinschaft Kreithof-Dolomitenhütte'), + ('Öffentliche Anreise', 4), + ('Aufstieg möglich', True), ('Aufstieg getrennt', (0.5, None)), ('Gehzeit', 75), ('Aufstiegshilfe', [('Taxi', None), ('Sonstige', 'PKW bis Kreithof')]), ('Beleuchtungsanlage', (1.0, None)), ('Beleuchtungstage', (7, None)), ('Rodelverleih', []), - ('Gütesiegel', [('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')]), + ('Gütesiegel', [('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')]), ('Webauskunft', (True, 'http://www.lienzerdolomiten.info/at/tobogorpt.html')), - ('Telefonauskunft', [('+43-664-2253782', 'Dolomitenhütte')]), + ('Telefonauskunft', [('+43-664-2253782', 'Dolomitenhütte')]), ('Bild', 'Dolomitenrodelbahn Tristach 2011-12-22 oberer Bereich.jpg'), - ('In Übersichtskarte', True), + ('In Übersichtskarte', True), ('Forumid', 139)]) - self.assertEqual(rodelbahnbox_to_str(value), self.value) - - -class TestWrValidators(unittest.TestCase): - def test_ValueCommentListNeinLoopNone(self): - v = wrpylib.wrvalidators.ValueCommentListNeinLoopNone() - assert v.to_python('') == None - assert v.to_python('Nein') == 'Nein' - assert v.to_python('T-Mobile (gut); A1') == 'T-Mobile (gut); A1' - assert v.from_python(None) == '' - assert v.from_python('Nein') == 'Nein' - assert v.from_python('T-Mobile (gut); A1') == 'T-Mobile (gut); A1' - - - def test_PhoneCommentListNeinLoopNone(self): - v = wrpylib.wrvalidators.PhoneCommentListNeinLoopNone(comments_are_optional=True) - assert v.to_python('') == None - assert v.to_python('Nein') == 'Nein' - assert v.to_python('+43-699-1234567 (nicht nach 20:00 Uhr); +43-512-123456') == '+43-699-1234567 (nicht nach 20:00 Uhr); +43-512-123456' - assert v.from_python(None) == '' - assert v.from_python('Nein') == 'Nein' - assert v.from_python('+43-699-1234567 (nicht nach 20:00 Uhr); +43-512-123456') == '+43-699-1234567 (nicht nach 20:00 Uhr); +43-512-123456' - - - def test_MaskedEmail(self): - v = wrpylib.wrvalidators.MaskedEmail() - assert v.to_python('') == (None, None) - assert v.to_python('abc.def@example.com') == ('abc.def@example.com', False) - assert v.to_python('abc.def(at)example.com') == ('abc.def@example.com', True) - assert v.from_python((None, None)) == '' - assert v.from_python(('abc.def@example.com', False)) == 'abc.def@example.com' - assert v.from_python(('abc.def@example.com', True)) == 'abc.def(at)example.com' - - - def test_EmailCommentListNeinLoopNone(self): - v = wrpylib.wrvalidators.EmailCommentListNeinLoopNone() - assert v.to_python('') == None - assert v.to_python('Nein') == 'Nein' - assert v.to_python('first@example.com') == 'first@example.com' - assert v.to_python('first@example.com (Nur Winter); second@example.com') == 'first@example.com (Nur Winter); second@example.com' - assert v.from_python(None) == '' - assert v.from_python('Nein') == 'Nein' - assert v.from_python('first@example.com') == 'first@example.com' - assert v.from_python('first@example.com (Nur Winter); second@example.com') == 'first@example.com (Nur Winter); second@example.com' - testvalue = 'abc.def(at)example.com (comment)' - try: - v.to_python(testvalue) - assert False - except formencode.Invalid: - pass - try: - v.from_python(testvalue) - assert False - except formencode.Invalid: - pass - v = wrpylib.wrvalidators.EmailCommentListNeinLoopNone(allow_masked_email=True) - assert v.to_python(testvalue) == testvalue - assert v.from_python(testvalue) == testvalue - - - def test_WikiPageListLoopNone(self): - v = wrpylib.wrvalidators.WikiPageListLoopNone() - assert v.to_python('') == None - assert v.to_python('[[Birgitzer Alm]]; [[Kemater Alm]]') == '[[Birgitzer Alm]]; [[Kemater Alm]]' - assert v.from_python(None) == '' - assert v.from_python('[[Birgitzer Alm]]; [[Kemater Alm]]') == '[[Birgitzer Alm]]; [[Kemater Alm]]' - - - def test_GasthausboxDictValidator(self): - v = wrpylib.wrvalidators.GasthausboxDictValidator() - other = collections.OrderedDict([ - ('Position', '47.295549 N 9.986970 E'), - ('Höhe', '1250'), - ('Betreiber', ''), - ('Sitzplätze', ''), - ('Übernachtung', ''), - ('Rauchfrei', 'Nein'), - ('Rodelverleih', ''), - ('Handyempfang', 'A1; T-Mobile/Telering'), - ('Homepage', 'http://www.bergkristallhuette.com/'), - ('E-Mail', 'bergkristallhuette@gmx.at'), - ('Telefon', '+43-664-1808482'), - ('Bild', 'Bergkritsallhütte 2009-02-07.JPG'), - ('Rodelbahnen', '[[Bergkristallhütte]]')]) - python = v.to_python(other, None) - other2 = v.from_python(python, None) - assert other == other2 + self.assertEqual(self.value, rodelbahnbox_to_str(value)) + + +# Gasthausbox converter +# --------------------- + +class TestGasthausbox(unittest.TestCase): + def setUp(self): + self.maxDiff = None + self.value = \ +"""{{Gasthausbox +| Position = 47.123456 N 11.123456 E +| Höhe = 1808 +| Betreiber = Max Mustermann +| Sitzplätze = 50 +| Übernachtung = 20 Matrazenlager, 3 Doppelzimmer +| Rauchfrei = Ja +| Rodelverleih = 2 Euro (Ausweis erforderlich) +| Handyempfang = A1; T-Mobile A +| Homepage = http://www.birgitzeralm.at/ +| E-Mail = Nein +| Telefon = +43-664-5487520; +43-512-123456 (wenn geschlossen) +| Bild = Gasthaus_Birgitzer_Alm_03.jpg +| Rodelbahnen = [[Birgitzer Alm (vom Adelshof)]]; [[Birgitzer Alm (von Birgitz)]] +}}""" + + def test_from_str(self): + value = gasthausbox_from_str(self.value) + self.assertEqual(LonLat(11.123456, 47.123456), value['Position']) + self.assertEqual(1808, value['Höhe']) + self.assertEqual('Max Mustermann', value['Betreiber']) + self.assertEqual(50, value['Sitzplätze']) + self.assertEqual((True, '20 Matrazenlager, 3 Doppelzimmer'), value['Übernachtung']) + self.assertEqual((True, '2 Euro (Ausweis erforderlich)'), value['Rodelverleih']) + self.assertEqual(1.0, value['Rauchfrei']) + self.assertEqual([('A1', None), ('T-Mobile A', None)], value['Handyempfang']) + self.assertEqual((True, 'http://www.birgitzeralm.at/'), value['Homepage']) + self.assertEqual([], value['E-Mail']) + self.assertEqual([('+43-664-5487520', None), ('+43-512-123456', 'wenn geschlossen')], value['Telefon']) + self.assertEqual('Gasthaus_Birgitzer_Alm_03.jpg', value['Bild']) + self.assertEqual(['[[Birgitzer Alm (vom Adelshof)]]', '[[Birgitzer Alm (von Birgitz)]]'], value['Rodelbahnen']) + + def test_to_str(self): + value = OrderedDict([ + ('Position', LonLat(11.123456, 47.123456)), + ('Höhe', 1808), + ('Betreiber', 'Max Mustermann'), + ('Sitzplätze', 50), + ('Übernachtung', (True, '20 Matrazenlager, 3 Doppelzimmer')), + ('Rodelverleih', (True, '2 Euro (Ausweis erforderlich)')), + ('Rauchfrei', 1.0), + ('Handyempfang', [('A1', None), ('T-Mobile A', None)]), + ('Homepage', (True, 'http://www.birgitzeralm.at/')), + ('E-Mail', []), + ('Telefon', [('+43-664-5487520', None), ('+43-512-123456', 'wenn geschlossen')]), + ('Bild', 'Gasthaus_Birgitzer_Alm_03.jpg'), + ('Rodelbahnen', ['[[Birgitzer Alm (vom Adelshof)]]', '[[Birgitzer Alm (von Birgitz)]]'])]) + self.assertEqual(self.value, gasthausbox_to_str(value))