source: wokkel/test/test_data_form.py @ 78:c85ce41a75bc

Last change on this file since 78:c85ce41a75bc was 78:c85ce41a75bc, checked in by Ralph Meijer <ralphm@…>, 13 years ago

Add missing tests for Data Forms and correct some minor issues.

File size: 27.6 KB
Line 
1# Copyright (c) 2003-2010 Ralph Meijer
2# See LICENSE for details.
3
4"""
5Tests for {wokkel.data_form}.
6"""
7
8from twisted.trial import unittest
9from twisted.words.xish import domish
10from twisted.words.protocols.jabber import jid
11
12from wokkel import data_form
13
14NS_X_DATA = 'jabber:x:data'
15
16class OptionTest(unittest.TestCase):
17    """
18    Tests for L{data_form.Option}.
19    """
20
21    def test_toElement(self):
22        """
23        An option is an option element with a value child with the option value.
24        """
25        option = data_form.Option('value')
26        element = option.toElement()
27
28        self.assertEqual('option', element.name)
29        self.assertEqual(NS_X_DATA, element.uri)
30        self.assertEqual(NS_X_DATA, element.value.uri)
31        self.assertEqual('value', unicode(element.value))
32        self.assertFalse(element.hasAttribute('label'))
33
34
35    def test_toElementLabel(self):
36        """
37        A label is rendered as an attribute on the option element.
38        """
39        option = data_form.Option('value', 'label')
40        element = option.toElement()
41
42        self.assertEqual('option', element.name)
43        self.assertEqual(NS_X_DATA, element.uri)
44        self.assertEqual(NS_X_DATA, element.value.uri)
45        self.assertEqual('value', unicode(element.value))
46        self.assertEqual('label', element['label'])
47
48
49    def test_fromElement(self):
50        """
51        An option has a child element with the option value.
52        """
53        element = domish.Element((NS_X_DATA, 'option'))
54        element.addElement('value', content='value')
55        option = data_form.Option.fromElement(element)
56
57        self.assertEqual('value', option.value)
58        self.assertIdentical(None, option.label)
59
60
61    def test_fromElementLabel(self):
62        """
63        An option label is an attribute on the option element.
64        """
65
66        element = domish.Element((NS_X_DATA, 'option'))
67        element.addElement('value', content='value')
68        element['label'] = 'label'
69        option = data_form.Option.fromElement(element)
70
71        self.assertEqual('label', option.label)
72
73
74    def test_fromElementNoValue(self):
75        """
76        An option MUST have a value.
77        """
78        element = domish.Element((NS_X_DATA, 'option'))
79        self.assertRaises(data_form.Error,
80                          data_form.Option.fromElement, element)
81
82
83    def test_repr(self):
84        """
85        The representation of an Option is equal to how it is created.
86        """
87        option = data_form.Option('value', 'label')
88        self.assertEqual("""Option('value', 'label')""", repr(option))
89
90
91
92class FieldTest(unittest.TestCase):
93    """
94    Tests for L{data_form.Field}.
95    """
96
97    def test_basic(self):
98        """
99        Test basic field initialization.
100        """
101        field = data_form.Field(var='test')
102        self.assertEqual('text-single', field.fieldType)
103        self.assertEqual('test', field.var)
104
105
106    def test_repr(self):
107        """
108        The repr of a field should be equal to its initialization.
109        """
110        field = data_form.Field('list-single', var='test', label='label',
111                               desc='desc', required=True, value='test',
112                               options=[data_form.Option('test')])
113        self.assertEqual("""Field(fieldType='list-single', """
114                         """var='test', label='label', """
115                         """desc='desc', required=True, """
116                         """values=['test'], """
117                         """options=[Option('test')])""",
118                         repr(field))
119
120
121    def test_toElement(self):
122        """
123        Test rendering to a DOM.
124        """
125        field = data_form.Field(var='test')
126        element = field.toElement()
127
128        self.assertTrue(domish.IElement.providedBy(element))
129        self.assertEquals('field', element.name)
130        self.assertEquals(NS_X_DATA, element.uri)
131        self.assertEquals('text-single',
132                          element.getAttribute('type', 'text-single'))
133        self.assertEquals('test', element['var'])
134        self.assertEquals([], element.children)
135
136
137    def test_toElementTypeNotListSingle(self):
138        """
139        Always render the field type, if different from list-single.
140        """
141        field = data_form.Field('hidden', var='test')
142        element = field.toElement()
143
144        self.assertEquals('hidden', element.getAttribute('type'))
145
146
147    def test_toElementAsForm(self):
148        """
149        Always render the field type, if asForm is True.
150        """
151        field = data_form.Field(var='test')
152        element = field.toElement(True)
153
154        self.assertEquals('text-single', element.getAttribute('type'))
155
156
157    def test_toElementOptions(self):
158        """
159        Test rendering to a DOM with options.
160        """
161        field = data_form.Field('list-single', var='test')
162        field.options = [data_form.Option(u'option1'),
163                         data_form.Option(u'option2')]
164        element = field.toElement(True)
165
166        self.assertEqual(2, len(element.children))
167
168
169    def test_toElementLabel(self):
170        """
171        Test rendering to a DOM with a label.
172        """
173        field = data_form.Field(var='test', label=u'my label')
174        element = field.toElement(True)
175
176        self.assertEqual(u'my label', element.getAttribute('label'))
177
178
179    def test_toElementDescription(self):
180        """
181        Test rendering to a DOM with options.
182        """
183        field = data_form.Field(var='test', desc=u'My desc')
184        element = field.toElement(True)
185
186        self.assertEqual(1, len(element.children))
187        child = element.children[0]
188        self.assertEqual('desc', child.name)
189        self.assertEqual(NS_X_DATA, child.uri)
190        self.assertEqual(u'My desc', unicode(child))
191
192
193    def test_toElementRequired(self):
194        """
195        Test rendering to a DOM with options.
196        """
197        field = data_form.Field(var='test', required=True)
198        element = field.toElement(True)
199
200        self.assertEqual(1, len(element.children))
201        child = element.children[0]
202        self.assertEqual('required', child.name)
203        self.assertEqual(NS_X_DATA, child.uri)
204
205
206    def test_toElementJID(self):
207        """
208        A JID value should render to text.
209        """
210        field = data_form.Field(fieldType='jid-single', var='test',
211                                value=jid.JID(u'test@example.org'))
212        element = field.toElement()
213        self.assertEqual(u'test@example.org', unicode(element.value))
214
215
216    def test_toElementJIDTextSingle(self):
217        """
218        A JID value should render to text if field type is text-single.
219        """
220        field = data_form.Field(fieldType='text-single', var='test',
221                                value=jid.JID(u'test@example.org'))
222        element = field.toElement()
223        self.assertEqual(u'test@example.org', unicode(element.value))
224
225
226    def test_toElementBoolean(self):
227        """
228        A boolean value should render to text.
229        """
230        field = data_form.Field(fieldType='boolean', var='test',
231                                value=True)
232        element = field.toElement()
233        self.assertEqual(u'true', unicode(element.value))
234
235
236    def test_toElementBooleanTextSingle(self):
237        """
238        A boolean value should render to text if the field type is text-single.
239        """
240        field = data_form.Field(var='test', value=True)
241        element = field.toElement()
242        self.assertEqual(u'true', unicode(element.value))
243
244
245    def test_typeCheckNoFieldName(self):
246        """
247        A field not of type fixed must have a var.
248        """
249        field = data_form.Field(fieldType='list-single')
250        self.assertRaises(data_form.FieldNameRequiredError, field.typeCheck)
251
252
253    def test_typeCheckTooManyValues(self):
254        """
255        Expect an exception if too many values are set, depending on type.
256        """
257        field = data_form.Field(fieldType='list-single', var='test',
258                                values=[u'value1', u'value2'])
259        self.assertRaises(data_form.TooManyValuesError, field.typeCheck)
260
261
262    def test_typeCheckBooleanFalse(self):
263        """
264        Test possible False values for a boolean field.
265        """
266        field = data_form.Field(fieldType='boolean', var='test')
267
268        for value in (False, 0, '0', 'false', 'False', []):
269            field.value = value
270            field.typeCheck()
271            self.assertIsInstance(field.value, bool)
272            self.assertFalse(field.value)
273
274
275    def test_typeCheckBooleanTrue(self):
276        """
277        Test possible True values for a boolean field.
278        """
279        field = data_form.Field(fieldType='boolean', var='test')
280
281        for value in (True, 1, '1', 'true', 'True', ['test']):
282            field.value = value
283            field.typeCheck()
284            self.assertIsInstance(field.value, bool)
285            self.assertTrue(field.value)
286
287
288    def test_typeCheckBooleanBad(self):
289        """
290        A bad value for a boolean field should raise a ValueError
291        """
292        field = data_form.Field(fieldType='boolean', var='test')
293        field.value = 'test'
294        self.assertRaises(ValueError, field.typeCheck)
295
296
297    def test_typeCheckJID(self):
298        """
299        The value of jid field should be a JID or coercable to one.
300        """
301        field = data_form.Field(fieldType='jid-single', var='test',
302                                value=jid.JID('test@example.org'))
303        field.typeCheck()
304
305
306    def test_typeCheckJIDString(self):
307        """
308        The string value of jid field should be coercable into a JID.
309        """
310        field = data_form.Field(fieldType='jid-single', var='test',
311                                value='test@example.org')
312        field.typeCheck()
313        self.assertEquals(jid.JID(u'test@example.org'), field.value)
314
315
316    def test_typeCheckJIDBad(self):
317        """
318        An invalid JID string should raise an exception.
319        """
320        field = data_form.Field(fieldType='jid-single', var='test',
321                                value='test@@example.org')
322        self.assertRaises(jid.InvalidFormat, field.typeCheck)
323
324
325    def test_fromElementType(self):
326        element = domish.Element((NS_X_DATA, 'field'))
327        element['type'] = 'fixed'
328        field = data_form.Field.fromElement(element)
329        self.assertEquals('fixed', field.fieldType)
330
331
332    def test_fromElementNoType(self):
333        element = domish.Element((NS_X_DATA, 'field'))
334        field = data_form.Field.fromElement(element)
335        self.assertEquals(None, field.fieldType)
336
337
338    def test_fromElementValueTextSingle(self):
339        """
340        Parsed text-single field values should be of type C{unicode}.
341        """
342        element = domish.Element((NS_X_DATA, 'field'))
343        element['type'] = 'text-single'
344        element.addElement('value', content=u'text')
345        field = data_form.Field.fromElement(element)
346        self.assertEquals('text', field.value)
347
348
349    def test_fromElementValueJID(self):
350        """
351        Parsed jid-single field values should be of type C{unicode}.
352        """
353        element = domish.Element((NS_X_DATA, 'field'))
354        element['type'] = 'jid-single'
355        element.addElement('value', content=u'user@example.org')
356        field = data_form.Field.fromElement(element)
357        self.assertEquals(u'user@example.org', field.value)
358
359
360    def test_fromElementValueJIDMalformed(self):
361        """
362        Parsed jid-single field values should be of type C{unicode}.
363
364        No validation should be done at this point, so invalid JIDs should
365        also be passed as-is.
366        """
367        element = domish.Element((NS_X_DATA, 'field'))
368        element['type'] = 'jid-single'
369        element.addElement('value', content=u'@@')
370        field = data_form.Field.fromElement(element)
371        self.assertEquals(u'@@', field.value)
372
373
374    def test_fromElementValueBoolean(self):
375        """
376        Parsed boolean field values should be of type C{unicode}.
377        """
378        element = domish.Element((NS_X_DATA, 'field'))
379        element['type'] = 'boolean'
380        element.addElement('value', content=u'false')
381        field = data_form.Field.fromElement(element)
382        self.assertEquals(u'false', field.value)
383
384
385    def test_fromElementDesc(self):
386        """
387        Field descriptions are in a desc child element.
388        """
389        element = domish.Element((NS_X_DATA, 'field'))
390        element.addElement('desc', content=u'My description')
391        field = data_form.Field.fromElement(element)
392        self.assertEqual(u'My description', field.desc)
393
394
395    def test_fromElementOption(self):
396        """
397        Field descriptions are in a desc child element.
398        """
399        element = domish.Element((NS_X_DATA, 'field'))
400        element.addElement('option').addElement('value', content=u'option1')
401        element.addElement('option').addElement('value', content=u'option2')
402        field = data_form.Field.fromElement(element)
403        self.assertEqual(2, len(field.options))
404
405
406    def test_fromElementRequired(self):
407        """
408        Required fields have a required child element.
409        """
410        element = domish.Element((NS_X_DATA, 'field'))
411        element.addElement('required')
412        field = data_form.Field.fromElement(element)
413        self.assertTrue(field.required)
414
415
416    def test_fromElementChildOtherNamespace(self):
417        """
418        Child elements from another namespace are ignored.
419        """
420        element = domish.Element((NS_X_DATA, 'field'))
421        element['var'] = 'test'
422        child = element.addElement(('myns', 'value'))
423        field = data_form.Field.fromElement(element)
424
425        self.assertIdentical(None, field.value)
426
427
428    def test_fromDict(self):
429        """
430        A named field with a value can be created by providing a dictionary.
431        """
432        fieldDict = {'var': 'test', 'value': 'text'}
433        field = data_form.Field.fromDict(fieldDict)
434        self.assertEqual('test', field.var)
435        self.assertEqual('text', field.value)
436
437
438    def test_fromDictFieldType(self):
439        """
440        The field type is set using the key 'type'.
441        """
442        fieldDict = {'type': 'boolean'}
443        field = data_form.Field.fromDict(fieldDict)
444        self.assertEqual('boolean', field.fieldType)
445
446
447    def test_fromDictOptions(self):
448        """
449        The field options are set using the key 'options'.
450
451        The options are represented as a dictionary keyed by option,
452        with the optional label as value.
453        """
454        fieldDict = {'options': {'value1': 'label1',
455                                 'value2': 'label2'}}
456        field = data_form.Field.fromDict(fieldDict)
457        self.assertEqual(2, len(field.options))
458        options = {}
459        for option in field.options:
460            options[option.value] = option.label
461
462        self.assertEqual(options, fieldDict['options'])
463
464
465class FormTest(unittest.TestCase):
466    """
467    Tests for L{data_form.Form}.
468    """
469
470    def test_formType(self):
471        """
472        A form has a type.
473        """
474
475        form = data_form.Form('result')
476        self.assertEqual('result', form.formType)
477
478
479    def test_toElement(self):
480        """
481        The toElement method returns a form's DOM representation.
482        """
483        form = data_form.Form('result')
484        element = form.toElement()
485
486        self.assertTrue(domish.IElement.providedBy(element))
487        self.assertEquals('x', element.name)
488        self.assertEquals(NS_X_DATA, element.uri)
489        self.assertEquals('result', element['type'])
490        self.assertEquals([], element.children)
491
492
493    def test_toElementTitle(self):
494        """
495        A title is rendered as a child element with the title as CDATA.
496        """
497        form = data_form.Form('form', title='Bot configuration')
498        element = form.toElement()
499
500        elements = list(element.elements())
501        self.assertEqual(1, len(elements))
502        title = elements[0]
503        self.assertEqual('title', title.name)
504        self.assertEqual(NS_X_DATA, title.uri)
505        self.assertEqual('Bot configuration', unicode(title))
506
507
508    def test_toElementInstructions(self):
509        """
510        Instructions are rendered as child elements with CDATA.
511        """
512        form = data_form.Form('form', instructions=['Fill out this form!'])
513        element = form.toElement()
514
515        elements = list(element.elements())
516        self.assertEqual(1, len(elements))
517        instructions = elements[0]
518        self.assertEqual('instructions', instructions.name)
519        self.assertEqual(NS_X_DATA, instructions.uri)
520        self.assertEqual('Fill out this form!', unicode(instructions))
521
522
523    def test_toElementInstructionsMultiple(self):
524        """
525        Instructions render as one element per instruction, in order.
526        """
527        form = data_form.Form('form', instructions=['Fill out this form!',
528                                                    'no really'])
529        element = form.toElement()
530
531        elements = list(element.elements())
532        self.assertEqual(2, len(elements))
533        instructions1 = elements[0]
534        instructions2 = elements[1]
535        self.assertEqual('instructions', instructions1.name)
536        self.assertEqual(NS_X_DATA, instructions1.uri)
537        self.assertEqual('Fill out this form!', unicode(instructions1))
538        self.assertEqual('instructions', instructions2.name)
539        self.assertEqual(NS_X_DATA, instructions2.uri)
540        self.assertEqual('no really', unicode(instructions2))
541
542
543    def test_toElementFormType(self):
544        """
545        The form type is rendered as a hidden field with name FORM_TYPE.
546        """
547        form = data_form.Form('form', formNamespace='jabber:bot')
548        element = form.toElement()
549
550        elements = list(element.elements())
551        self.assertEqual(1, len(elements))
552        formTypeField = elements[0]
553        self.assertEqual('field', formTypeField.name)
554        self.assertEqual(NS_X_DATA, formTypeField.uri)
555        self.assertEqual('FORM_TYPE', formTypeField['var'])
556        self.assertEqual('hidden', formTypeField['type'])
557        self.assertEqual('jabber:bot', unicode(formTypeField.value))
558
559
560    def test_toElementFields(self):
561        """
562        Fields are rendered as child elements, in order.
563        """
564        fields = [data_form.Field('fixed', value='Section 1'),
565                  data_form.Field('text-single',
566                                  var='botname',
567                                  label='The name of your bot'),
568                  data_form.Field('text-multi',
569                                  var='description',
570                                  label='Helpful description of your bot'),
571                  data_form.Field('boolean',
572                                  var='public',
573                                  label='Public bot?',
574                                  required=True)
575                 ]
576        form = data_form.Form('form', fields=fields)
577        element = form.toElement()
578
579        elements = list(element.elements())
580        self.assertEqual(4, len(elements))
581        for field in elements:
582            self.assertEqual('field', field.name)
583            self.assertEqual(NS_X_DATA, field.uri)
584
585        # Check order
586        self.assertEqual('fixed', elements[0]['type'])
587        self.assertEqual('botname', elements[1]['var'])
588        self.assertEqual('description', elements[2]['var'])
589        self.assertEqual('public', elements[3]['var'])
590
591
592    def test_fromElement(self):
593        """
594        C{fromElement} creates a L{data_form.Form} from a DOM representation.
595        """
596        element = domish.Element((NS_X_DATA, 'x'))
597        element['type'] = 'result'
598        form = data_form.Form.fromElement(element)
599
600        self.assertEquals('result', form.formType)
601        self.assertEquals(None, form.title)
602        self.assertEquals([], form.instructions)
603        self.assertEquals({}, form.fields)
604
605
606    def test_fromElementInvalidElementName(self):
607        """
608        Bail if the passed element does not have the correct name.
609        """
610        element = domish.Element((NS_X_DATA, 'form'))
611        self.assertRaises(Exception, data_form.Form.fromElement, element)
612
613
614    def test_fromElementInvalidElementURI(self):
615        """
616        Bail if the passed element does not have the correct namespace.
617        """
618        element = domish.Element(('myns', 'x'))
619        self.assertRaises(Exception, data_form.Form.fromElement, element)
620
621
622    def test_fromElementTitle(self):
623        element = domish.Element((NS_X_DATA, 'x'))
624        element.addElement('title', content='My title')
625        form = data_form.Form.fromElement(element)
626
627        self.assertEquals('My title', form.title)
628
629
630    def test_fromElementInstructions(self):
631        element = domish.Element((NS_X_DATA, 'x'))
632        element.addElement('instructions', content='instruction')
633        form = data_form.Form.fromElement(element)
634
635        self.assertEquals(['instruction'], form.instructions)
636
637
638    def test_fromElementInstructions2(self):
639        element = domish.Element((NS_X_DATA, 'x'))
640        element.addElement('instructions', content='instruction 1')
641        element.addElement('instructions', content='instruction 2')
642        form = data_form.Form.fromElement(element)
643
644        self.assertEquals(['instruction 1', 'instruction 2'], form.instructions)
645
646
647    def test_fromElementOneField(self):
648        element = domish.Element((NS_X_DATA, 'x'))
649        element.addElement('field')
650        form = data_form.Form.fromElement(element)
651
652        self.assertEquals(1, len(form.fieldList))
653        self.assertNotIn('field', form.fields)
654
655
656    def test_fromElementTwoFields(self):
657        element = domish.Element((NS_X_DATA, 'x'))
658        element.addElement('field')['var'] = 'field1'
659        element.addElement('field')['var'] = 'field2'
660        form = data_form.Form.fromElement(element)
661
662        self.assertEquals(2, len(form.fieldList))
663        self.assertIn('field1', form.fields)
664        self.assertEquals('field1', form.fieldList[0].var)
665        self.assertIn('field2', form.fields)
666        self.assertEquals('field2', form.fieldList[1].var)
667
668
669    def test_fromElementFormType(self):
670        """
671        The form type is a hidden field named FORM_TYPE.
672        """
673        element = domish.Element((NS_X_DATA, 'x'))
674        field = element.addElement('field')
675        field['var'] = 'FORM_TYPE'
676        field['type'] = 'hidden'
677        field.addElement('value', content='myns')
678        form = data_form.Form.fromElement(element)
679
680        self.assertNotIn('FORM_TYPE', form.fields)
681        self.assertEqual('myns', form.formNamespace)
682
683    def test_fromElementFormTypeNotHidden(self):
684        """
685        A non-hidden field named FORM_TYPE does not set the form type.
686        """
687        element = domish.Element((NS_X_DATA, 'x'))
688        field = element.addElement('field')
689        field['var'] = 'FORM_TYPE'
690        field.addElement('value', content='myns')
691        form = data_form.Form.fromElement(element)
692
693        self.assertIn('FORM_TYPE', form.fields)
694        self.assertIdentical(None, form.formNamespace)
695
696
697    def test_fromElementChildOtherNamespace(self):
698        """
699        Child elements from another namespace are ignored.
700        """
701        element = domish.Element((NS_X_DATA, 'x'))
702        element['type'] = 'result'
703        field = element.addElement(('myns', 'field'))
704        field['var'] = 'test'
705        form = data_form.Form.fromElement(element)
706
707        self.assertEqual(0, len(form.fields))
708
709
710    def test_repr(self):
711        """
712        The repr of a form should be equal to its initialization.
713        """
714        form = data_form.Form('form', title='title', instructions=['instr'],
715                                      formNamespace='myns',
716                                      fields=[data_form.Field('fixed',
717                                                              value='test')])
718        self.assertEqual("""Form(formType='form', title='title', """
719                         """instructions=['instr'], formNamespace='myns', """
720                         """fields=[Field(fieldType='fixed', """
721                         """values=['test'])])""",
722                         repr(form))
723
724
725    def test_addField(self):
726        """
727        A field should occur in fieldList.
728        """
729        form = data_form.Form('result')
730        field = data_form.Field('fixed', value='Section 1')
731        form.addField(field)
732        self.assertEqual([field], form.fieldList)
733
734
735    def test_addFieldTwice(self):
736        """
737        Fields occur in fieldList in the order they were added.
738        """
739        form = data_form.Form('result')
740        field1 = data_form.Field('fixed', value='Section 1')
741        field2 = data_form.Field('fixed', value='Section 2')
742        form.addField(field1)
743        form.addField(field2)
744        self.assertEqual([field1, field2], form.fieldList)
745
746
747    def test_addFieldNotNamed(self):
748        """
749        A non-named field should not occur in fields.
750        """
751        form = data_form.Form('result')
752        field = data_form.Field('fixed', value='Section 1')
753        form.addField(field)
754        self.assertEqual({}, form.fields)
755
756
757    def test_addFieldNamed(self):
758        """
759        A named field should occur in fields.
760        """
761        form = data_form.Form('result')
762        field = data_form.Field(var='test')
763        form.addField(field)
764        self.assertEqual({'test': field}, form.fields)
765
766
767    def test_addFieldTwiceNamed(self):
768        """
769        A second named field should occur in fields.
770        """
771        form = data_form.Form('result')
772        field1 = data_form.Field(var='test')
773        field2 = data_form.Field(var='test2')
774        form.addField(field2)
775        form.addField(field1)
776        self.assertEqual({'test': field1, 'test2': field2}, form.fields)
777
778
779    def test_addFieldSameName(self):
780        """
781        A named field cannot occur twice.
782        """
783        form = data_form.Form('result')
784        field1 = data_form.Field(var='test', value='value')
785        field2 = data_form.Field(var='test', value='value2')
786        form.addField(field1)
787        self.assertRaises(data_form.Error, form.addField, field2)
788
789
790    def test_getValues(self):
791        """
792        Each named field is represented in the values, keyed by name.
793        """
794        fields = [data_form.Field(var='botname', value='The Jabber Bot'),
795                  data_form.Field('boolean', var='public', value=True),
796                  data_form.Field('list-multi', var='features',
797                                                values=['news', 'search'])]
798        form = data_form.Form('submit', fields=fields)
799        values = form.getValues()
800        self.assertEqual({'botname': 'The Jabber Bot',
801                          'public': True,
802                          'features': ['news', 'search']},
803                         values)
804
805
806    def test_getValuesOneValueTypeMulti(self):
807        """
808        A single value for a multi-value field type is returned in a list.
809        """
810        fields = [data_form.Field('list-multi', var='features',
811                                                values=['news'])]
812        form = data_form.Form('submit', fields=fields)
813        values = form.getValues()
814        self.assertEqual({'features': ['news']}, values)
815
816
817    def test_getValuesMultipleValuesNoType(self):
818        """
819        Multiple values for a field without type are returned in a list.
820        """
821        fields = [data_form.Field(None, var='features',
822                                        values=['news', 'search'])]
823        form = data_form.Form('submit', fields=fields)
824        values = form.getValues()
825        self.assertEqual({'features': ['news', 'search']}, values)
826
827
828    def test_getValuesMultipleValuesTypeSingle(self):
829        """
830        Multiple values for a single-value field type returns the first value.
831        """
832        fields = [data_form.Field('text-single', var='features',
833                                        values=['news', 'search'])]
834        form = data_form.Form('submit', fields=fields)
835        values = form.getValues()
836        self.assertEqual({'features': 'news'}, values)
Note: See TracBrowser for help on using the repository browser.