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