Changeset 79:54aa7dd5fe81 for wokkel

Timestamp:

Jan 5, 2010, 2:53:43 PM (13 years ago)

Author:

Ralph Meijer <ralphm@…>

Branch:

default

Message:

Move makeFields to wokkel.data_form, add form type checking.

Location:

wokkel

Files:

• data_form.py (modified) (8 diffs)
• pubsub.py (modified) (2 diffs)
• test/test_data_form.py (modified) (5 diffs)

wokkel/data_form.py

@@ -76 +76 @@
             option['label'] = self.label
         return option
+
 
     @staticmethod
@@ -213 +214 @@
         if self.values:
             if (self.fieldType not in ('hidden', 'jid-multi', 'list-multi',
-                                 'text-multi') and
+                                       'text-multi', None) and
                 len(self.values) > 1):
                 raise TooManyValuesError()
@@ -234 +235 @@
             self.values = newValues
 
+
     def toElement(self, asForm=False):
         """
@@ -245 +247 @@
         field = domish.Element((NS_X_DATA, 'field'))
 
-        if asForm or self.fieldType != 'text-single':
+        if self.fieldType:
             field['type'] = self.fieldType
 
@@ -323 +325 @@
 
     @staticmethod
-    def fromDict(dictionary):
-        kwargs = dictionary.copy()
-
-        if 'type' in dictionary:
-            kwargs['fieldType'] = dictionary['type']
+    def fromDict(fieldDict):
+        """
+        Create a field from a dictionary.
+
+        This is a short hand for passing arguments directly on Field object
+        creation. The field type is represented by the C{'type'} key. For
+        C{'options'} the value is not a list of L{Option}s, but a dictionary
+        keyed by value, with an optional label as value.
+        """
+        kwargs = fieldDict.copy()
+
+        if 'type' in fieldDict:
+            kwargs['fieldType'] = fieldDict['type']
             del kwargs['type']
 
-        if 'options' in dictionary:
+        if 'options' in fieldDict:
             options = []
-            for value, label in dictionary['options'].iteritems():
+            for value, label in fieldDict['options'].iteritems():
                 options.append(Option(value, label))
             kwargs['options'] = options
@@ -416 +426 @@
         Add a field to this form.
 
-        Fields are added in order, and L{fields} is a dictionary of the
+        Fields are added in order, and C{fields} is a dictionary of the
         named fields, that is kept in sync only if this method is used for
         adding new fields. Multiple fields with the same name are disallowed.
@@ -429 +439 @@
 
 
+    def removeField(self, field):
+        """
+        Remove a field from this form.
+        """
+        self.fieldList.remove(field)
+
+        if field.var is not None:
+            del self.fields[field.var]
+
+
+    def makeFields(self, values, fieldDefs=None, filterUnknown=True):
+        """
+        Create fields from values and add them to this form.
+
+        This creates fields from a mapping of name to value(s) and adds them to
+        this form. It is typically used for generating outgoing forms.
+
+        If C{fieldDefs} is not C{None}, this is used to fill in
+        additional properties of fields, like the field types, labels and
+        possible options.
+
+        If C{filterUnknown} is C{True} and C{fieldDefs} is not C{None}, fields
+        will only be created from C{values} with a corresponding entry in
+        C{fieldDefs}.
+
+        If the field type is unknown, the field type is C{None}. When the form
+        is rendered using L{toElement}, these fields will have no C{'type'}
+        attribute, and it is up to the receiving party to interpret the values
+        properly (e.g. by knowing about the FORM_TYPE in L{formNamespace} and
+        the field name).
+
+        @param values: Values to create fields from.
+        @type values: C{dict}
+
+        @param fieldDefs: Field definitions as a dictionary. See
+            L{wokkel.iwokkel.IPubSubService.getConfigurationOptions}
+        @type fieldDefs: C{dict}
+
+        @param filterUnknown: If C{True}, ignore fields that are not in
+            C{fieldDefs}.
+        @type filterUnknown: C{bool}
+        """
+        for name, value in values.iteritems():
+            fieldDict = {'var': name,
+                         'type': None}
+
+            if fieldDefs is not None:
+                if name in fieldDefs:
+                    fieldDict.update(fieldDefs[name])
+                elif filterUnknown:
+                    continue
+
+            if isinstance(value, list):
+                fieldDict['values'] = value
+            else:
+                fieldDict['value'] = value
+
+            self.addField(Field.fromDict(fieldDict))
+
+
     def toElement(self):
+        """
+        Return the DOM representation of this Form.
+
+        @rtype: L{domish.Element}
+        """
         form = domish.Element((NS_X_DATA, 'x'))
         form['type'] = self.formType
@@ -517 +592 @@
 
         return values
+
+
+    def typeCheck(self, fieldDefs=None, filterUnknown=False):
+        """
+        Check values of fields according to the field definition.
+
+        This method walks all named fields to check their values against their
+        type, and is typically used for forms received from other entities. The
+        field definition in C{fieldDefs} is used to check the field type.
+
+        If C{filterUnknown} is C{True}, fields that are not present in
+        C{fieldDefs} are removed from the form.
+
+        If the field type is C{None} (when not set by the sending entity),
+        the type from the field definitition is used, or C{'text-single'} if
+        that is not set.
+
+        If C{fieldDefs} is None, an empty dictionary is assumed. This is
+        useful for coercing boolean and JID values on forms with type
+        C{'form'}.
+
+        @param fieldDefs: Field definitions as a dictionary. See
+            L{wokkel.iwokkel.IPubSubService.getConfigurationOptions}
+        @type fieldDefs: C{dict}
+
+        @param filterUnknown: If C{True}, remove fields that are not in
+            C{fieldDefs}.
+        @type filterUnknown: C{bool}
+        """
+
+        if fieldDefs is None:
+            fieldDefs = {}
+
+        filtered = []
+
+        for name, field in self.fields.iteritems():
+            if name in fieldDefs:
+                fieldDef = fieldDefs[name]
+                if 'type' not in fieldDef:
+                    fieldDef['type'] = 'text-single'
+
+                if field.fieldType is None:
+                    field.fieldType = fieldDef['type']
+                elif field.fieldType != fieldDef['type']:
+                    raise TypeError("Field type for %r is %r, expected %r" %
+                                    (name,
+                                     field.fieldType,
+                                     fieldDef['type']))
+                else:
+                    # Field type is correct
+                    pass
+                field.typeCheck()
+            elif filterUnknown:
+                filtered.append(field)
+            elif field.fieldType is not None:
+                field.typeCheck()
+            else:
+                # Unknown field without type, no checking, no filtering
+                pass
+
+        for field in filtered:
+            self.removeField(field)

wokkel/pubsub.py

@@ -1 +1 @@
 # -*- test-case-name: wokkel.test.test_pubsub -*-
 #
-# Copyright (c) 2003-2009 Ralph Meijer
+# Copyright (c) 2003-2010 Ralph Meijer
 # See LICENSE for details.
 
@@ -1013 +1013 @@
 
 
-    def _makeFields(self, options, values):
-        fields = []
-        for name, value in values.iteritems():
-            if name not in options:
-                continue
-
-            option = {'var': name}
-            option.update(options[name])
-            if isinstance(value, list):
-                option['values'] = value
-            else:
-                option['value'] = value
-            fields.append(data_form.Field.fromDict(option))
-        return fields
-
-
     def _formFromConfiguration(self, resource, values):
-        options = resource.getConfigurationOptions()
-        fields = self._makeFields(options, values)
+        fieldDefs = resource.getConfigurationOptions()
         form = data_form.Form(formType="form",
-                              formNamespace=NS_PUBSUB_NODE_CONFIG,
-                              fields=fields)
-
+                              formNamespace=NS_PUBSUB_NODE_CONFIG)
+        form.makeFields(values, fieldDefs)
         return form
 

wokkel/test/test_data_form.py

@@ -135 +135 @@
 
 
-    def test_toElementTypeNotListSingle(self):
-        """
-        Always render the field type, if different from list-single.
+    def test_toElementTypeNotTextSingle(self):
+        """
+        Always render the field type, if different from text-single.
         """
         field = data_form.Field('hidden', var='test')
@@ -143 +143 @@
 
         self.assertEquals('hidden', element.getAttribute('type'))
+
+
+    def test_toElementSingleValue(self):
+        """
+        A single value should yield only one value element.
+        """
+        field = data_form.Field('list-multi', var='test', value='test')
+        element = field.toElement()
+
+        children = list(element.elements())
+        self.assertEqual(1, len(children))
+
+
+    def test_toElementMultipleValues(self):
+        """
+        A field with no type and multiple values should render all values.
+        """
+        field = data_form.Field('list-multi', var='test',
+                                values=['test', 'test2'])
+        element = field.toElement()
+
+        children = list(element.elements())
+        self.assertEqual(2, len(children))
 
 
@@ -241 +264 @@
         element = field.toElement()
         self.assertEqual(u'true', unicode(element.value))
+
+
+    def test_toElementNoType(self):
+        """
+        A field with no type should not have a type attribute.
+        """
+        field = data_form.Field(None, var='test', value='test')
+        element = field.toElement()
+        self.assertFalse(element.hasAttribute('type'))
+
+
+    def test_toElementNoTypeMultipleValues(self):
+        """
+        A field with no type and multiple values should render all values.
+        """
+        field = data_form.Field(None, var='test', values=['test', 'test2'])
+        element = field.toElement()
+
+        self.assertFalse(element.hasAttribute('type'))
+        children = list(element.elements())
+        self.assertEqual(2, len(children))
 
 
@@ -788 +832 @@
 
 
+    def test_removeField(self):
+        """
+        A removed field should not occur in fieldList.
+        """
+        form = data_form.Form('result')
+        field = data_form.Field('fixed', value='Section 1')
+        form.addField(field)
+        form.removeField(field)
+        self.assertNotIn(field, form.fieldList)
+
+
+    def test_removeFieldNamed(self):
+        """
+        A removed named field should not occur in fields.
+        """
+        form = data_form.Form('result')
+        field = data_form.Field(var='test', value='test1')
+        form.addField(field)
+        form.removeField(field)
+        self.assertNotIn('test', form.fields)
+
+
+    def test_makeField(self):
+        """
+        Fields can be created from a dict of values and a dict of field defs.
+        """
+        fieldDefs = {
+                "pubsub#persist_items":
+                    {"type": "boolean",
+                     "label": "Persist items to storage"},
+                "pubsub#deliver_payloads":
+                    {"type": "boolean",
+                     "label": "Deliver payloads with event notifications"},
+                "pubsub#creator":
+                    {"type": "jid-single",
+                     "label": "The JID of the node creator"},
+                "pubsub#description":
+                    {"type": "text-single",
+                     "label": "A description of the node"},
+                "pubsub#owner":
+                    {"type": "jid-single",
+                     "label": "Owner of the node"},
+                }
+        values = {'pubsub#deliver_payloads': '0',
+                  'pubsub#persist_items': True,
+                  'pubsub#description': 'a great node',
+                  'pubsub#owner': jid.JID('user@example.org'),
+                  'x-myfield': ['a', 'b']}
+
+        form = data_form.Form('submit')
+        form.makeFields(values, fieldDefs)
+
+        # Check that the expected fields have been created
+        self.assertIn('pubsub#deliver_payloads', form.fields)
+        self.assertIn('pubsub#persist_items', form.fields)
+        self.assertIn('pubsub#description', form.fields)
+        self.assertIn('pubsub#owner', form.fields)
+
+        # This field is not created because there is no value for it.
+        self.assertNotIn('pubsub#creator', form.fields)
+
+        # This field is not created because it does not appear in fieldDefs
+        # and filterUnknown defaults to True
+        self.assertNotIn('x-myfield', form.fields)
+
+        # Check properties the created fields
+        self.assertEqual('boolean',
+                         form.fields['pubsub#deliver_payloads'].fieldType)
+        self.assertEqual('0',
+                         form.fields['pubsub#deliver_payloads'].value)
+        self.assertEqual('Deliver payloads with event notifications',
+                         form.fields['pubsub#deliver_payloads'].label)
+        self.assertEqual(True,
+                         form.fields['pubsub#persist_items'].value)
+
+
+    def test_makeFieldNotFilterUnknown(self):
+        """
+        Fields can be created from a dict of values and a dict of field defs.
+        """
+        fieldDefs = {
+                "pubsub#persist_items":
+                    {"type": "boolean",
+                     "label": "Persist items to storage"},
+                }
+        values = {'x-myfield': ['a', 'b']}
+
+        form = data_form.Form('submit')
+        form.makeFields(values, fieldDefs, filterUnknown=False)
+
+        field = form.fields['x-myfield']
+        self.assertEqual(None, field.fieldType)
+        self.assertEqual(values, form.getValues())
+
+
+    def test_makeFieldsUnknownTypeJID(self):
+        """
+        Without type, a single JID value sets field type jid-single.
+        """
+        values = {'pubsub#creator': jid.JID('user@example.org')}
+        form = data_form.Form('result')
+        form.makeFields(values)
+
+        field = form.fields['pubsub#creator']
+        self.assertEqual(None, field.fieldType)
+        self.assertEqual(values, form.getValues())
+
+
+    def test_makeFieldsUnknownTypeJIDMulti(self):
+        """
+        Without type, multiple JID values sets field type jid-multi.
+        """
+        values = {'pubsub#contact': [jid.JID('user@example.org'),
+                                     jid.JID('other@example.org')]}
+        form = data_form.Form('result')
+        form.makeFields(values)
+
+        field = form.fields['pubsub#contact']
+        self.assertEqual(None, field.fieldType)
+        self.assertEqual(values, form.getValues())
+
+
+    def test_makeFieldsUnknownTypeBoolean(self):
+        """
+        Without type, a boolean value sets field type boolean.
+        """
+        values = {'pubsub#persist_items': True}
+        form = data_form.Form('result')
+        form.makeFields(values)
+
+        field = form.fields['pubsub#persist_items']
+        self.assertEqual(None, field.fieldType)
+        self.assertEqual(values, form.getValues())
+
+
+    def test_makeFieldsUnknownTypeListMulti(self):
+        """
+        Without type, multiple values sets field type list-multi.
+        """
+        values = {'pubsub#show-values': ['chat', 'online', 'away']}
+        form = data_form.Form('result')
+        form.makeFields(values)
+
+        field = form.fields['pubsub#show-values']
+        self.assertEqual(None, field.fieldType)
+        self.assertEqual(values, form.getValues())
+
+
     def test_getValues(self):
         """
@@ -835 +1027 @@
         values = form.getValues()
         self.assertEqual({'features': 'news'}, values)
+
+
+    def test_typeCheckKnownFieldChecked(self):
+        """
+        Known fields are type checked.
+        """
+        checked = []
+        fieldDefs = {"pubsub#description":
+                        {"type": "text-single",
+                         "label": "A description of the node"}}
+        form = data_form.Form('submit')
+        form.addField(data_form.Field(var='pubsub#description',
+                                      value='a node'))
+        field = form.fields['pubsub#description']
+        field.typeCheck = lambda : checked.append(None)
+        form.typeCheck(fieldDefs)
+
+        self.assertEqual([None], checked)
+
+
+    def test_typeCheckKnownFieldNoType(self):
+        """
+        Known fields without a type get the type of the field definition.
+        """
+        checked = []
+        fieldDefs = {"pubsub#description":
+                        {"type": "text-single",
+                         "label": "A description of the node"}}
+        form = data_form.Form('submit')
+        form.addField(data_form.Field(None, var='pubsub#description',
+                                            value='a node'))
+        field = form.fields['pubsub#description']
+        field.typeCheck = lambda : checked.append(None)
+        form.typeCheck(fieldDefs)
+
+        self.assertEqual('text-single', field.fieldType)
+        self.assertEqual([None], checked)
+
+
+    def test_typeCheckWrongFieldType(self):
+        """
+        A field should have the same type as the field definition.
+        """
+        checked = []
+        fieldDefs = {"pubsub#description":
+                        {"type": "text-single",
+                         "label": "A description of the node"}}
+        form = data_form.Form('submit')
+        form.addField(data_form.Field('list-single', var='pubsub#description',
+                                                     value='a node'))
+        field = form.fields['pubsub#description']
+        field.typeCheck = lambda : checked.append(None)
+
+        self.assertRaises(TypeError, form.typeCheck, fieldDefs)
+        self.assertEqual([], checked)
+
+
+    def test_typeCheckDefaultTextSingle(self):
+        """
+        If a field definition has no type, use text-single.
+        """
+        checked = []
+        fieldDefs = {"pubsub#description":
+                        {"label": "A description of the node"}}
+        form = data_form.Form('submit')
+        form.addField(data_form.Field('text-single', var='pubsub#description',
+                                                     value='a node'))
+        field = form.fields['pubsub#description']
+        field.typeCheck = lambda : checked.append(None)
+        form.typeCheck(fieldDefs)
+
+        self.assertEqual([None], checked)
+
+
+    def test_typeCheckUnknown(self):
+        """
+        Unknown fields are checked, not removed if filterUnknown False.
+        """
+        checked = []
+        fieldDefs = {}
+        form = data_form.Form('submit')
+        form.addField(data_form.Field('list-single', var='pubsub#description',
+                                                     value='a node'))
+        field = form.fields['pubsub#description']
+        field.typeCheck = lambda : checked.append(None)
+        form.typeCheck(fieldDefs, filterUnknown=False)
+
+        self.assertIn('pubsub#description', form.fields)
+        self.assertEqual([None], checked)
+
+
+    def test_typeCheckUnknownNoType(self):
+        """
+        Unknown fields without type are not checked.
+        """
+        checked = []
+        fieldDefs = {}
+        form = data_form.Form('submit')
+        form.addField(data_form.Field(None, var='pubsub#description',
+                                            value='a node'))
+        field = form.fields['pubsub#description']
+        field.typeCheck = lambda : checked.append(None)
+        form.typeCheck(fieldDefs, filterUnknown=False)
+
+        self.assertIn('pubsub#description', form.fields)
+        self.assertEqual([], checked)
+
+
+    def test_typeCheckUnknownRemoved(self):
+        """
+        Unknown fields are not checked, and removed if filterUnknown True.
+        """
+        checked = []
+        fieldDefs = {}
+        form = data_form.Form('submit')
+        form.addField(data_form.Field('list-single', var='pubsub#description',
+                                                     value='a node'))
+        field = form.fields['pubsub#description']
+        field.typeCheck = lambda : checked.append(None)
+        form.typeCheck(fieldDefs, filterUnknown=True)
+
+        self.assertNotIn('pubsub#description', form.fields)
+        self.assertEqual([], checked)
+
+
+    def test_typeCheckNoFieldDefs(self):
+        """
+        If there are no field defs, an empty dictionary is assumed.
+        """
+        checked = []
+        form = data_form.Form('submit')
+        form.addField(data_form.Field('list-single', var='pubsub#description',
+                                                     value='a node'))
+        field = form.fields['pubsub#description']
+        field.typeCheck = lambda : checked.append(None)
+        form.typeCheck()
+
+        self.assertIn('pubsub#description', form.fields)
+        self.assertEqual([None], checked)