tests/test_wrvalidators.py

   1 #!/usr/bin/python3.4
   2 # -*- coding: iso-8859-15 -*-
   3 import collections
   4 import wrpylib.wrvalidators
   5 import unittest
   6 from wrpylib.wrvalidators import *
   7
   8 # TODO: optional converter
   9 # ------------------
  10
  11 # "no" converter
  12 # --------------
  13
  14 class TestNoGermanConverter(unittest.TestCase):
  15     def test_from_str(self):
  16         self.assertEqual((True, 'abc'), no_german_from_str('abc', req_str_from_str))
  17         self.assertEqual((False, None), no_german_from_str('Nein', req_str_from_str))
  18         with self.assertRaises(ValueError):
  19             no_german_from_str('', req_str_from_str)
  20
  21     def test_to_str(self):
  22         self.assertEqual('abc', no_german_to_str((True, 'abc'), str_to_str))
  23         self.assertEqual('Nein', no_german_to_str((False, None), str_to_str))
  24
  25
  26 # "optional"/"no" converter
  27 # -------------------------
  28
  29 class TestOptNoGerman(unittest.TestCase):
  30     def test_from_str(self):
  31         self.assertEqual((True, 'abc'), opt_no_german_from_str('abc', str_from_str))
  32         self.assertEqual((False, None), opt_no_german_from_str('Nein', str_from_str))
  33         self.assertEqual((None, None), opt_no_german_from_str('', str_from_str))
  34
  35     def test_to_str(self):
  36         self.assertEqual('abc', opt_no_german_to_str((True, 'abc'), str_to_str))
  37         self.assertEqual('Nein', opt_no_german_to_str((False, None), str_to_str))
  38         self.assertEqual('', opt_no_german_to_str((None, None), str_to_str))
  39
  40
  41 # TODO: choice converter
  42 # ----------------
  43
  44
  45 # TODO: dict converter
  46 # --------------
  47
  48
  49 # enum/"list" converter
  50 # ---------------------
  51
  52 class TestEnumConverter(unittest.TestCase):
  53     def test_from_str(self):
  54         self.assertEqual([], enum_from_str('', str_from_str))
  55         self.assertEqual(['abc'], enum_from_str('abc', str_from_str))
  56         self.assertEqual(['abc', 'def'], enum_from_str('abc; def', str_from_str))
  57         self.assertEqual(['abc', 'def', 'ghi'], enum_from_str('abc; def;ghi', str_from_str))
  58
  59     def test_to_str(self):
  60         self.assertEqual('abc; def; ghi', enum_to_str(['abc', 'def', 'ghi'], str_to_str))
  61         self.assertEqual('abc', enum_to_str(['abc'], str_to_str))
  62         self.assertEqual('', enum_to_str([''], str_to_str))
  63         self.assertEqual('', enum_to_str([], str_to_str))
  64
  65
  66 # value/comment converter
  67 # -----------------------
  68
  69 class TestValueCommentConverter(unittest.TestCase):
  70     def test_from_str(self):
  71         self.assertEqual(('abc', 'defg'), value_comment_from_str('abc (defg)', str_from_str, str_from_str))
  72         self.assertEqual(('abc', ''), value_comment_from_str('abc ()', str_from_str, str_from_str))
  73         self.assertEqual(('', 'def'), value_comment_from_str('(def)', str_from_str, str_from_str))
  74         self.assertEqual(('ab', '(cd)'), value_comment_from_str('ab((cd))', str_from_str, str_from_str))
  75         self.assertEqual(('ab', '(c(d)[(]))'), value_comment_from_str('ab((c(d)[(])))', str_from_str, str_from_str))
  76         self.assertEqual(('ab(', 'cd'), value_comment_from_str('ab((cd)', str_from_str, str_from_str))
  77         self.assertEqual(('abcd', 'ef'), value_comment_from_str('abcd  (ef) ', str_from_str, str_from_str))
  78         self.assertEqual(('abc', ''), value_comment_from_str('abc', str_from_str, str_from_str, comment_optional=True))
  79         with self.assertRaises(ValueError):
  80             value_comment_from_str('abc (', str_from_str, str_from_str)
  81         with self.assertRaises(ValueError):
  82             value_comment_from_str('abc )', str_from_str, str_from_str)
  83         with self.assertRaises(ValueError):
  84             value_comment_from_str('abc (def)g', str_from_str, str_from_str)
  85         with self.assertRaises(ValueError):
  86             value_comment_from_str('abc (b))', str_from_str, str_from_str)
  87         with self.assertRaises(ValueError):
  88             value_comment_from_str('abc', str_from_str, str_from_str)
  89
  90     def test_to_str(self):
  91         self.assertEqual('abc (defg)', value_comment_to_str(('abc', 'defg'), str_to_str, str_to_str))
  92         self.assertEqual('abc ()', value_comment_to_str(('abc', ''), str_to_str, str_to_str))
  93         self.assertEqual('(def)', value_comment_to_str(('', 'def'), str_to_str, str_to_str))
  94         self.assertEqual('ab ((cd))', value_comment_to_str(('ab', '(cd)'), str_to_str, str_to_str))
  95         self.assertEqual('ab ((c(d)[(])))', value_comment_to_str(('ab', '(c(d)[(]))'), str_to_str, str_to_str))
  96         self.assertEqual('ab( (cd)', value_comment_to_str(('ab(', 'cd'), str_to_str, str_to_str))
  97         self.assertEqual('abcd (ef)', value_comment_to_str(('abcd', 'ef'), str_to_str, str_to_str))
  98         self.assertEqual('abc', value_comment_to_str(('abc', ''), str_to_str, str_to_str, comment_optional=True))
  99
 100
 101 # string converter
 102 # ----------------
 103
 104 class TestStr(unittest.TestCase):
 105     def test_from_str(self):
 106         self.assertEqual('', str_from_str(''))
 107         self.assertEqual('abc', str_from_str('abc'))
 108
 109     def test_to_str(self):
 110         self.assertEqual('', str_to_str(''))
 111         self.assertEqual('abc', str_to_str('abc'))
 112
 113
 114 class TestReqStr(unittest.TestCase):
 115     def test_from_str(self):
 116         self.assertEqual('abc', req_str_from_str('abc'))
 117         self.assertEqual(' ', req_str_from_str(' '))
 118         with self.assertRaises(ValueError):
 119             req_str_from_str('')
 120
 121
 122 class TestOptStr(unittest.TestCase):
 123     def test_from_str(self):
 124         self.assertEqual('abc', opt_str_from_str('abc'))
 125         self.assertEqual(' ', opt_str_from_str(' '))
 126         self.assertEqual(None, opt_str_from_str(''))
 127
 128     def test_to_str(self):
 129         self.assertEqual('abc', opt_str_to_str('abc'))
 130         self.assertEqual(' ', opt_str_to_str(' '))
 131         self.assertEqual('', opt_str_to_str(None))
 132
 133
 134 # optional no or string converter
 135 # -------------------------------
 136
 137 class TestOptNoOrStr(unittest.TestCase):
 138     def test_from_str(self):
 139         self.assertEqual((False, None), opt_no_or_str_from_str('Nein'))
 140         self.assertEqual((True, 'Nur Wochenende'), opt_no_or_str_from_str('Nur Wochenende'))
 141         self.assertEqual((True, 'Ja'), opt_no_or_str_from_str('Ja'))
 142         self.assertEqual((None, None), opt_no_or_str_from_str(''))
 143
 144     def test_to_str(self):
 145         self.assertEqual('Nein', opt_no_or_str_to_str((False, None)))
 146         self.assertEqual('Nur Wochenende', opt_no_or_str_to_str((True, 'Nur Wochenende')))
 147         self.assertEqual('Ja', opt_no_or_str_to_str((True, 'Ja')))
 148         self.assertEqual('', opt_no_or_str_to_str((None, None)))
 149
 150
 151 # integer converter
 152 # -----------------
 153
 154 class TestInt(unittest.TestCase):
 155     def test_from_str(self):
 156         self.assertEqual(42, int_from_str('42'))
 157         self.assertEqual(42, int_from_str('+42'))
 158         self.assertEqual(-20, int_from_str('-20'))
 159         self.assertEqual(0, int_from_str('0', min=0))
 160         self.assertEqual(10, int_from_str('10', max=10))
 161         with self.assertRaises(ValueError):
 162             int_from_str('abc')
 163         with self.assertRaises(ValueError):
 164             int_from_str('')
 165         with self.assertRaises(ValueError):
 166             int_from_str('-1', min=0)
 167         with self.assertRaises(ValueError):
 168             int_from_str('11', max=10)
 169         with self.assertRaises(ValueError):
 170             int_from_str('10.0')
 171         with self.assertRaises(ValueError):
 172             int_from_str('0d')
 173
 174     def test_to_str(self):
 175         self.assertEqual('20', int_to_str(20))
 176         self.assertEqual('-20', int_to_str(-20))
 177         self.assertEqual('0', int_to_str(0))
 178
 179
 180 class TestOptInt(unittest.TestCase):
 181     def test_from_str(self):
 182         self.assertEqual(42, opt_int_from_str('42'))
 183         self.assertEqual(42, opt_int_from_str('+42'))
 184         self.assertEqual(-20, opt_int_from_str('-20'))
 185         self.assertEqual(None, opt_int_from_str(''))
 186         with self.assertRaises(ValueError):
 187             opt_int_from_str('abc')
 188         with self.assertRaises(ValueError):
 189             opt_int_from_str('10.0')
 190         with self.assertRaises(ValueError):
 191             opt_int_from_str('0d')
 192
 193     def test_to_str(self):
 194         self.assertEqual('20', opt_int_to_str(20))
 195         self.assertEqual('-20', opt_int_to_str(-20))
 196         self.assertEqual('0', opt_int_to_str(0))
 197         self.assertEqual('', opt_int_to_str(None))
 198
 199
 200 class TestOptUInt(unittest.TestCase):
 201     def test_from_str(self):
 202         self.assertEqual(42, opt_uint_from_str('42'))
 203         self.assertEqual(0, opt_uint_from_str('0'))
 204         self.assertEqual(None, opt_uint_from_str(''))
 205         with self.assertRaises(ValueError):
 206             opt_uint_from_str('-1')
 207
 208     def test_to_str(self):
 209         self.assertEqual('20', opt_uint_to_str(20))
 210         self.assertEqual('0', opt_uint_to_str(0))
 211         self.assertEqual('', opt_uint_to_str(None))
 212
 213
 214 # TODO: bool converter
 215 # --------------
 216
 217
 218 # tristate converter
 219 # ------------------
 220
 221 class TestTristateGerman(unittest.TestCase):
 222     def test_from_str(self):
 223         self.assertEqual(1.0, tristate_german_from_str('Ja'))
 224         self.assertEqual(0.5, tristate_german_from_str('Teilweise'))
 225         self.assertEqual(0, tristate_german_from_str('Nein'))
 226         with self.assertRaises(ValueError):
 227             tristate_german_from_str('')
 228         with self.assertRaises(ValueError):
 229             tristate_german_from_str('Vielleicht')
 230
 231     def test_to_str(self):
 232         self.assertEqual('Ja', tristate_german_to_str(1.0))
 233         self.assertEqual('Teilweise', tristate_german_to_str(0.5))
 234         self.assertEqual('Nein', tristate_german_to_str(0.0))
 235
 236
 237 class TestOptTristateGerman(unittest.TestCase):
 238     def test_from_str(self):
 239         self.assertEqual(1.0, opt_tristate_german_from_str('Ja'))
 240         self.assertEqual(0.5, opt_tristate_german_from_str('Teilweise'))
 241         self.assertEqual(0, opt_tristate_german_from_str('Nein'))
 242         self.assertEqual(None, opt_tristate_german_from_str(''))
 243         with self.assertRaises(ValueError):
 244             opt_tristate_german_from_str('Vielleicht')
 245
 246     def test_to_str(self):
 247         self.assertEqual('Ja', opt_tristate_german_to_str(1.0))
 248         self.assertEqual('Teilweise', opt_tristate_german_to_str(0.5))
 249         self.assertEqual('Nein', opt_tristate_german_to_str(0.0))
 250         self.assertEqual('', opt_tristate_german_to_str(None))
 251
 252
 253 # tristate with comment converter
 254 # -------------------------------
 255
 256 class TestOptTristateGermanComment(unittest.TestCase):
 257     def test_from_str(self):
 258         self.assertEqual((1.0, None), opt_tristate_german_comment_from_str('Ja'))
 259         self.assertEqual((0.5, None), opt_tristate_german_comment_from_str('Teilweise'))
 260         self.assertEqual((0, None), opt_tristate_german_comment_from_str('Nein'))
 261         self.assertEqual((0.5, 'nur ganz oben nicht'), opt_tristate_german_comment_from_str('Teilweise (nur ganz oben nicht)'))
 262         self.assertEqual((None, None), opt_tristate_german_comment_from_str(''))
 263         with self.assertRaises(ValueError):
 264             opt_tristate_german_from_str('Vielleicht')
 265         with self.assertRaises(ValueError):
 266             opt_tristate_german_from_str('(Ja)')
 267
 268     def test_to_str(self):
 269         self.assertEqual('Ja', opt_tristate_german_comment_to_str((1.0, None)))
 270         self.assertEqual('Teilweise', opt_tristate_german_comment_to_str((0.5, None)))
 271         self.assertEqual('Nein', opt_tristate_german_comment_to_str((0.0, None)))
 272         self.assertEqual('', opt_tristate_german_comment_to_str((None, None)))
 273
 274
 275 # url converter
 276 # -------------
 277
 278 class TestUrl(unittest.TestCase):
 279     def test_from_str(self):
 280         self.assertEqual('http://www.winterrodeln.org/wiki/Arzler_Alm/', url_from_str('http://www.winterrodeln.org/wiki/Arzler_Alm/'))
 281         self.assertEqual('http://www.winterrodeln.org/wiki/Nösslachhütte/', url_from_str('http://www.winterrodeln.org/wiki/Nösslachhütte/'))
 282         self.assertEqual('https://www.winterrodeln.org/wiki/Nösslachhütte/', url_from_str('https://www.winterrodeln.org/wiki/Nösslachhütte/'))
 283         with self.assertRaises(ValueError):
 284             url_from_str('mailto:office@example.com')
 285         with self.assertRaises(ValueError):
 286             url_from_str('/wiki/Arzler_Alm/')
 287
 288     def test_to_str(self):
 289         self.assertEqual('http://www.winterrodeln.org/wiki/Arzler_Alm/', url_to_str('http://www.winterrodeln.org/wiki/Arzler_Alm/'))
 290         self.assertEqual('http://www.winterrodeln.org/wiki/Nösslachhütte/', url_to_str('http://www.winterrodeln.org/wiki/Nösslachhütte/'))
 291         self.assertEqual('https://www.winterrodeln.org/wiki/Nösslachhütte/', url_to_str('https://www.winterrodeln.org/wiki/Nösslachhütte/'))
 292
 293
 294 # webauskunft converter
 295 # ---------------------
 296
 297 class TestWebauskunft(unittest.TestCase):
 298     def test_from_str(self):
 299         self.assertEqual((True, 'http://www.example.com/current'), webauskunft_from_str('http://www.example.com/current'))
 300         self.assertEqual((None, None), webauskunft_from_str(''))
 301         self.assertEqual((False, None), webauskunft_from_str('Nein'))
 302
 303     def test_to_str(self):
 304         self.assertEqual('http://www.example.com/current', webauskunft_to_str((True, 'http://www.example.com/current')))
 305         self.assertEqual('', webauskunft_to_str((None, None)))
 306         self.assertEqual('Nein', webauskunft_to_str((False, None)))
 307
 308
 309 # wikipage converter
 310 # ------------------
 311
 312 class TestWikipage(unittest.TestCase):
 313     def test_from_str(self):
 314         self.assertEqual('[[Birgitzer Alm]]', wikipage_from_str('[[Birgitzer Alm]]'))
 315         with self.assertRaises(ValueError):
 316             wikipage_from_str('[[')
 317         with self.assertRaises(ValueError):
 318             wikipage_from_str('')
 319         with self.assertRaises(ValueError):
 320             wikipage_from_str('Birgitzer Alm')
 321
 322     def test_to_str(self):
 323         self.assertEqual('[[Birgitzer Alm]]', wikipage_to_str('[[Birgitzer Alm]]'))
 324
 325
 326 class TestOptWikipageEnum(unittest.TestCase):
 327     def test_from_str(self):
 328         self.assertEqual(['[[Birgitzer Alm]]', '[[Kemater Alm]]'], opt_wikipage_enum_from_str('[[Birgitzer Alm]]; [[Kemater Alm]]'))
 329         self.assertEqual(['[[Birgitzer Alm]]'], opt_wikipage_enum_from_str('[[Birgitzer Alm]]'))
 330         self.assertEqual([], opt_wikipage_enum_from_str('Nein'))
 331         self.assertEqual(None, opt_wikipage_enum_from_str(''))
 332
 333     def test_to_str(self):
 334         self.assertEqual('[[Birgitzer Alm]]; [[Kemater Alm]]', opt_wikipage_enum_to_str(['[[Birgitzer Alm]]', '[[Kemater Alm]]']))
 335         self.assertEqual('[[Birgitzer Alm]]', opt_wikipage_enum_to_str(['[[Birgitzer Alm]]']))
 336         self.assertEqual('Nein', opt_wikipage_enum_to_str([]))
 337         self.assertEqual('', opt_wikipage_enum_to_str(None))
 338
 339
 340 # email converter
 341 # ---------------
 342
 343 class TestEmail(unittest.TestCase):
 344     def setUp(self):
 345         self.good_addresses = ['office@example.com', 'winter+rodeln@localhost', 'joe.doe@exämple.com']
 346         self.bad_addresses = ['öffice@example.com', 'winter rodeln@localhost', 'www.winterrodeln.org', 'mailto:info@example.com', 'info@example.com.']
 347
 348     def test_from_str(self):
 349         for value in self.good_addresses:
 350             self.assertEqual(value, email_from_str(value))
 351         for value in self.bad_addresses:
 352             with self.assertRaises(ValueError):
 353                 email_from_str(value)
 354
 355     def test_to_str(self):
 356         for value in self.good_addresses:
 357             self.assertEqual(value, email_to_str(value))
 358
 359
 360 class TestMaskedEmail(unittest.TestCase):
 361     def test_from_str(self):
 362         self.assertEqual(('office@example.com', False), masked_email_from_str('office@example.com'))
 363         self.assertEqual(('office@example.com', True), masked_email_from_str('office(at)example.com'))
 364         with self.assertRaises(ValueError):
 365             masked_email_from_str('office@example.com', masked_only=True)
 366         with self.assertRaises(ValueError):
 367             masked_email_from_str('off ice@example.com')
 368
 369     def test_to_str(self):
 370         self.assertEqual('office@example.com', masked_email_to_str(('office@example.com', False)))
 371         self.assertEqual('office(at)example.com', masked_email_to_str(('office@example.com', True)))
 372         self.assertEqual('office()example.com', masked_email_to_str(('office@example.com', True), '()'))
 373
 374
 375 class TestEmails(unittest.TestCase):
 376     def test_from_str(self):
 377         self.assertEqual(None, emails_from_str(''))
 378         self.assertEqual([], emails_from_str('Nein'))
 379         self.assertEqual([(('info@example.com', False), None)], emails_from_str('info@example.com'))
 380         self.assertEqual([(('info@example.com', True), None)], emails_from_str('info(at)example.com'))
 381         self.assertEqual([(('info@example.com', False), 'Office')], emails_from_str('info@example.com (Office)'))
 382         self.assertEqual([(('info@example.com', False), None), (('home@example.com', False), 'Privat')], emails_from_str('info@example.com; home@example.com (Privat)'))
 383         with self.assertRaises(ValueError):
 384             emails_from_str('nein')
 385         with self.assertRaises(ValueError):
 386             emails_from_str('info@example.com; ho me@example.com (Privat)')
 387
 388     def test_to_str(self):
 389         self.assertEqual('', emails_to_str(None))
 390         self.assertEqual('Nein', emails_to_str([]))
 391         self.assertEqual('info@example.com', emails_to_str([(('info@example.com', False), None)]))
 392         self.assertEqual('info@example.com (Office)', emails_to_str([(('info@example.com', False), 'Office')]))
 393         self.assertEqual('info@example.com; home@example.com (Privat)', emails_to_str([(('info@example.com', False), None), (('home@example.com', False), 'Privat')]))
 394
 395
 396 # phone converter
 397 # ---------------
 398
 399 class TestPhoneNumber(unittest.TestCase):
 400     def test_from_str(self):
 401         self.assertEqual('+43-699-123456789', phone_number_from_str('+43-699-123456789'))
 402         self.assertEqual('+43-69945', phone_number_from_str('+43-69945'))
 403         self.assertEqual('+43-512-507-6418', phone_number_from_str('+43-512-507-6418'))
 404         with self.assertRaises(ValueError):
 405             phone_number_from_str('+43-')
 406         with self.assertRaises(ValueError):
 407             phone_number_from_str('0512123456789')
 408
 409     def test_to_str(self):
 410         self.assertEqual('+43-699-123456789', phone_number_to_str('+43-699-123456789'))
 411         self.assertEqual('+43-69945', phone_number_to_str('+43-69945'))
 412         self.assertEqual('+43-512-507-6418', phone_number_to_str('+43-512-507-6418'))
 413
 414
 415 class TestOptPhoneCommentEnum(unittest.TestCase):
 416     def test_from_str(self):
 417         self.assertEqual(opt_phone_comment_enum_from_str(''), None)
 418         self.assertEqual([], opt_phone_comment_enum_from_str('Nein'))
 419         self.assertEqual([('+43-512-123456', 'untertags')], opt_phone_comment_enum_from_str('+43-512-123456 (untertags)'))
 420         self.assertEqual([('+43-512-1234', 'untertags'), ('+43-664-123456', 'Alm')], opt_phone_comment_enum_from_str('+43-512-1234 (untertags); +43-664-123456 (Alm)'))
 421         self.assertEqual([('+43-512-1234', None), ('+43-664-123456', 'Sommer')], opt_phone_comment_enum_from_str('+43-512-1234; +43-664-123456 (Sommer)', True))
 422         with self.assertRaises(ValueError):
 423             opt_phone_comment_enum_from_str('+43-512-123456+ (untertags)')
 424         with self.assertRaises(ValueError):
 425             opt_phone_comment_enum_from_str('+43-512-123456')
 426
 427     def test_to_str(self):
 428         self.assertEqual('', opt_phone_comment_enum_to_str(None))
 429         self.assertEqual('Nein', opt_phone_comment_enum_to_str([]))
 430         self.assertEqual('+43-512-123456 (untertags)', opt_phone_comment_enum_to_str([('+43-512-123456', 'untertags')]))
 431         self.assertEqual('+43-512-1234 (untertags); +43-664-123456 (Alm)', opt_phone_comment_enum_to_str([('+43-512-1234', 'untertags'), ('+43-664-123456', 'Alm')]))
 432         self.assertEqual('+43-512-1234; +43-664-123456 (Sommer)', opt_phone_comment_enum_to_str([('+43-512-1234', None), ('+43-664-123456', 'Sommer')], True))
 433
 434
 435 # longitude/latitude converter
 436 # ----------------------------
 437
 438 class TestLonLat(unittest.TestCase):
 439     def test_from_str(self):
 440         self.assertEqual(LonLat(11.453553, 47.076207), lonlat_from_str('47.076207 N 11.453553 E'))
 441         with self.assertRaises(ValueError):
 442             lonlat_from_str('47.076207 N 11.453553')
 443
 444     def test_to_str(self):
 445         self.assertEqual('47.076207 N 11.453553 E', lonlat_to_str(LonLat(11.453553, 47.076207)))
 446
 447
 448 # difficulty converter
 449 # --------------------
 450
 451 class TestDifficultyGerman(unittest.TestCase):
 452     def test_from_str(self):
 453         self.assertEqual(1, difficulty_german_from_str('leicht'))
 454         self.assertEqual(2, difficulty_german_from_str('mittel'))
 455         with self.assertRaises(ValueError):
 456             difficulty_german_from_str('dontknow')
 457         with self.assertRaises(ValueError):
 458             difficulty_german_from_str('')
 459
 460     def test_to_str(self):
 461         self.assertEqual('leicht', difficulty_german_to_str(1))
 462
 463
 464 # TODO: avalanches converter
 465 # --------------------
 466
 467
 468
 469 # lift converter
 470 # --------------
 471
 472 class TestLiftGermanValidator(unittest.TestCase):
 473     def test_from_str(self):
 474         self.assertEqual(lift_german_from_str(''), None)
 475         self.assertEqual([], lift_german_from_str('Nein'))
 476         self.assertEqual([('Sessellift', None)], lift_german_from_str('Sessellift'))
 477         self.assertEqual([('Gondel', 'nur bis zur Hälfte')], lift_german_from_str('Gondel (nur bis zur Hälfte)'))
 478         self.assertEqual([('Sessellift', None), ('Taxi', None)], lift_german_from_str('Sessellift; Taxi'))
 479         self.assertEqual([('Sessellift', 'Wochenende'), ('Taxi', '6 Euro')], lift_german_from_str('Sessellift (Wochenende); Taxi (6 Euro)'))
 480
 481     def test_to_str(self):
 482         self.assertEqual('', lift_german_to_str(None))
 483         self.assertEqual('Nein', lift_german_to_str([]))
 484         self.assertEqual('Sessellift', lift_german_to_str([('Sessellift', None)]))
 485         self.assertEqual('Gondel (nur bis zur Hälfte)', lift_german_to_str([('Gondel', 'nur bis zur Hälfte')]))
 486         self.assertEqual('Sessellift; Taxi', lift_german_to_str([('Sessellift', None), ('Taxi', None)]))
 487         self.assertEqual('Sessellift (Wochenende); Taxi (6 Euro)', lift_german_to_str([('Sessellift', 'Wochenende'), ('Taxi', '6 Euro')]))
 488
 489
 490 # TODO: public transport converter
 491 # --------------------------
 492
 493
 494 # cachet converter
 495 # ----------------
 496
 497 class TestSingleCachet(unittest.TestCase):
 498     def test_from_str(self):
 499         self.assertEqual(('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel'), single_cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 2009 mittel'))
 500         self.assertEqual(('Tiroler Naturrodelbahn-Gütesiegel', '2013', 'schwer'), single_cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 2013 schwer'))
 501         with self.assertRaises(ValueError):
 502             single_cachet_german_from_str('')
 503         with self.assertRaises(ValueError):
 504             single_cachet_german_from_str('Salzburger Naturrodelbahn-Gütesiegel 2013 schwer')
 505         with self.assertRaises(ValueError):
 506             single_cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 4013 schwer')
 507         with self.assertRaises(ValueError):
 508             single_cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 13 schwer')
 509         with self.assertRaises(ValueError):
 510             single_cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 2013 schwerer')
 511
 512     def test_to_str(self):
 513         self.assertEqual('Tiroler Naturrodelbahn-Gütesiegel 2009 mittel', single_cachet_german_to_str(('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')))
 514         self.assertEqual('Tiroler Naturrodelbahn-Gütesiegel 2013 schwer', single_cachet_german_to_str(('Tiroler Naturrodelbahn-Gütesiegel', '2013', 'schwer')))
 515
 516
 517 class TestCachetGerman(unittest.TestCase):
 518     def test_from_str(self):
 519         self.assertEqual(cachet_german_from_str(''), None)
 520         self.assertEqual([], cachet_german_from_str('Nein'))
 521         self.assertEqual([('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')], cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 2009 mittel'))
 522         self.assertEqual([('Tiroler Naturrodelbahn-Gütesiegel', '2013', 'schwer'), ('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')],
 523                          cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 2013 schwer; Tiroler Naturrodelbahn-Gütesiegel 2009 mittel'))
 524         with self.assertRaises(ValueError):
 525             cachet_german_from_str('Ja')
 526         with self.assertRaises(ValueError):
 527             cachet_german_from_str('Tiroler Naturrodelbahn-Gütesiegel 2013 schwer Tiroler Naturrodelbahn-Gütesiegel 2009 mittel')
 528
 529     def test_to_str(self):
 530         self.assertEqual('', cachet_german_to_str(None))
 531         self.assertEqual('Nein', cachet_german_to_str([]))
 532         self.assertEqual('Tiroler Naturrodelbahn-Gütesiegel 2009 mittel', cachet_german_to_str([('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')]))
 533         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')]))
 534
 535
 536 # night light days converter
 537 # --------------------------
 538
 539 class TestNightLightDays(unittest.TestCase):
 540     def test_from_str(self):
 541         self.assertEqual((None, None), nightlightdays_from_str(''))
 542         self.assertEqual((2, 'Mo, Di'), nightlightdays_from_str('2 (Mo, Di)'))
 543         self.assertEqual((7, None), nightlightdays_from_str('7'))
 544         self.assertEqual((0, None), nightlightdays_from_str('0'))
 545         self.assertEqual((None, 'keine Ahnung'), nightlightdays_from_str('(keine Ahnung)'))
 546         with self.assertRaises(ValueError):
 547             nightlightdays_from_str('8')
 548         with self.assertRaises(ValueError):
 549             nightlightdays_from_str('5 (Montag')
 550         with self.assertRaises(ValueError):
 551             nightlightdays_from_str('5.2')
 552
 553     def test_to_str(self):
 554         self.assertEqual('', nightlightdays_to_str((None, None)))
 555         self.assertEqual('2 (Mo, Di)', nightlightdays_to_str((2, 'Mo, Di')))
 556         self.assertEqual('7', nightlightdays_to_str((7, None)))
 557         self.assertEqual('0', nightlightdays_to_str((0, None)))
 558
 559
 560 # string with optional comment enum/list converter
 561 # ------------------------------------------------
 562
 563 class TestOptStrOptCommentEnum(unittest.TestCase):
 564     def test_from_str(self):
 565         self.assertEqual(None, opt_str_opt_comment_enum_from_str(''))
 566         self.assertEqual([], opt_str_opt_comment_enum_from_str('Nein'))
 567         self.assertEqual([('Talstation', None)], opt_str_opt_comment_enum_from_str('Talstation'))
 568         self.assertEqual([('Talstation', 'unten')], opt_str_opt_comment_enum_from_str('Talstation (unten)'))
 569         self.assertEqual([('Talstation', 'unten'), ('Mittelstation', None)], opt_str_opt_comment_enum_from_str('Talstation (unten); Mittelstation'))
 570         with self.assertRaises(ValueError):
 571             opt_str_opt_comment_enum_from_str('(unten)')
 572         with self.assertRaises(ValueError):
 573             opt_str_opt_comment_enum_from_str('Talstation (unten); ; Mittelstation')
 574
 575     def test_to_str(self):
 576         self.assertEqual('', opt_str_opt_comment_enum_to_str(None))
 577         self.assertEqual('Nein', opt_str_opt_comment_enum_to_str([]))
 578         self.assertEqual('Talstation', opt_str_opt_comment_enum_to_str([('Talstation', None)]))
 579         self.assertEqual('Talstation (unten)', opt_str_opt_comment_enum_to_str([('Talstation', 'unten')]))
 580         self.assertEqual('Talstation (unten); Mittelstation', opt_str_opt_comment_enum_to_str([('Talstation', 'unten'), ('Mittelstation', None)]))
 581
 582
 583 # wikibox converter
 584 # -----------------
 585
 586 class TestWikibox(unittest.TestCase):
 587     def test_from_str(self):
 588         value = '{{MyTemplate|apple=2|banana=5}}'
 589         converter_dict = OrderedDict([('apple', opt_uint_converter), ('banana', opt_uint_converter)])
 590         result = wikibox_from_str(value, 'MyTemplate', converter_dict)
 591         self.assertEqual(2, result['apple'])
 592         self.assertEqual(5, result['banana'])
 593
 594         value = '{{MyTemplate\n | apple = 2 \n| banana = 5 }}'
 595         result = wikibox_from_str(value, 'MyTemplate', converter_dict)
 596         self.assertEqual(2, result['apple'])
 597         self.assertEqual(5, result['banana'])
 598
 599         with self.assertRaises(ValueError):
 600             wikibox_from_str(value, 'myTemplate', converter_dict)
 601         with self.assertRaises(ValueError):
 602             value = '{{MyTemplate|apple=2|banana=five}}'
 603             wikibox_from_str(value, 'MyTemplate', converter_dict)
 604         with self.assertRaises(ValueError):
 605             value = '{{MyTemplate|apple=2}}'
 606             wikibox_from_str(value, 'MyTemplate', converter_dict)
 607         with self.assertRaises(ValueError):
 608             value = '{{MyTemplate|apple=2|banana=5|cherry=6}}'
 609             wikibox_from_str(value, 'MyTemplate', converter_dict)
 610
 611     def test_to_str(self):
 612         value = OrderedDict([('apple', 2), ('banana', 5)])
 613         converter_dict = OrderedDict([('apple', opt_uint_converter), ('banana', opt_uint_converter)])
 614         result = wikibox_to_str(value, 'MyTemplate', converter_dict)
 615         self.assertEqual('{{MyTemplate|apple=2|banana=5}}', result)
 616
 617
 618 # Rodelbahnbox converter
 619 # ----------------------
 620
 621 class TestRodelbahnbox(unittest.TestCase):
 622     def setUp(self):
 623         self.maxDiff = None
 624         self.value = \
 625 '''{{Rodelbahnbox
 626 | Position             = 46.807218 N 12.806522 E
 627 | Position oben        = 46.799014 N 12.818658 E
 628 | Höhe oben            = 1046
 629 | Position unten       =
 630 | Höhe unten           =
 631 | Länge                = 3500
 632 | Schwierigkeit        = mittel
 633 | Lawinen              = kaum
 634 | Betreiber            = Bringungsgemeinschaft Kreithof-Dolomitenhütte
 635 | Öffentliche Anreise  = Schlecht
 636 | Aufstieg möglich     = Ja
 637 | Aufstieg getrennt    = Teilweise
 638 | Gehzeit              = 75
 639 | Aufstiegshilfe       = Taxi; Sonstige (PKW bis Kreithof)
 640 | Beleuchtungsanlage   = Ja
 641 | Beleuchtungstage     = 7
 642 | Rodelverleih         = Nein
 643 | Gütesiegel           = Tiroler Naturrodelbahn-Gütesiegel 2009 mittel
 644 | Webauskunft          = http://www.lienzerdolomiten.info/at/tobogorpt.html
 645 | Telefonauskunft      = +43-664-2253782 (Dolomitenhütte)
 646 | Bild                 = Dolomitenrodelbahn Tristach 2011-12-22 oberer Bereich.jpg
 647 | In Übersichtskarte   = Ja
 648 | Forumid              = 139
 649 }}'''
 650
 651     def test_from_str(self):
 652         value = rodelbahnbox_from_str(self.value)
 653         self.assertEqual(LonLat(12.806522, 46.807218), value['Position'])
 654         self.assertEqual(LonLat(12.818658, 46.799014), value['Position oben'])
 655         self.assertEqual(1046, value['Höhe oben'])
 656         self.assertEqual(LonLat(None, None), value['Position unten'])
 657         self.assertEqual(None, value['Höhe unten'])
 658         self.assertEqual(3500, value['Länge'])
 659         self.assertEqual(2, value['Schwierigkeit'])
 660         self.assertEqual(1, value['Lawinen'])
 661         self.assertEqual('Bringungsgemeinschaft Kreithof-Dolomitenhütte', value['Betreiber'])
 662         self.assertEqual(4, value['Öffentliche Anreise'])
 663         self.assertEqual(True, value['Aufstieg möglich'])
 664         self.assertEqual((0.5, None), value['Aufstieg getrennt'])
 665         self.assertEqual(75, value['Gehzeit'])
 666         self.assertEqual([('Taxi', None), ('Sonstige', 'PKW bis Kreithof')], value['Aufstiegshilfe'])
 667         self.assertEqual((1.0, None), value['Beleuchtungsanlage'])
 668         self.assertEqual((7, None), value['Beleuchtungstage'])
 669         self.assertEqual([], value['Rodelverleih'])
 670         self.assertEqual([('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')], value['Gütesiegel'])
 671         self.assertEqual((True, 'http://www.lienzerdolomiten.info/at/tobogorpt.html'), value['Webauskunft'])
 672         self.assertEqual([('+43-664-2253782', 'Dolomitenhütte')], value['Telefonauskunft'])
 673         self.assertEqual('Dolomitenrodelbahn Tristach 2011-12-22 oberer Bereich.jpg', value['Bild'])
 674         self.assertEqual(True, value['In Übersichtskarte'])
 675         self.assertEqual(139, value['Forumid'])
 676
 677     def test_to_str(self):
 678         value = OrderedDict([
 679             ('Position', LonLat(12.806522, 46.807218)),
 680             ('Position oben', LonLat(12.818658, 46.799014)),
 681             ('Höhe oben', 1046),
 682             ('Position unten', LonLat(None, None)),
 683             ('Höhe unten', None),
 684             ('Länge', 3500),
 685             ('Schwierigkeit', 2),
 686             ('Lawinen', 1),
 687             ('Betreiber', 'Bringungsgemeinschaft Kreithof-Dolomitenhütte'),
 688             ('Öffentliche Anreise', 4),
 689             ('Aufstieg möglich', True),
 690             ('Aufstieg getrennt', (0.5, None)),
 691             ('Gehzeit', 75),
 692             ('Aufstiegshilfe', [('Taxi', None), ('Sonstige', 'PKW bis Kreithof')]),
 693             ('Beleuchtungsanlage', (1.0, None)),
 694             ('Beleuchtungstage', (7, None)),
 695             ('Rodelverleih', []),
 696             ('Gütesiegel', [('Tiroler Naturrodelbahn-Gütesiegel', '2009', 'mittel')]),
 697             ('Webauskunft', (True, 'http://www.lienzerdolomiten.info/at/tobogorpt.html')),
 698             ('Telefonauskunft', [('+43-664-2253782', 'Dolomitenhütte')]),
 699             ('Bild', 'Dolomitenrodelbahn Tristach 2011-12-22 oberer Bereich.jpg'),
 700             ('In Übersichtskarte', True),
 701             ('Forumid', 139)])
 702         self.assertEqual(self.value, rodelbahnbox_to_str(value))
 703
 704
 705 # TODO: Gasthausbox converter
 706 # ---------------------
 707
 708 class TestGasthausbox(unittest.TestCase):
 709     def setUp(self):
 710         self.maxDiff = None
 711         self.value = \
 712 """{{Gasthausbox
 713 | Position          = 47.123456 N 11.123456 E
 714 | Höhe              = 1808
 715 | Betreiber         = Max Mustermann
 716 | Sitzplätze        = 50
 717 | Übernachtung      = 20 Matrazenlager, 3 Doppelzimmer
 718 | Rauchfrei         = Ja
 719 | Rodelverleih      = 2 Euro (Ausweis erforderlich)
 720 | Handyempfang      = A1; T-Mobile A
 721 | Homepage          = http://www.birgitzeralm.at/
 722 | E-Mail            = Nein
 723 | Telefon           = +43-664-5487520; +43-512-123456 (wenn geschlossen)
 724 | Bild              = Gasthaus_Birgitzer_Alm_03.jpg
 725 | Rodelbahnen       = [[Birgitzer Alm (vom Adelshof)]]; [[Birgitzer Alm (von Birgitz)]]
 726 }}"""
 727
 728     def test_from_str(self):
 729         value = gasthausbox_from_str(self.value)
 730         self.assertEqual(LonLat(11.123456, 47.123456), value['Position'])
 731         self.assertEqual(1808, value['Höhe'])
 732         self.assertEqual('Max Mustermann', value['Betreiber'])
 733         self.assertEqual(50, value['Sitzplätze'])
 734         self.assertEqual((True, '20 Matrazenlager, 3 Doppelzimmer'), value['Übernachtung'])
 735         self.assertEqual((True, '2 Euro (Ausweis erforderlich)'), value['Rodelverleih'])
 736         self.assertEqual(1.0, value['Rauchfrei'])
 737         self.assertEqual([('A1', None), ('T-Mobile A', None)], value['Handyempfang'])
 738         self.assertEqual((True, 'http://www.birgitzeralm.at/'), value['Homepage'])
 739         self.assertEqual([], value['E-Mail'])
 740         self.assertEqual([('+43-664-5487520', None), ('+43-512-123456', 'wenn geschlossen')], value['Telefon'])
 741         self.assertEqual('Gasthaus_Birgitzer_Alm_03.jpg', value['Bild'])
 742         self.assertEqual(['[[Birgitzer Alm (vom Adelshof)]]', '[[Birgitzer Alm (von Birgitz)]]'], value['Rodelbahnen'])
 743
 744     def test_to_str(self):
 745         value = OrderedDict([
 746             ('Position', LonLat(11.123456, 47.123456)),
 747             ('Höhe', 1808),
 748             ('Betreiber', 'Max Mustermann'),
 749             ('Sitzplätze', 50),
 750             ('Übernachtung', (True, '20 Matrazenlager, 3 Doppelzimmer')),
 751             ('Rodelverleih', (True, '2 Euro (Ausweis erforderlich)')),
 752             ('Rauchfrei', 1.0),
 753             ('Handyempfang', [('A1', None), ('T-Mobile A', None)]),
 754             ('Homepage', (True, 'http://www.birgitzeralm.at/')),
 755             ('E-Mail', []),
 756             ('Telefon', [('+43-664-5487520', None), ('+43-512-123456', 'wenn geschlossen')]),
 757             ('Bild', 'Gasthaus_Birgitzer_Alm_03.jpg'),
 758             ('Rodelbahnen', ['[[Birgitzer Alm (vom Adelshof)]]', '[[Birgitzer Alm (von Birgitz)]]'])])
 759         self.assertEqual(self.value, gasthausbox_to_str(value))