source: ralphm-patches/form-missing-tests.patch @ 24:8116c2eaa96a

diff -r 3ef9bc7a0d70 wokkel/data_form.py
--- a/wokkel/data_form.py       Wed Dec 30 16:53:05 2009 +0100
+++ b/wokkel/data_form.py       Fri Jan 01 01:21:56 2010 +0100
@@ -251,10 +251,10 @@
             field['var'] = self.var
 
         for value in self.values:
-            if self.fieldType == 'boolean':
+            if isinstance(value, bool):
                 value = unicode(value).lower()
-            elif self.fieldType in ('jid-single', 'jid-multi'):
-                value = value.full()
+            else:
+                value = unicode(value)
 
             field.addElement('value', content=value)
 
@@ -343,7 +343,7 @@
     """
     Data Form.
 
-    There are two similarly named properties of forms. The L{formType} is the
+    There are two similarly named properties of forms. The C{formType} is the
     the so-called type of the form, and is set as the C{'type'} attribute
     on the form's root element.
 
@@ -351,19 +351,31 @@
     provide a context for the field names used in this form, by setting a
     special hidden field named C{'FORM_TYPE'}, to put the names of all
     other fields in the namespace of the value of that field. This namespace
-    is recorded in the L{formNamespace} instance variable.
+    is recorded in the C{formNamespace} instance variable.
 
     @ivar formType: Type of form. One of C{'form'}, C{'submit'}, {'cancel'},
                     or {'result'}.
-    @type formType: C{str}.
+    @type formType: C{str}
+
+    @ivar title: Natural language title of the form.
+    @type title: C{unicode}
+
+    @ivar instructions: Natural language instructions as a list of C{unicode}
+        strings without line breaks.
+    @type instructions: C{list}
+
     @ivar formNamespace: The optional namespace of the field names for this
-                         form. This goes in the special field named
-                         C{'FORM_TYPE'}, if set.
+        form. This goes in the special field named C{'FORM_TYPE'}, if set.
     @type formNamespace: C{str}.
-    @ivar fields: Dictionary of fields that have a name. Note that this is
-                  meant to be used for reading, only. One should use
-                  L{addField} for adding fields.
+
+    @ivar fields: Dictionary of named fields. Note that this is meant to be
+        used for reading, only. One should use L{addField} or L{makeFields} and
+        L{removeField} for adding and removing fields.
     @type fields: C{dict}
+
+    @ivar fieldList: List of all fields, in the order they are added. Like
+        C{fields}, this is meant to be used for reading, only.
+    @type fieldList: C{list}
     """
 
     def __init__(self, formType, title=None, instructions=None,
@@ -392,7 +404,7 @@
         if self.formNamespace:
             r.append(", formNamespace=")
             r.append(repr(self.formNamespace))
-        if self.fields:
+        if self.fieldList:
             r.append(", fields=")
             r.append(repr(self.fieldList))
         r.append(")")
@@ -424,7 +436,7 @@
             form.addElement('title', content=self.title)
 
         for instruction in self.instructions:
-            form.addElement('instruction', content=instruction)
+            form.addElement('instructions', content=instruction)
 
         if self.formNamespace is not None:
             field = Field('hidden', 'FORM_TYPE', self.formNamespace)
@@ -477,11 +489,26 @@
 
         return form
 
+
     def getValues(self):
+        """
+        Extract values from the named form fields.
+
+        For all named fields, the corresponding value or values are
+        returned in a dictionary keyed by the field name. For multi-value
+        fields, the dictionary value is a list, otherwise a single value.
+
+        If a field has no type, and the field has multiple values, the value of
+        the dictionary entry is the list of values. Otherwise, it will be a
+        single value.
+
+        @rtype: C{dict}
+        """
         values = {}
 
         for name, field in self.fields.iteritems():
-            if len(field.values) > 1:
+            if (field.fieldType in ('jid-multi', 'list-multi', 'text-multi') or
+                (field.fieldType is None and len(field.values) > 1)):
                 value = field.values
             else:
                 value = field.value
diff -r 3ef9bc7a0d70 wokkel/test/test_data_form.py
--- a/wokkel/test/test_data_form.py     Wed Dec 30 16:53:05 2009 +0100
+++ b/wokkel/test/test_data_form.py     Fri Jan 01 01:21:56 2010 +0100
@@ -19,14 +19,67 @@
     """
 
     def test_toElement(self):
+        option = data_form.Option('value')
+        element = option.toElement()
+
+        self.assertEqual('option', element.name)
+        self.assertEqual(NS_X_DATA, element.uri)
+        self.assertEqual(NS_X_DATA, element.value.uri)
+        self.assertEqual('value', unicode(element.value))
+        self.assertFalse(element.hasAttribute('label'))
+
+
+    def test_toElementLabel(self):
         option = data_form.Option('value', 'label')
         element = option.toElement()
-        self.assertEquals('option', element.name)
-        self.assertEquals(NS_X_DATA, element.uri)
-        self.assertEquals('label', element['label'])
-        self.assertEquals('value', element.value.name)
-        self.assertEquals(NS_X_DATA, element.value.uri)
-        self.assertEquals('value', unicode(element.value))
+
+        self.assertEqual('option', element.name)
+        self.assertEqual(NS_X_DATA, element.uri)
+        self.assertEqual(NS_X_DATA, element.value.uri)
+        self.assertEqual('value', unicode(element.value))
+        self.assertEqual('label', element['label'])
+
+
+    def test_fromElement(self):
+        """
+        An option has a child element with the option value.
+        """
+        element = domish.Element((NS_X_DATA, 'option'))
+        element.addElement('value', content='value')
+        option = data_form.Option.fromElement(element)
+
+        self.assertEqual('value', option.value)
+        self.assertIdentical(None, option.label)
+
+
+    def test_fromElementLabel(self):
+        """
+        An option label is an attribute on the option element.
+        """
+
+        element = domish.Element((NS_X_DATA, 'option'))
+        element.addElement('value', content='value')
+        element['label'] = 'label'
+        option = data_form.Option.fromElement(element)
+
+        self.assertEqual('label', option.label)
+
+
+    def test_fromElementNoValue(self):
+        """
+        An option MUST have a value.
+        """
+        element = domish.Element((NS_X_DATA, 'option'))
+        self.assertRaises(data_form.Error,
+                          data_form.Option.fromElement, element)
+
+
+    def test_repr(self):
+        """
+        The representation of an Option is equal to how it is created.
+        """
+        option = data_form.Option('value', 'label')
+        self.assertEqual("""Option('value', 'label')""", repr(option))
 
 
 
@@ -44,6 +97,21 @@
         self.assertEqual('test', field.var)
 
 
+    def test_repr(self):
+        """
+        The repr of a field should be equal to its initialization.
+        """
+        field = data_form.Field('list-single', var='test', label='label',
+                               desc='desc', required=True, value='test',
+                               options=[data_form.Option('test')])
+        self.assertEqual("""Field(fieldType='list-single', """
+                         """var='test', label='label', """
+                         """desc='desc', required=True, """
+                         """values=['test'], """
+                         """options=[Option('test')])""",
+                         repr(field))
+
+
     def test_toElement(self):
         """
         Test rendering to a DOM.
@@ -130,12 +198,44 @@
 
 
     def test_toElementJID(self):
+        """
+        A JID value should render to text.
+        """
         field = data_form.Field(fieldType='jid-single', var='test',
                                 value=jid.JID(u'test@example.org'))
         element = field.toElement()
         self.assertEqual(u'test@example.org', unicode(element.value))
 
 
+    def test_toElementJIDTextSingle(self):
+        """
+        A JID value should render to text if field type is text-single.
+        """
+        field = data_form.Field(fieldType='text-single', var='test',
+                                value=jid.JID(u'test@example.org'))
+        element = field.toElement()
+        self.assertEqual(u'test@example.org', unicode(element.value))
+
+
+    def test_toElementBoolean(self):
+        """
+        A boolean value should render to text.
+        """
+        field = data_form.Field(fieldType='boolean', var='test',
+                                value=True)
+        element = field.toElement()
+        self.assertEqual(u'true', unicode(element.value))
+
+
+    def test_toElementBooleanTextSingle(self):
+        """
+        A boolean value should render to text if the field type is text-single.
+        """
+        field = data_form.Field(var='test', value=True)
+        element = field.toElement()
+        self.assertEqual(u'true', unicode(element.value))
+
+
     def test_typeCheckNoFieldName(self):
         """
         A field not of type fixed must have a var.
@@ -250,6 +350,7 @@
         field = data_form.Field.fromElement(element)
         self.assertEquals(u'user@example.org', field.value)
 
+
     def test_fromElementValueJIDMalformed(self):
         """
         Parsed jid-single field values should be of type C{unicode}.
@@ -275,6 +376,85 @@
         self.assertEquals(u'false', field.value)
 
 
+    def test_fromElementDesc(self):
+        """
+        Field descriptions are in a desc child element.
+        """
+        element = domish.Element((NS_X_DATA, 'field'))
+        element.addElement('desc', content=u'My description')
+        field = data_form.Field.fromElement(element)
+        self.assertEqual(u'My description', field.desc)
+
+
+    def test_fromElementOption(self):
+        """
+        Field descriptions are in a desc child element.
+        """
+        element = domish.Element((NS_X_DATA, 'field'))
+        element.addElement('option').addElement('value', content=u'option1')
+        element.addElement('option').addElement('value', content=u'option2')
+        field = data_form.Field.fromElement(element)
+        self.assertEqual(2, len(field.options))
+
+
+    def test_fromElementRequired(self):
+        """
+        Required fields have a required child element.
+        """
+        element = domish.Element((NS_X_DATA, 'field'))
+        element.addElement('required')
+        field = data_form.Field.fromElement(element)
+        self.assertTrue(field.required)
+
+
+    def test_fromElementChildOtherNamespace(self):
+        """
+        Child elements from another namespace are ignored.
+        """
+        element = domish.Element((NS_X_DATA, 'field'))
+        element['var'] = 'test'
+        child = element.addElement(('myns', 'value'))
+        field = data_form.Field.fromElement(element)
+
+        self.assertIdentical(None, field.value)
+
+
+    def test_fromDict(self):
+        """
+        A named field with a value can be created by providing a dictionary.
+        """
+        fieldDict = {'var': 'test', 'value': 'text'}
+        field = data_form.Field.fromDict(fieldDict)
+        self.assertEqual('test', field.var)
+        self.assertEqual('text', field.value)
+
+
+    def test_fromDictFieldType(self):
+        """
+        The field type is set using the key 'type'.
+        """
+        fieldDict = {'type': 'boolean'}
+        field = data_form.Field.fromDict(fieldDict)
+        self.assertEqual('boolean', field.fieldType)
+
+
+    def test_fromDictOptions(self):
+        """
+        The field options are set using the key 'options'.
+
+        The options are represented as a dictionary keyed by option,
+        with the optional label as value.
+        """
+        fieldDict = {'options': {'value1': 'label1',
+                                 'value2': 'label2'}}
+        field = data_form.Field.fromDict(fieldDict)
+        self.assertEqual(2, len(field.options))
+        options = {}
+        for option in field.options:
+            options[option.value] = option.label
+
+        self.assertEqual(options, fieldDict['options'])
+
 
 class FormTest(unittest.TestCase):
     """
@@ -289,11 +469,13 @@
         form = data_form.Form('result')
         self.assertEqual('result', form.formType)
 
+
     def test_toElement(self):
         """
         The toElement method returns a form's DOM representation.
         """
         form = data_form.Form('result')
+
         element = form.toElement()
 
         self.assertTrue(domish.IElement.providedBy(element))
@@ -303,6 +485,105 @@
         self.assertEquals([], element.children)
 
 
+    def test_toElementTitle(self):
+        """
+        A title is rendered as a child element with the title as CDATA.
+        """
+        form = data_form.Form('form', title='Bot configuration')
+        element = form.toElement()
+
+        elements = list(element.elements())
+        self.assertEqual(1, len(elements))
+        title = elements[0]
+        self.assertEqual('title', title.name)
+        self.assertEqual(NS_X_DATA, title.uri)
+        self.assertEqual('Bot configuration', unicode(title))
+
+
+    def test_toElementInstructions(self):
+        """
+        Instructions are rendered as child elements with CDATA.
+        """
+        form = data_form.Form('form', instructions=['Fill out this form!'])
+        element = form.toElement()
+
+        elements = list(element.elements())
+        self.assertEqual(1, len(elements))
+        instructions = elements[0]
+        self.assertEqual('instructions', instructions.name)
+        self.assertEqual(NS_X_DATA, instructions.uri)
+        self.assertEqual('Fill out this form!', unicode(instructions))
+
+
+    def test_toElementInstructionsMultiple(self):
+        """
+        Instructions render as one element per instruction, in order.
+        """
+        form = data_form.Form('form', instructions=['Fill out this form!',
+                                                    'no really'])
+        element = form.toElement()
+
+        elements = list(element.elements())
+        self.assertEqual(2, len(elements))
+        instructions1 = elements[0]
+        instructions2 = elements[1]
+        self.assertEqual('instructions', instructions1.name)
+        self.assertEqual(NS_X_DATA, instructions1.uri)
+        self.assertEqual('Fill out this form!', unicode(instructions1))
+        self.assertEqual('instructions', instructions2.name)
+        self.assertEqual(NS_X_DATA, instructions2.uri)
+        self.assertEqual('no really', unicode(instructions2))
+
+
+    def test_toElementFormType(self):
+        """
+        The form type is rendered as a hidden field with name FORM_TYPE.
+        """
+        form = data_form.Form('form', formNamespace='jabber:bot')
+        element = form.toElement()
+
+        elements = list(element.elements())
+        self.assertEqual(1, len(elements))
+        formTypeField = elements[0]
+        self.assertEqual('field', formTypeField.name)
+        self.assertEqual(NS_X_DATA, formTypeField.uri)
+        self.assertEqual('FORM_TYPE', formTypeField['var'])
+        self.assertEqual('hidden', formTypeField['type'])
+        self.assertEqual('jabber:bot', unicode(formTypeField.value))
+
+
+    def test_toElementFields(self):
+        """
+        Fields are rendered as child elements, in order.
+        """
+        fields = [data_form.Field('fixed', value='Section 1'),
+                  data_form.Field('text-single',
+                                  var='botname',
+                                  label='The name of your bot'),
+                  data_form.Field('text-multi',
+                                  var='description',
+                                  label='Helpful description of your bot'),
+                  data_form.Field('boolean',
+                                  var='public',
+                                  label='Public bot?',
+                                  required=True)
+                 ]
+        form = data_form.Form('form', fields=fields)
+        element = form.toElement()
+
+        elements = list(element.elements())
+        self.assertEqual(4, len(elements))
+        for field in elements:
+            self.assertEqual('field', field.name)
+            self.assertEqual(NS_X_DATA, field.uri)
+
+        # Check order
+        self.assertEqual('fixed', elements[0]['type'])
+        self.assertEqual('botname', elements[1]['var'])
+        self.assertEqual('description', elements[2]['var'])
+        self.assertEqual('public', elements[3]['var'])
+
+
     def test_fromElement(self):
         """
         C{fromElement} creates a L{data_form.Form} from a DOM representation.
@@ -348,6 +629,7 @@
 
         self.assertEquals(['instruction'], form.instructions)
 
+
     def test_fromElementInstructions2(self):
         element = domish.Element((NS_X_DATA, 'x'))
         element.addElement('instructions', content='instruction 1')
@@ -377,3 +659,173 @@
         self.assertEquals('field1', form.fieldList[0].var)
         self.assertIn('field2', form.fields)
         self.assertEquals('field2', form.fieldList[1].var)
+
+
+    def test_fromElementFormType(self):
+        """
+        The form type is a hidden field named FORM_TYPE.
+        """
+        element = domish.Element((NS_X_DATA, 'x'))
+        field = element.addElement('field')
+        field['var'] = 'FORM_TYPE'
+        field['type'] = 'hidden'
+        field.addElement('value', content='myns')
+        form = data_form.Form.fromElement(element)
+
+        self.assertNotIn('FORM_TYPE', form.fields)
+        self.assertEqual('myns', form.formNamespace)
+
+    def test_fromElementFormTypeNotHidden(self):
+        """
+        A non-hidden field named FORM_TYPE does not set the form type.
+        """
+        element = domish.Element((NS_X_DATA, 'x'))
+        field = element.addElement('field')
+        field['var'] = 'FORM_TYPE'
+        field.addElement('value', content='myns')
+        form = data_form.Form.fromElement(element)
+
+        self.assertIn('FORM_TYPE', form.fields)
+        self.assertIdentical(None, form.formNamespace)
+
+
+    def test_fromElementChildOtherNamespace(self):
+        """
+        Child elements from another namespace are ignored.
+        """
+        element = domish.Element((NS_X_DATA, 'x'))
+        element['type'] = 'result'
+        field = element.addElement(('myns', 'field'))
+        field['var'] = 'test'
+        form = data_form.Form.fromElement(element)
+
+        self.assertEqual(0, len(form.fields))
+
+
+    def test_repr(self):
+        """
+        The repr of a form should be equal to its initialization.
+        """
+        form = data_form.Form('form', title='title', instructions=['instr'],
+                                      formNamespace='myns',
+                                      fields=[data_form.Field('fixed',
+                                                              value='test')])
+        self.assertEqual("""Form(formType='form', title='title', """
+                         """instructions=['instr'], formNamespace='myns', """
+                         """fields=[Field(fieldType='fixed', """
+                         """values=['test'])])""",
+                         repr(form))
+
+
+    def test_addField(self):
+        """
+        A field should occur in fieldList.
+        """
+        form = data_form.Form('result')
+        field = data_form.Field('fixed', value='Section 1')
+        form.addField(field)
+        self.assertEqual([field], form.fieldList)
+
+
+    def test_addFieldTwice(self):
+        """
+        Fields occur in fieldList in the order they were added.
+        """
+        form = data_form.Form('result')
+        field1 = data_form.Field('fixed', value='Section 1')
+        field2 = data_form.Field('fixed', value='Section 2')
+        form.addField(field1)
+        form.addField(field2)
+        self.assertEqual([field1, field2], form.fieldList)
+
+
+    def test_addFieldNotNamed(self):
+        """
+        A non-named field should not occur in fields.
+        """
+        form = data_form.Form('result')
+        field = data_form.Field('fixed', value='Section 1')
+        form.addField(field)
+        self.assertEqual({}, form.fields)
+
+
+    def test_addFieldNamed(self):
+        """
+        A named field should occur in fields.
+        """
+        form = data_form.Form('result')
+        field = data_form.Field(var='test')
+        form.addField(field)
+        self.assertEqual({'test': field}, form.fields)
+
+
+    def test_addFieldTwiceNamed(self):
+        """
+        A second named field should occur in fields.
+        """
+        form = data_form.Form('result')
+        field1 = data_form.Field(var='test')
+        field2 = data_form.Field(var='test2')
+        form.addField(field2)
+        form.addField(field1)
+        self.assertEqual({'test': field1, 'test2': field2}, form.fields)
+
+
+    def test_addFieldSameName(self):
+        """
+        A named field cannot occur twice.
+        """
+        form = data_form.Form('result')
+        field1 = data_form.Field(var='test', value='value')
+        field2 = data_form.Field(var='test', value='value2')
+        form.addField(field1)
+        self.assertRaises(data_form.Error, form.addField, field2)
+
+
+    def test_getValues(self):
+        """
+        Each named field is represented in the values, keyed by name.
+        """
+        fields = [data_form.Field(var='botname', value='The Jabber Bot'),
+                  data_form.Field('boolean', var='public', value=True),
+                  data_form.Field('list-multi', var='features',
+                                                values=['news', 'search'])]
+        form = data_form.Form('submit', fields=fields)
+        values = form.getValues()
+        self.assertEqual({'botname': 'The Jabber Bot',
+                          'public': True,
+                          'features': ['news', 'search']},
+                         values)
+
+
+    def test_getValuesOneValueTypeMulti(self):
+        """
+        A single value for a multi-value field type is returned in a list.
+        """
+        fields = [data_form.Field('list-multi', var='features',
+                                                values=['news'])]
+        form = data_form.Form('submit', fields=fields)
+        values = form.getValues()
+        self.assertEqual({'features': ['news']}, values)
+
+
+    def test_getValuesMultipleValuesNoType(self):
+        """
+        Multiple values for a field without type are returned in a list.
+        """
+        fields = [data_form.Field(None, var='features',
+                                        values=['news', 'search'])]
+        form = data_form.Form('submit', fields=fields)
+        values = form.getValues()
+        self.assertEqual({'features': ['news', 'search']}, values)
+
+
+    def test_getValuesMultipleValuesTypeSingle(self):
+        """
+        Multiple values for a single-value field type returns the first value.
+        """
+        fields = [data_form.Field('text-single', var='features',
+                                        values=['news', 'search'])]
+        form = data_form.Form('submit', fields=fields)
+        values = form.getValues()
+        self.assertEqual({'features': 'news'}, values)