Changeset 25:fd00a744a458 for wokkel

Timestamp:

Jul 7, 2008, 4:29:02 PM (14 years ago)

Author:

Ralph Meijer <ralphm@…>

Branch:

default

Convert:

svn:b33ecbfc-034c-dc11-8662-000475d9059e/trunk@55

Message:

Refactor Data Forms.

Author: ralphm.
Fixes #13.

This refactoring provides an abstract representation of Forms, Fields and
Options and each of those can be parsed from or unparsed to XML. This change
also simplifies testing in test_pubsub, by allowing the 'received' requests
to be represented as an XML snippit.

Location:

wokkel

Files:

• data_form.py (modified) (1 diff)
• iwokkel.py (modified) (1 diff)
• pubsub.py (modified) (30 diffs)
• test/test_pubsub.py (modified) (13 diffs)

wokkel/data_form.py

@@ -1 @@
-# Copyright (c) 2003-2007 Ralph Meijer
+# -*- test-case-name: wokkel.test.test_data_form -*-
+#
+# Copyright (c) 2003-2008 Ralph Meijer
 # See LICENSE for details.
 
+"""
+Data Forms.
+
+Support for Data Forms as described in
+U{XEP-0004<http://www.xmpp.org/extensions/xep-0004.html>}, along with support
+for Field Standardization for Data Forms as described in
+U{XEP-0068<http://www.xmpp.org/extensions/xep-0068.html>}.
+"""
+
+from twisted.words.protocols.jabber.jid import JID
 from twisted.words.xish import domish
 
 NS_X_DATA = 'jabber:x:data'
 
-class Field(domish.Element):
-    def __init__(self, type='text-single', var=None, label=None,
-                       value=None, values=[], options={}):
-        domish.Element.__init__(self, (NS_X_DATA, 'field'))
-        self['type'] = type
-        if var is not None:
-            self['var'] = var
-        if label is not None:
-            self['label'] = label
+
+
+class Error(Exception):
+    """
+    Data Forms error.
+    """
+
+
+
+class FieldNameRequiredError(Error):
+    """
+    A field name is required for this field type.
+    """
+
+
+
+class TooManyValuesError(Error):
+    """
+    This field is single-value.
+    """
+
+
+
+class Option(object):
+    """
+    Data Forms field option.
+
+    @ivar value: Value of this option.
+    @type value: C{unicode}
+    @ivar label: Optional label for this option.
+    @type label: C{unicode} or C{NoneType}.
+    """
+
+    def __init__(self, value, label=None):
+        self.value = value
+        self.label = label
+
+
+    def __repr__(self):
+        r = ["Option(", repr(self.value)]
+        if self.label:
+            r.append(", ")
+            r.append(repr(self.label))
+        r.append(")")
+        return u"".join(r)
+
+
+    def toElement(self):
+        """
+        Return the DOM representation of this option.
+
+        @rtype L{domish.Element}.
+        """
+        option = domish.Element((NS_X_DATA, 'option'))
+        option.addElement('value', content=self.value)
+        if self.label:
+            option['label'] = self.label
+        return option
+
+    @staticmethod
+    def fromElement(element):
+        valueElements = list(domish.generateElementsQNamed(element.children,
+                                                           'value', NS_X_DATA))
+        if not valueElements:
+            raise Error("Option has no value")
+
+        label = element.getAttribute('label')
+        return Option(unicode(valueElements[0]), label)
+
+
+class Field(object):
+    """
+    Data Forms field.
+
+    @ivar fieldType: Type of this field. One of C{'boolean'}, C{'fixed'},
+                     C{'hidden'}, C{'jid-multi'}, C{'jid-single'},
+                     C{'list-multi'}, {'list-single'}, C{'text-multi'},
+                     C{'text-private'}, C{'text-single'}.
+
+                     The default is C{'text-single'}.
+    @type fieldType: C{str}
+    @ivar var: Field name. Optional if L{fieldType} is C{'fixed'}.
+    @type var: C{str}
+    @ivar label: Human readable label for this field.
+    @type label: C{unicode}
+    @ivar values: The values for this field, for multi-valued field
+                  types, as a list of C{bool}, C{unicode} or L{JID}.
+    @type values: C{list}
+    @ivar options: List of possible values to choose from in a response
+                   to this form as a list of L{Option}s.
+    @type options: C{list}.
+    @ivar desc: Human readable description for this field.
+    @type desc: C{unicode}
+    @ivar required: Whether the field is required to be provided in a
+                    response to this form.
+    @type required: C{bool}.
+    """
+
+    def __init__(self, fieldType='text-single', var=None, value=None,
+                       values=None, options=None, label=None, desc=None,
+                       required=False):
+        """
+        Initialize this field.
+
+        See the identically named instance variables for descriptions.
+
+        If C{value} is not C{None}, it overrides C{values}, setting the
+        given value as the only value for this field.
+        """
+
+        self.fieldType = fieldType
+        self.var = var
         if value is not None:
-            self.set_value(value)
+            self.value = value
         else:
-            self.set_values(values)
-        if type in ['list-single', 'list-multi']:
-            for value, label in options.iteritems():
-                self.addChild(Option(value, label))
-
-    def set_value(self, value):
-        if self['type'] == 'boolean':
-            value = str(int(bool(value)))
+            self.values = values or []
+
+        try:
+            self.options = [Option(value, label)
+                            for value, label in options.iteritems()]
+        except AttributeError:
+            self.options = options or []
+
+        self.label = label
+        self.desc = desc
+        self.required = required
+
+
+    def __repr__(self):
+        r = ["Field(fieldType=", repr(self.fieldType)]
+        if self.var:
+            r.append(", var=")
+            r.append(repr(self.var))
+        if self.label:
+            r.append(", label=")
+            r.append(repr(self.label))
+        if self.desc:
+            r.append(", desc=")
+            r.append(repr(self.desc))
+        if self.required:
+            r.append(", required=")
+            r.append(repr(self.required))
+        if self.values:
+            r.append(", values=")
+            r.append(repr(self.values))
+        if self.options:
+            r.append(", options=")
+            r.append(repr(self.options))
+        r.append(")")
+        return u"".join(r)
+
+
+    def __value_set(self, value):
+        """
+        Setter of value property.
+
+        Sets C{value} as the only element of L{values}.
+
+        @type value: C{bool}, C{unicode} or L{JID}
+        """
+        self.values = [value]
+
+
+    def __value_get(self):
+        """
+        Getter of value property.
+
+        Returns the first element of L{values}, if present, or C{None}.
+        """
+
+        if self.values:
+            return self.values[0]
         else:
-            value = str(value)
-
-        value_element = self.value or self.addElement('value')
-        value_element.children = []
-        value_element.addContent(value)
-
-    def set_values(self, values):
-        for value in values:
-            value = str(value)
-            self.addElement('value', content=value)
-
-class Option(domish.Element):
-    def __init__(self, value, label=None):
-        domish.Element.__init__(self, (NS_X_DATA, 'option'))
-        if label is not None:
-            self['label'] = label
-        self.addElement('value', content=value)
-
-class Form(domish.Element):
-    def __init__(self, type, form_type):
-        domish.Element.__init__(self, (NS_X_DATA, 'x'),
-                                attribs={'type': type})
-        self.add_field(type='hidden', var='FORM_TYPE', values=[form_type])
-
-    def add_field(self, type='text-single', var=None, label=None,
-                        value=None, values=[], options={}):
-        self.addChild(Field(type, var, label, value, values, options))
+            return None
+
+
+    value = property(__value_get, __value_set, doc="""
+            The value for this field, for single-valued field types.
+
+            This is a special property accessing L{values}.  Writing to this
+            property empties L{values} and then sets the given value as the
+            only element of L{values}.  Reading from this propery returns the
+            first element of L{values}.
+            """)
+
+
+    def toElement(self):
+        """
+        Return the DOM representation of this Field.
+
+        @rtype L{domish.Element}.
+        """
+        if self.var is None and self.fieldType != 'fixed':
+            raise FieldNameRequiredError()
+
+        field = domish.Element((NS_X_DATA, 'field'))
+        field['type'] = self.fieldType
+
+        if self.var is not None:
+            field['var'] = self.var
+
+        if self.values:
+            if (self.fieldType not in ('hidden', 'jid-multi', 'list-multi',
+                                 'text-multi') and
+                len(self.values) > 1):
+                raise TooManyValuesError()
+
+            for value in self.values:
+                if self.fieldType == 'boolean':
+                    # We send out the textual representation of boolean values
+                    value = unicode(bool(value)).lower()
+                elif self.fieldType in ('jid-single', 'jid-multi'):
+                    value = value.full()
+
+                field.addElement('value', content=value)
+
+        if self.fieldType in ('list-single', 'list-multi'):
+            for option in self.options:
+                field.addChild(option.toElement())
+
+        if self.label is not None:
+            field['label'] = self.label
+
+        if self.desc is not None:
+            field.addElement('desc', content=self.desc)
+
+        if self.required:
+            field.addElement('required')
+
+        return field
+
+
+    @staticmethod
+    def _parse_desc(field, element):
+        desc = unicode(element)
+        if desc:
+            field.desc = desc
+
+
+    @staticmethod
+    def _parse_option(field, element):
+        field.options.append(Option.fromElement(element))
+
+
+    @staticmethod
+    def _parse_required(field, element):
+        field.required = True
+
+
+    @staticmethod
+    def _parse_value(field, element):
+        value = unicode(element)
+        if field.fieldType == 'boolean':
+            value = value.lower() in ('1', 'true')
+        elif field.fieldType in ('jid-multi', 'jid-single'):
+            value = JID(value)
+        field.values.append(value)
+
+
+    @staticmethod
+    def fromElement(element):
+        field = Field(None)
+
+        for eAttr, fAttr in {'type': 'fieldType',
+                             'var': 'var',
+                             'label': 'label'}.iteritems():
+            value = element.getAttribute(eAttr)
+            if value:
+                setattr(field, fAttr, value)
+
+
+        for child in element.elements():
+            if child.uri != NS_X_DATA:
+                continue
+
+            func = getattr(Field, '_parse_' + child.name, None)
+            if func:
+                func(field, child)
+
+        return field
+
+
+    @staticmethod
+    def fromDict(dictionary):
+        if 'type' in dictionary:
+            dictionary['fieldType'] = dictionary['type']
+            del dictionary['type']
+        if 'options' in dictionary:
+            options = []
+            for value, label in dictionary['options'].iteritems():
+                options.append(Option(value, label))
+            dictionary['options'] = options
+        return Field(**dictionary)
+
+
+
+class Form(object):
+    """
+    Data Form.
+
+    There are two similarly named properties of forms. The L{formType} is the
+    the so-called type of the form, and is set as the C{'type'} attribute
+    on the form's root element.
+
+    The Field Standardization specification in XEP-0068, defines a way to
+    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.
+
+    @ivar formType: Type of form. One of C{'form'}, C{'submit'}, {'cancel'},
+                    or {'result'}.
+    @type formType: C{str}.
+    @ivar formNamespace: The optional namespace of the field names for this
+                         form. This goes in the special field named
+                         C{'FORM_TYPE'}, if set.
+    @type formNamespace: C{str}.
+    """
+
+    def __init__(self, formType, title=None, instructions=None,
+                       formNamespace=None, fields=None):
+        self.formType = formType
+        self.title = title
+        self.instructions = instructions or []
+        self.formNamespace = formNamespace
+        self.fields = fields or []
+
+
+    def __repr__(self):
+        r = ["Form(formType=", repr(self.formType)]
+
+        if self.title:
+            r.append(", title=")
+            r.append(repr(self.title))
+        if self.instructions:
+            r.append(", instructions=")
+            r.append(repr(self.instructions))
+        if self.formNamespace:
+            r.append(", formNamespace=")
+            r.append(repr(self.formNamespace))
+        if self.fields:
+            r.append(", fields=")
+            r.append(repr(self.fields))
+        r.append(")")
+        return u"".join(r)
+
+
+    def toElement(self):
+        form = domish.Element((NS_X_DATA, 'x'))
+        form['type'] = self.formType
+
+        if self.title:
+            form.addElement('title', content=self.title)
+
+        for instruction in self.instructions:
+            form.addElement('instruction', content=instruction)
+
+        if self.formNamespace is not None:
+            field = Field('hidden', 'FORM_TYPE', self.formNamespace)
+            form.addChild(field.toElement())
+
+        for field in self.fields:
+            form.addChild(field.toElement())
+
+        return form
+
+
+    @staticmethod
+    def _parse_title(form, element):
+        title = unicode(element)
+        if title:
+            form.title = title
+
+
+    @staticmethod
+    def _parse_instructions(form, element):
+        instructions = unicode(element)
+        if instructions:
+            form.instructions.append(instructions)
+
+
+    @staticmethod
+    def _parse_field(form, element):
+        field = Field.fromElement(element)
+        if (field.var == "FORM_TYPE" and
+            field.fieldType == 'hidden' and
+            field.value):
+            form.formNamespace = field.value
+        else:
+            form.fields.append(field)
+
+    @staticmethod
+    def fromElement(element):
+        if (element.uri, element.name) != ((NS_X_DATA, 'x')):
+            raise Error("Element provided is not a Data Form")
+
+        form = Form(element.getAttribute("type"))
+
+        for child in element.elements():
+            if child.uri != NS_X_DATA:
+                continue
+
+            func = getattr(Form, '_parse_' + child.name, None)
+            if func:
+                func(form, child)
+
+        return form
+
+    def getValues(self):
+        values = {}
+
+        for field in self.fields:
+            if len(field.values) > 1:
+                value = field.values
+            else:
+                value = field.value
+
+            if field.var:
+                values[field.var] = value
+
+        return values

wokkel/iwokkel.py

@@ -390 +390 @@
         """
 
+    def getConfigurationOptions():
+        """
+        Retrieve all known node configuration options.
+
+        The returned dictionary holds the possible node configuration options
+        by option name. The value of each entry represents the specifics for
+        that option in a dictionary:
+
+        - C{'type'} (C{str}): The option's type (see
+          L{Field<wokkel.data_form.Field>}'s doc string for possible values).
+        - C{'label'} (C{unicode}): A human readable label for this option.
+        - C{'options'} (C{dict}): Optional list of possible values for this
+          option.
+
+        Example::
+
+            {
+            "pubsub#persist_items":
+                {"type": "boolean",
+                 "label": "Persist items to storage"},
+            "pubsub#deliver_payloads":
+                {"type": "boolean",
+                 "label": "Deliver payloads with event notifications"},
+            "pubsub#send_last_published_item":
+                {"type": "list-single",
+                 "label": "When to send the last published item",
+                 "options": {
+                     "never": "Never",
+                     "on_sub": "When a new subscription is processed"}
+                }
+            }
+
+        @rtype: C{dict}.
+        """
+
     def getDefaultConfiguration(requestor, service):
         """

wokkel/pubsub.py

@@ -174 +174 @@
         self.command = self.pubsub.addElement(verb)
 
+
     def send(self, to):
         """
@@ -199 +200 @@
         self.xmlstream.addObserver('/message/event[@xmlns="%s"]' %
                                    NS_PUBSUB_EVENT, self._onEvent)
+
 
     def _onEvent(self, message):
@@ -271 +273 @@
         return request.send(service).addCallback(cb)
 
+
     def deleteNode(self, service, nodeIdentifier):
         """
@@ -283 +286 @@
         request.command['node'] = nodeIdentifier
         return request.send(service)
+
 
     def subscribe(self, service, nodeIdentifier, subscriber):
@@ -315 +319 @@
         return request.send(service).addCallback(cb)
 
+
     def unsubscribe(self, service, nodeIdentifier, subscriber):
         """
@@ -331 +336 @@
         return request.send(service)
 
+
     def publish(self, service, nodeIdentifier, items=None):
         """
@@ -349 +355 @@
 
         return request.send(service)
+
 
     def items(self, service, nodeIdentifier, maxItems=None):
@@ -431 +438 @@
             }
 
+
     def __init__(self):
         self.discoIdentity = {'category': 'pubsub',
@@ -437 +445 @@
 
         self.pubSubFeatures = []
+
 
     def connectionMade(self):
@@ -444 +453 @@
         self.xmlstream.addObserver(PUBSUB_OWNER_SET, self.handleRequest)
 
+
     def getDiscoInfo(self, requestor, target, nodeIdentifier):
         info = []
@@ -454 +464 @@
                          for feature in self.pubSubFeatures])
 
-            return defer.succeed(info)
-        else:
-            def toInfo(nodeInfo):
-                if not nodeInfo:
-                    return []
-
-                (nodeType, metaData) = nodeInfo['type'], nodeInfo['meta-data']
-                info.append(disco.DiscoIdentity('pubsub', nodeType))
-                if metaData:
-                    form = data_form.Form(type="result",
-                                          form_type=NS_PUBSUB_META_DATA) 
-                    form.add_field("text-single",
-                                   "pubsub#node_type",
-                                   "The type of node (collection or leaf)",
-                                   nodeType)
-
-                    for metaDatum in metaData:
-                        form.add_field(**metaDatum)
-
-                    info.append(form)
-                return info
-
-            d = self.getNodeInfo(requestor, target, nodeIdentifier)
-            d.addCallback(toInfo)
-            return d
+        def toInfo(nodeInfo):
+            if not nodeInfo:
+                return
+
+            (nodeType, metaData) = nodeInfo['type'], nodeInfo['meta-data']
+            info.append(disco.DiscoIdentity('pubsub', nodeType))
+            if metaData:
+                form = data_form.Form(formType="result",
+                                      formNamespace=NS_PUBSUB_META_DATA)
+                form.fields.append(
+                        data_form.Field(
+                            var='pubsub#node_type',
+                            value=nodeType,
+                            label='The type of node (collection or leaf)'
+                        )
+                )
+
+                for metaDatum in metaData:
+                    form.fields.append(data_form.Field.fromDict(metaDatum))
+
+                info.append(form.toElement())
+
+        d = self.getNodeInfo(requestor, target, nodeIdentifier or '')
+        d.addCallback(toInfo)
+        d.addBoth(lambda result: info)
+        return d
+
 
     def getDiscoItems(self, requestor, target, nodeIdentifier):
@@ -489 +501 @@
         return d
 
+
+    def _findForm(self, element, formNamespace):
+        if not element:
+            return None
+
+        form = None
+        for child in element.elements():
+            try:
+                form = data_form.Form.fromElement(child)
+            except data_form.Error:
+                continue
+
+            if form.formNamespace != NS_PUBSUB_NODE_CONFIG:
+                continue
+
+        return form
+
+
     def _onPublish(self, iq):
         requestor = jid.internJID(iq["from"]).userhostJID()
@@ -504 +534 @@
 
         return self.publish(requestor, service, nodeIdentifier, items)
+
 
     def _onSubscribe(self, iq):
@@ -528 +559 @@
         return d
 
+
     def _onUnsubscribe(self, iq):
         requestor = jid.internJID(iq["from"]).userhostJID()
@@ -540 +572 @@
         return self.unsubscribe(requestor, service, nodeIdentifier, subscriber)
 
+
     def _onOptionsGet(self, iq):
         raise Unsupported('subscription-options-unavailable')
 
+
     def _onOptionsSet(self, iq):
         raise Unsupported('subscription-options-unavailable')
+
 
     def _onSubscriptions(self, iq):
@@ -564 +599 @@
         return d
 
+
     def _onAffiliations(self, iq):
         requestor = jid.internJID(iq["from"]).userhostJID()
@@ -582 +618 @@
         d.addCallback(toResponse)
         return d
+
 
     def _onCreate(self, iq):
@@ -601 +638 @@
         return d
 
-    def _formFromConfiguration(self, options):
-        form = data_form.Form(type="form", form_type=NS_PUBSUB_NODE_CONFIG)
-
-        for option in options:
-            form.add_field(**option)
+
+    def _formFromConfiguration(self, values):
+        options = self.getConfigurationOptions()
+        form = data_form.Form(formType="form",
+                              formNamespace=NS_PUBSUB_NODE_CONFIG)
+
+        for name, value in values.iteritems():
+            if name in options:
+                option = {'var': name}
+                option.update(options[name])
+                if isinstance(value, list):
+                    option['values'] = value
+                else:
+                    option['value'] = value
+                form.fields.append(data_form.Field.fromDict(option))
 
         return form
+
 
     def _onDefault(self, iq):
@@ -616 +664 @@
             response = domish.Element((NS_PUBSUB_OWNER, "pubsub"))
             default = response.addElement("default")
-            default.addChild(self._formFromConfiguration(options))
+            default.addChild(self._formFromConfiguration(options).toElement())
             return response
 
@@ -623 +671 @@
         return d
 
+
     def _onConfigureGet(self, iq):
         requestor = jid.internJID(iq["from"]).userhostJID()
@@ -631 +680 @@
             response = domish.Element((NS_PUBSUB_OWNER, "pubsub"))
             configure = response.addElement("configure")
-            configure.addChild(self._formFromConfiguration(options))
+            configure.addChild(self._formFromConfiguration(options).toElement())
 
             if nodeIdentifier:
@@ -642 +691 @@
         return d
 
+
     def _onConfigureSet(self, iq):
         requestor = jid.internJID(iq["from"]).userhostJID()
@@ -647 +697 @@
         nodeIdentifier = iq.pubsub.configure["node"]
 
-        def getFormOptions(form):
-            options = {}
-
-            for element in form.elements():
-                if element.name == 'field' and \
-                   element.uri == data_form.NS_X_DATA:
-                    try:
-                        options[element["var"]] = str(element.value)
-                    except (KeyError, AttributeError):
-                        raise BadRequest
-
-            return options
-
         # Search configuration form with correct FORM_TYPE and process it
 
-        for element in iq.pubsub.configure.elements():
-            if element.name != 'x' or element.uri != data_form.NS_X_DATA:
-                continue
-
-            type = element.getAttribute("type")
-            if type == "cancel":
-                return None
-            elif type != "submit":
-                continue
-
-            options = getFormOptions(element)
-
-            if options["FORM_TYPE"] == NS_PUBSUB + "#node_config":
-                del options["FORM_TYPE"]
+        form = self._findForm(iq.pubsub.configure, NS_PUBSUB_NODE_CONFIG)
+
+        if form:
+            if form.formType == 'submit':
+                options = form.getValues()
+
                 return self.setConfiguration(requestor, service,
                                              nodeIdentifier, options)
-
-        raise BadRequest
+            elif form.formType == 'cancel':
+                return None
+
+        raise BadRequest()
+
 
     def _onItems(self, iq):
@@ -721 +753 @@
         return d
 
+
     def _onRetract(self, iq):
         requestor = jid.internJID(iq["from"]).userhostJID()
@@ -741 +774 @@
                             itemIdentifiers)
 
+
     def _onPurge(self, iq):
         requestor = jid.internJID(iq["from"]).userhostJID()
@@ -752 +786 @@
         return self.purge(requestor, service, nodeIdentifier)
 
+
     def _onDelete(self, iq):
         requestor = jid.internJID(iq["from"]).userhostJID()
@@ -763 +798 @@
         return self.delete(requestor, service, nodeIdentifier)
 
+
     def _onAffiliationsGet(self, iq):
         raise Unsupported('modify-affiliations')
 
+
     def _onAffiliationsSet(self, iq):
         raise Unsupported('modify-affiliations')
 
+
     def _onSubscriptionsGet(self, iq):
         raise Unsupported('manage-subscriptions')
+
 
     def _onSubscriptionsSet(self, iq):
@@ -788 +827 @@
             self.send(message)
 
+
     def notifyDelete(self, service, nodeIdentifier, recipients):
         for recipient in recipients:
@@ -798 +838 @@
             self.send(message)
 
+
     def getNodeInfo(self, requestor, service, nodeIdentifier):
         return None
 
+
     def getNodes(self, requestor, service):
         return []
 
+
     def publish(self, requestor, service, nodeIdentifier, items):
         raise Unsupported('publish')
 
+
     def subscribe(self, requestor, service, nodeIdentifier, subscriber):
         raise Unsupported('subscribe')
 
+
     def unsubscribe(self, requestor, service, nodeIdentifier, subscriber):
         raise Unsupported('subscribe')
 
+
     def subscriptions(self, requestor, service):
         raise Unsupported('retrieve-subscriptions')
 
+
     def affiliations(self, requestor, service):
         raise Unsupported('retrieve-affiliations')
 
+
     def create(self, requestor, service, nodeIdentifier):
         raise Unsupported('create-nodes')
 
+
+    def getConfigurationOptions(self):
+        return {}
+
+
     def getDefaultConfiguration(self, requestor, service):
         raise Unsupported('retrieve-default')
 
+
     def getConfiguration(self, requestor, service, nodeIdentifier):
         raise Unsupported('config-node')
 
+
     def setConfiguration(self, requestor, service, nodeIdentifier, options):
         raise Unsupported('config-node')
+
 
     def items(self, requestor, service, nodeIdentifier, maxItems,
@@ -835 +891 @@
         raise Unsupported('retrieve-items')
 
+
     def retract(self, requestor, service, nodeIdentifier, itemIdentifiers):
         raise Unsupported('retract-items')
 
+
     def purge(self, requestor, service, nodeIdentifier):
         raise Unsupported('purge-nodes')
 
+
     def delete(self, requestor, service, nodeIdentifier):
         raise Unsupported('delete-nodes')

wokkel/test/test_pubsub.py

@@ -5 +5 @@
 Tests for L{wokkel.pubsub}
 """
+
 from zope.interface import verify
 
@@ -13 +14 @@
 from twisted.words.protocols.jabber.jid import JID
 
-from wokkel import iwokkel, pubsub
+from wokkel import data_form, iwokkel, pubsub
 from wokkel.generic import parseXml
 from wokkel.test.helpers import XmlStreamStub
@@ -23 +24 @@
 
 NS_PUBSUB = 'http://jabber.org/protocol/pubsub'
+NS_PUBSUB_CONFIG = 'http://jabber.org/protocol/pubsub#node_config'
 NS_PUBSUB_ERRORS = 'http://jabber.org/protocol/pubsub#errors'
 NS_PUBSUB_EVENT = 'http://jabber.org/protocol/pubsub#event'
+NS_PUBSUB_OWNER = 'http://jabber.org/protocol/pubsub#owner'
 
 def calledAsync(fn):
@@ -445 +448 @@
     """
 
-    def handleRequest(self, handler, iq):
+    def setUp(self):
+        self.service = pubsub.PubSubService()
+
+    def handleRequest(self, xml):
         """
         Find a handler and call it directly
         """
-        for queryString, method in handler.iqHandlers.iteritems():
+        handler = None
+        iq = parseXml(xml)
+        for queryString, method in self.service.iqHandlers.iteritems():
             if xpath.internQuery(queryString).matches(iq):
-                handler = getattr(handler, method)
+                handler = getattr(self.service, method)
 
         if handler:
@@ -465 +473 @@
         Do instances of L{pubsub.PubSubService} provide L{iwokkel.IPubSubService}?
         """
-        verify.verifyObject(iwokkel.IPubSubService, pubsub.PubSubService())
+        verify.verifyObject(iwokkel.IPubSubService, self.service)
 
 
@@ -484 +492 @@
             self.assertEquals('bad-request', result.condition)
 
-        handler = pubsub.PubSubService()
-        d = self.handleRequest(handler, parseXml(xml))
+        d = self.handleRequest(xml)
         self.assertFailure(d, error.StanzaError)
         d.addCallback(cb)
         return d
+
 
     def test_onPublish(self):
@@ -495 +503 @@
         called.
         """
-        class Handler(pubsub.PubSubService):
-            def publish(self, requestor, service, nodeIdentifier, items):
-                return defer.succeed((requestor, service,nodeIdentifier,
-                                      items))
 
         xml = """
@@ -509 +513 @@
         """
 
-        def cb(result):
-            self.assertEqual((JID('user@example.org'),
-                              JID('pubsub.example.org'),'test', []), result)
-
-        handler = Handler()
-        d = self.handleRequest(handler, parseXml(xml))
-        d.addCallback(cb)
-        return d
+        def publish(requestor, service, nodeIdentifier, items):
+            self.assertEqual(JID('user@example.org'), requestor)
+            self.assertEqual(JID('pubsub.example.org'), service)
+            self.assertEqual('test', nodeIdentifier)
+            self.assertEqual([], items)
+            return defer.succeed(None)
+
+        self.service.publish = publish
+        return self.handleRequest(xml)
 
 
@@ -524 +529 @@
         """
 
-        handler = pubsub.PubSubService()
         xml = """
         <iq type='get' to='pubsub.example.org'
@@ -539 +543 @@
             self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
 
-        handler = pubsub.PubSubService()
-        d = self.handleRequest(handler, parseXml(xml))
+        d = self.handleRequest(xml)
         self.assertFailure(d, error.StanzaError)
         d.addCallback(cb)
@@ -546 +549 @@
 
 
+    def test_onDefault(self):
+        """
+        A default request should result in
+        L{PubSubService.getDefaultConfiguration} being called.
+        """
+
+        xml = """
+        <iq type='get' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'>
+            <default/>
+          </pubsub>
+        </iq>
+        """
+
+        def getConfigurationOptions():
+            return {
+                "pubsub#persist_items":
+                    {"type": "boolean",
+                     "label": "Persist items to storage"},
+                "pubsub#deliver_payloads":
+                    {"type": "boolean",
+                     "label": "Deliver payloads with event notifications"}
+                }
+
+        def getDefaultConfiguration(requestor, service):
+            self.assertEqual(JID('user@example.org'), requestor)
+            self.assertEqual(JID('pubsub.example.org'), service)
+            return defer.succeed({})
+
+        def cb(element):
+            self.assertEqual('pubsub', element.name)
+            self.assertEqual(NS_PUBSUB_OWNER, element.uri)
+            self.assertEqual(NS_PUBSUB_OWNER, element.default.uri)
+            form = data_form.Form.fromElement(element.default.x)
+            self.assertEqual(NS_PUBSUB_CONFIG, form.formNamespace)
+
+        self.service.getConfigurationOptions = getConfigurationOptions
+        self.service.getDefaultConfiguration = getDefaultConfiguration
+        d = self.handleRequest(xml)
+        d.addCallback(cb)
+        return d
+
+
+    def test_onConfigureGet(self):
+        """
+        On a node configuration get request L{PubSubService.getConfiguration}
+        is called and results in a data form with the configuration.
+        """
+
+        xml = """
+        <iq type='get' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'>
+            <configure node='test'/>
+          </pubsub>
+        </iq>
+        """
+
+        def getConfigurationOptions():
+            return {
+                "pubsub#persist_items":
+                    {"type": "boolean",
+                     "label": "Persist items to storage"},
+                "pubsub#deliver_payloads":
+                    {"type": "boolean",
+                     "label": "Deliver payloads with event notifications"}
+                }
+
+        def getConfiguration(requestor, service, nodeIdentifier):
+            self.assertEqual(JID('user@example.org'), requestor)
+            self.assertEqual(JID('pubsub.example.org'), service)
+            self.assertEqual('test', nodeIdentifier)
+
+            return defer.succeed({'pubsub#deliver_payloads': '0',
+                                  'pubsub#persist_items': '1'})
+
+        def cb(element):
+            self.assertEqual('pubsub', element.name)
+            self.assertEqual(NS_PUBSUB_OWNER, element.uri)
+            self.assertEqual(NS_PUBSUB_OWNER, element.configure.uri)
+            form = data_form.Form.fromElement(element.configure.x)
+            self.assertEqual(NS_PUBSUB_CONFIG, form.formNamespace)
+            fields = dict([(field.var, field) for field in form.fields])
+
+            self.assertIn('pubsub#deliver_payloads', fields)
+            field = fields['pubsub#deliver_payloads']
+            self.assertEqual('boolean', field.fieldType)
+            self.assertEqual(True, field.value)
+
+            self.assertIn('pubsub#persist_items', fields)
+            field = fields['pubsub#persist_items']
+            self.assertEqual('boolean', field.fieldType)
+            self.assertEqual(True, field.value)
+
+        self.service.getConfigurationOptions = getConfigurationOptions
+        self.service.getConfiguration = getConfiguration
+        d = self.handleRequest(xml)
+        d.addCallback(cb)
+        return d
+
+
+    def test_onConfigureSet(self):
+        """
+        On a node configuration set request the Data Form is parsed and
+        L{PubSubService.setConfiguration} is called with the passed options.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'>
+            <configure node='test'>
+              <x xmlns='jabber:x:data' type='submit'>
+                <field var='FORM_TYPE' type='hidden'>
+                  <value>http://jabber.org/protocol/pubsub#node_config</value>
+                </field>
+                <field var='pubsub#deliver_payloads'><value>0</value></field>
+                <field var='pubsub#persist_items'><value>1</value></field>
+              </x>
+            </configure>
+          </pubsub>
+        </iq>
+        """
+
+        def setConfiguration(requestor, service, nodeIdentifier, options):
+            self.assertEqual(JID('user@example.org'), requestor)
+            self.assertEqual(JID('pubsub.example.org'), service)
+            self.assertEqual('test', nodeIdentifier)
+            self.assertEqual({'pubsub#deliver_payloads': '0',
+                              'pubsub#persist_items': '1'}, options)
+            return defer.succeed(None)
+
+        self.service.setConfiguration = setConfiguration
+        return self.handleRequest(xml)
+
+
+    def test_onConfigureSetCancel(self):
+        """
+        The node configuration is cancelled, L{PubSubService.setConfiguration}
+        not called.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'>
+            <configure node='test'>
+              <x xmlns='jabber:x:data' type='cancel'>
+                <field var='FORM_TYPE' type='hidden'>
+                  <value>http://jabber.org/protocol/pubsub#node_config</value>
+                </field>
+              </x>
+            </configure>
+          </pubsub>
+        </iq>
+        """
+
+        def setConfiguration(requestor, service, nodeIdentifier, options):
+            self.fail("Unexpected call to setConfiguration")
+
+        self.service.setConfiguration = setConfiguration
+        return self.handleRequest(xml)
+
+
     def test_onItems(self):
         """
         On a items request, return all items for the given node.
         """
-        class Handler(pubsub.PubSubService):
-            def items(self, *args, **kwargs):
-                self.args = args
-                self.kwargs = kwargs
-                return defer.succeed([pubsub.Item('current')])
-
         xml = """
         <iq type='get' to='pubsub.example.org'
@@ -565 +727 @@
         """
 
+        def items(requestor, service, nodeIdentifier, maxItems, items):
+            self.assertEqual(JID('user@example.org'), requestor)
+            self.assertEqual(JID('pubsub.example.org'), service)
+            self.assertEqual('test', nodeIdentifier)
+            self.assertIdentical(None, maxItems)
+            self.assertEqual([], items)
+            return defer.succeed([pubsub.Item('current')])
+
         def cb(element):
-            self.assertEqual((JID('user@example.org'),
-                              JID('pubsub.example.org'), 'test', None, []),
-                             handler.args)
-
             self.assertEqual(NS_PUBSUB, element.uri)
             self.assertEqual(NS_PUBSUB, element.items.uri)
@@ -579 +745 @@
             self.assertEqual('current', item['id'])
 
-        handler = Handler()
-        d = self.handleRequest(handler, parseXml(xml))
-        d.addCallback(cb)
-        return d
+        self.service.items = items
+        d = self.handleRequest(xml)
+        d.addCallback(cb)
+        return d