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