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