Changes in [133:2ea562934152:134:250a1041a437]

Files:

• LICENSE (modified) (1 diff)
• README (modified) (1 diff)
• debian/changelog (added)
• debian/compat (added)
• debian/control (added)
• debian/copyright (added)
• debian/docs (added)
• debian/python-wokkel.postinst (added)
• debian/rules (added)
• setup.py (modified) (2 diffs, 1 prop)
• twisted/plugins/server.py (added)
• wokkel/__init__.py (modified) (1 diff)
• wokkel/client.py (modified) (1 diff, 1 prop)
• wokkel/compat.py (modified) (1 diff, 1 prop)
• wokkel/component.py (modified) (3 diffs, 1 prop)
• wokkel/componentservertap.py (added)
• wokkel/data_form.py (modified) (17 diffs, 1 prop)
• wokkel/delay.py (added)
• wokkel/disco.py (modified) (10 diffs, 1 prop)
• wokkel/formats.py (modified) (1 diff, 1 prop)
• wokkel/generic.py (modified) (5 diffs, 1 prop)
• wokkel/iwokkel.py (modified) (1 prop)
• wokkel/ping.py (modified) (2 diffs, 1 prop)
• wokkel/pubsub.py (modified) (44 diffs, 1 prop)
• wokkel/server.py (modified) (1 diff, 1 prop)
• wokkel/shim.py (modified) (1 diff, 1 prop)
• wokkel/subprotocols.py (modified) (12 diffs, 1 prop)
• wokkel/test/__init__.py (modified) (1 diff, 1 prop)
• wokkel/test/helpers.py (modified) (1 diff, 1 prop)
• wokkel/test/test_client.py (modified) (1 diff, 1 prop)
• wokkel/test/test_compat.py (modified) (1 diff, 1 prop)
• wokkel/test/test_component.py (modified) (3 diffs, 1 prop)
• wokkel/test/test_data_form.py (modified) (12 diffs, 1 prop)
• wokkel/test/test_delay.py (added)
• wokkel/test/test_disco.py (modified) (11 diffs, 1 prop)
• wokkel/test/test_generic.py (modified) (3 diffs, 1 prop)
• wokkel/test/test_ping.py (modified) (2 diffs, 1 prop)
• wokkel/test/test_pubsub.py (modified) (50 diffs, 1 prop)
• wokkel/test/test_server.py (modified) (1 diff, 1 prop)
• wokkel/test/test_shim.py (modified) (1 diff, 1 prop)
• wokkel/test/test_subprotocols.py (modified) (11 diffs, 1 prop)
• wokkel/test/test_xmppim.py (modified) (1 diff)
• wokkel/xmppim.py (modified) (1 diff, 1 prop)

LICENSE

@@ -1 @@
-Copyright (c) 2003-2009 Ralph Meijer
+Copyright (c) 2003-2011 Ralph Meijer.
 
 Permission is hereby granted, free of charge, to any person obtaining

README

@@ -31 +31 @@
 ======================
 
-The code in this distribution is Copyright (c) 2003-2009 Ralph Meijer, unless
-excplicitely specified otherwise.
+The code in this distribution is Copyright (c) Ralph Meijer, unless
+explicitly specified otherwise.
 
 Wokkel is made available under the MIT License. The included LICENSE file

setup.py

@@ -1 +1 @@
 #!/usr/bin/env python
 
-# Copyright (c) 2003-2009 Ralph Meijer
+# Copyright (c) Ralph Meijer.
 # See LICENSE for details.
 
@@ -18 +18 @@
           'wokkel',
           'wokkel.test',
+          'twisted.plugins',
       ],
+      package_data={'twisted.plugins': ['twisted/plugins/server.py']},
 )

wokkel/__init__.py

@@ -1 @@
-# Copyright (c) 2003-2007 Ralph Meijer
+# Copyright (c) Ralph Meijer.
 # See LICENSE for details
 

wokkel/client.py

@@ -1 +1 @@
 # -*- test-case-name: wokkel.test.test_client -*-
 #
-# Copyright (c) 2003-2009 Ralph Meijer
+# Copyright (c) Ralph Meijer.
 # See LICENSE for details.
 

wokkel/compat.py

@@ -1 +1 @@
 # -*- test-case-name: wokkel.test.test_compat -*-
 #
-# Copyright (c) 2001-2009 Twisted Matrix Laboratories.
+# Copyright (c) Twisted Matrix Laboratories.
 # See LICENSE for details.
 

wokkel/component.py

@@ -1 +1 @@
 # -*- test-case-name: wokkel.test.test_component -*-
 #
-# Copyright (c) 2003-2008 Ralph Meijer
+# Copyright (c) Ralph Meijer.
 # See LICENSE for details.
 
@@ -158 +158 @@
 
     @ivar secret: The shared used to authorized incoming component connections.
-    @type secret: C{str}.
+    @type secret: C{unicode}.
     """
 
@@ -237 +237 @@
         be exchanged.
         """
-        calculatedHash = xmlstream.hashPassword(self.xmlstream.sid, self.secret)
+        calculatedHash = xmlstream.hashPassword(self.xmlstream.sid,
+                                                unicode(self.secret))
         if handshake != calculatedHash:
             exc = error.StreamError('not-authorized', text='Invalid hash')

wokkel/data_form.py

@@ -1 +1 @@
 # -*- test-case-name: wokkel.test.test_data_form -*-
 #
-# Copyright (c) 2003-2009 Ralph Meijer
+# Copyright (c) Ralph Meijer.
 # See LICENSE for details.
 
@@ -76 +76 @@
             option['label'] = self.label
         return option
+
 
     @staticmethod
@@ -130 +131 @@
         self.fieldType = fieldType
         self.var = var
+
         if value is not None:
             self.value = value
         else:
             self.values = values or []
+
+        self.label = label
 
         try:
@@ -141 +145 @@
             self.options = options or []
 
-        self.label = label
         self.desc = desc
         self.required = required
@@ -213 +216 @@
         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 +237 @@
             self.values = newValues
 
+
     def toElement(self, asForm=False):
         """
@@ -245 +249 @@
         field = domish.Element((NS_X_DATA, 'field'))
 
-        if asForm or self.fieldType != 'text-single':
+        if self.fieldType:
             field['type'] = self.fieldType
 
@@ -252 +256 @@
 
         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)
@@ -323 +327 @@
 
     @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
@@ -344 +356 @@
     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.
@@ -352 +364 @@
     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}
     """
 
@@ -393 +417 @@
             r.append(", formNamespace=")
             r.append(repr(self.formNamespace))
-        if self.fields:
+        if self.fieldList:
             r.append(", fields=")
             r.append(repr(self.fieldList))
@@ -404 +428 @@
         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.
@@ -417 +441 @@
 
 
+    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
@@ -425 +514 @@
 
         for instruction in self.instructions:
-            form.addElement('instruction', content=instruction)
+            form.addElement('instructions', content=instruction)
 
         if self.formNamespace is not None:
@@ -478 +567 @@
         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:
@@ -490 +594 @@
 
         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)
+
+
+
+def findForm(element, formNamespace):
+    """
+    Find a Data Form.
+
+    Look for an element that represents a Data Form with the specified
+    form namespace as a child element of the given element.
+    """
+    if not element:
+        return None
+
+    for child in element.elements():
+        if (child.uri, child.name) == ((NS_X_DATA, 'x')):
+            form = Form.fromElement(child)
+
+            if (form.formNamespace == formNamespace or
+                not form.formNamespace and form.formType=='cancel'):
+                return form
+
+    return None

wokkel/disco.py

@@ -1 +1 @@
 # -*- test-case-name: wokkel.test.test_disco -*-
 #
-# Copyright (c) 2003-2009 Ralph Meijer
+# Copyright (c) Ralph Meijer.
 # See LICENSE for details.
 
@@ -15 +15 @@
 from twisted.words.xish import domish
 
-from wokkel import data_form
-from wokkel.compat import IQ
+from wokkel import data_form, generic
 from wokkel.iwokkel import IDisco
 from wokkel.subprotocols import IQHandlerMixin, XMPPHandler
@@ -120 +119 @@
     @type nodeIdentifier: C{unicode}
     @ivar features: Features as L{DiscoFeature}.
-    @type features: C{set)
+    @type features: C{set}
     @ivar identities: Identities as a mapping from (category, type) to name,
                       all C{unicode}.
@@ -347 +346 @@
 
 
-class _DiscoRequest(IQ):
-    """
-    Element representing an XMPP service discovery request.
-    """
-
-    def __init__(self, xs, namespace, nodeIdentifier=''):
-        """
-        Initialize the request.
-
-        @param xs: XML Stream the request should go out on.
-        @type xs: L{xmlstream.XmlStream}
-        @param namespace: Request namespace.
-        @type namespace: C{str}
-        @param nodeIdentifier: Node to request info from.
-        @type nodeIdentifier: C{unicode}
-        """
-        IQ.__init__(self, xs, "get")
-        query = self.addElement((namespace, 'query'))
-        if nodeIdentifier:
-            query['node'] = nodeIdentifier
+class _DiscoRequest(generic.Request):
+    """
+    A Service Discovery request.
+
+    @ivar verb: Type of request: C{'info'} or C{'items'}.
+    @type verb: C{str}
+    @ivar nodeIdentifier: Optional node to request info for.
+    @type nodeIdentifier: C{unicode}
+    """
+
+    verb = None
+    nodeIdentifier = ''
+
+    _requestVerbMap = {
+            NS_DISCO_INFO: 'info',
+            NS_DISCO_ITEMS: 'items',
+            }
+
+    _verbRequestMap = dict(((v, k) for k, v in _requestVerbMap.iteritems()))
+
+    def __init__(self, verb=None, nodeIdentifier='',
+                       recipient=None, sender=None):
+        generic.Request.__init__(self, recipient=recipient, sender=sender,
+                                       stanzaType='get')
+        self.verb = verb
+        self.nodeIdentifier = nodeIdentifier
+
+
+    def parseElement(self, element):
+        generic.Request.parseElement(self, element)
+
+        verbElement = None
+        for child in element.elements():
+            if child.name == 'query' and child.uri in self._requestVerbMap:
+                self.verb = self._requestVerbMap[child.uri]
+                verbElement = child
+
+        if verbElement:
+            self.nodeIdentifier = verbElement.getAttribute('node', '')
+
+
+    def toElement(self):
+        element = generic.Request.toElement(self)
+
+        childURI = self._verbRequestMap[self.verb]
+        query = element.addElement((childURI, 'query'))
+
+        if self.nodeIdentifier:
+            query['node'] = self.nodeIdentifier
+
+        return element
 
 
@@ -389 +419 @@
         """
 
-        request = _DiscoRequest(self.xmlstream, NS_DISCO_INFO, nodeIdentifier)
-        if sender is not None:
-            request['from'] = unicode(sender)
-
-        d = request.send(entity.full())
+        request = _DiscoRequest('info', nodeIdentifier)
+        request.sender = sender
+        request.recipient = entity
+
+        d = self.request(request)
         d.addCallback(lambda iq: DiscoInfo.fromElement(iq.query))
         return d
@@ -412 +442 @@
         """
 
-        request = _DiscoRequest(self.xmlstream, NS_DISCO_ITEMS, nodeIdentifier)
-        if sender is not None:
-            request['from'] = unicode(sender)
-
-        d = request.send(entity.full())
+        request = _DiscoRequest('items', nodeIdentifier)
+        request.sender = sender
+        request.recipient = entity
+
+        d = self.request(request)
         d.addCallback(lambda iq: DiscoItems.fromElement(iq.query))
         return d
@@ -446 +476 @@
         @type iq: L{Element<twisted.words.xish.domish.Element>}
         """
-        requestor = jid.internJID(iq["from"])
-        target = jid.internJID(iq["to"])
-        nodeIdentifier = iq.query.getAttribute("node", '')
+        request = _DiscoRequest.fromElement(iq)
 
         def toResponse(info):
-            if nodeIdentifier and not info:
+            if request.nodeIdentifier and not info:
                 raise error.StanzaError('item-not-found')
             else:
                 response = DiscoInfo()
-                response.nodeIdentifier = nodeIdentifier
+                response.nodeIdentifier = request.nodeIdentifier
 
                 for item in info:
@@ -462 +490 @@
             return response.toElement()
 
-        d = self.info(requestor, target, nodeIdentifier)
+        d = self.info(request.sender, request.recipient,
+                      request.nodeIdentifier)
         d.addCallback(toResponse)
         return d
@@ -474 +503 @@
         @type iq: L{Element<twisted.words.xish.domish.Element>}
         """
-        requestor = jid.internJID(iq["from"])
-        target = jid.internJID(iq["to"])
-        nodeIdentifier = iq.query.getAttribute("node", '')
+        request = _DiscoRequest.fromElement(iq)
 
         def toResponse(items):
             response = DiscoItems()
-            response.nodeIdentifier = nodeIdentifier
+            response.nodeIdentifier = request.nodeIdentifier
 
             for item in items:
@@ -487 +514 @@
             return response.toElement()
 
-        d = self.items(requestor, target, nodeIdentifier)
+        d = self.items(request.sender, request.recipient,
+                       request.nodeIdentifier)
         d.addCallback(toResponse)
         return d

wokkel/formats.py

@@ -1 @@
-# Copyright (c) 2003-2008 Ralph Meijer
+# Copyright (c) Ralph Meijer.
 # See LICENSE for details.
 

wokkel/generic.py

@@ -1 +1 @@
 # -*- test-case-name: wokkel.test.test_generic -*-
 #
-# Copyright (c) 2003-2009 Ralph Meijer
+# Copyright (c) Ralph Meijer.
 # See LICENSE for details.
 
@@ -21 +21 @@
     from wokkel.compat import BootstrapMixin
 
-from wokkel import disco
 from wokkel.iwokkel import IDisco
 from wokkel.subprotocols import XMPPHandler
@@ -121 +120 @@
 
         if not node:
+            from wokkel import disco
             info.add(disco.DiscoFeature(NS_VERSION))
 
@@ -175 +175 @@
     """
 
+    recipient = None
+    sender = None
     stanzaKind = None
     stanzaID = None
@@ -237 +239 @@
 
 
+class Request(Stanza):
+    """
+    IQ request stanza.
+
+    This is a base class for IQ get or set stanzas, to be used with
+    L{wokkel.subprotocols.StreamManager.request}.
+    """
+
+    stanzaKind = 'iq'
+    stanzaType = 'get'
+    timeout = None
+
+    def __init__(self, recipient=None, sender=None, stanzaType='get'):
+        Stanza.__init__(self, recipient=recipient, sender=sender)
+        self.stanzaType = stanzaType
+
+
+    def toElement(self):
+        element = Stanza.toElement(self)
+
+        if not self.stanzaID:
+            element.addUniqueId()
+            self.stanzaID = element['id']
+
+        return element
+
+
+
 class DeferredXmlStreamFactory(BootstrapMixin, protocol.ClientFactory):
     protocol = xmlstream.XmlStream

wokkel/ping.py

@@ -1 +1 @@
 # -*- test-case-name: wokkel.test.test_ping -*-
 #
-# Copyright (c) 2003-2009 Ralph Meijer
+# Copyright (c) Ralph Meijer.
 # See LICENSE for details.
 
@@ -95 +95 @@
         response = toResponse(iq, 'result')
         self.xmlstream.send(response)
+        iq.handled = True
 
 

wokkel/pubsub.py

@@ -1 +1 @@
 # -*- test-case-name: wokkel.test.test_pubsub -*-
 #
-# Copyright (c) 2003-2009 Ralph Meijer
+# Copyright (c) Ralph Meijer.
 # See LICENSE for details.
 
@@ -103 +103 @@
     A subscription to a node.
 
-    @ivar nodeIdentifier: The identifier of the node subscribed to.
-                          The root node is denoted by C{None}.
+    @ivar nodeIdentifier: The identifier of the node subscribed to.  The root
+        node is denoted by C{None}.
+    @type nodeIdentifier: C{unicode}
+
     @ivar subscriber: The subscribing entity.
+    @type subscriber: L{jid.JID}
+
     @ivar state: The subscription state. One of C{'subscribed'}, C{'pending'},
                  C{'unconfigured'}.
+    @type state: C{unicode}
+
     @ivar options: Optional list of subscription options.
-    @type options: C{dict}.
-    """
-
-    def __init__(self, nodeIdentifier, subscriber, state, options=None):
+    @type options: C{dict}
+
+    @ivar subscriptionIdentifier: Optional subscription identifier.
+    @type subscriptionIdentifier: C{unicode}
+    """
+
+    def __init__(self, nodeIdentifier, subscriber, state, options=None,
+                       subscriptionIdentifier=None):
         self.nodeIdentifier = nodeIdentifier
         self.subscriber = subscriber
         self.state = state
         self.options = options or {}
+        self.subscriptionIdentifier = subscriptionIdentifier
+
+
+    @staticmethod
+    def fromElement(element):
+        return Subscription(
+                element.getAttribute('node'),
+                jid.JID(element.getAttribute('jid')),
+                element.getAttribute('subscription'),
+                subscriptionIdentifier=element.getAttribute('subid'))
+
+
+    def toElement(self, defaultUri=None):
+        """
+        Return the DOM representation of this subscription.
+
+        @rtype: L{domish.Element}
+        """
+        element = domish.Element((defaultUri, 'subscription'))
+        if self.nodeIdentifier:
+            element['node'] = self.nodeIdentifier
+        element['jid'] = unicode(self.subscriber)
+        element['subscription'] = self.state
+        if self.subscriptionIdentifier:
+            element['subid'] = self.subscriptionIdentifier
+        return element
 
 
@@ -139 +175 @@
         """
 
-        domish.Element.__init__(self, (NS_PUBSUB, 'item'))
+        domish.Element.__init__(self, (None, 'item'))
         if id is not None:
             self['id'] = id
@@ -185 +221 @@
                          L{Subscription}.
     @type subscriptions: C{set}
+    @ivar affiliations: Affiliations to be modified, as a dictionary of entity
+                        (L{JID} to affiliation (C{unicode}).
+    @type affiliations: C{dict}
     """
 
@@ -199 +238 @@
     subscriptionIdentifier = None
     subscriptions = None
+    affiliations = None
 
     # Map request iq type and subelement name to request verb
@@ -229 +269 @@
     _parameters = {
         'publish': ['node', 'items'],
-        'subscribe': ['nodeOrEmpty', 'jid'],
-        'unsubscribe': ['nodeOrEmpty', 'jid'],
-        'optionsGet': ['nodeOrEmpty', 'jid'],
-        'optionsSet': ['nodeOrEmpty', 'jid', 'options'],
+        'subscribe': ['nodeOrEmpty', 'jid', 'optionsWithSubscribe'],
+        'unsubscribe': ['nodeOrEmpty', 'jid', 'subidOrNone'],
+        'optionsGet': ['nodeOrEmpty', 'jid', 'subidOrNone'],
+        'optionsSet': ['nodeOrEmpty', 'jid', 'options', 'subidOrNone'],
         'subscriptions': [],
         'affiliations': [],
-        'create': ['nodeOrNone'],
+        'create': ['nodeOrNone', 'configureOrNone'],
         'default': ['default'],
         'configureGet': ['nodeOrEmpty'],
         'configureSet': ['nodeOrEmpty', 'configure'],
-        'items': ['node', 'maxItems', 'itemIdentifiers'],
+        'items': ['node', 'maxItems', 'itemIdentifiers', 'subidOrNone'],
         'retract': ['node', 'itemIdentifiers'],
         'purge': ['node'],
         'delete': ['node'],
         'affiliationsGet': ['nodeOrEmpty'],
-        'affiliationsSet': [],
+        'affiliationsSet': ['nodeOrEmpty', 'affiliations'],
         'subscriptionsGet': ['nodeOrEmpty'],
         'subscriptionsSet': [],
@@ -251 +291 @@
     def __init__(self, verb=None):
         self.verb = verb
-
-
-    @staticmethod
-    def _findForm(element, formNamespace):
-        """
-        Find a Data Form.
-
-        Look for an element that represents a Data Form with the specified
-        form namespace as a child element of the given element.
-        """
-        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
 
 
@@ -343 +359 @@
         if self.items:
             for item in self.items:
+                item.uri = NS_PUBSUB
                 verbElement.addChild(item)
 
@@ -367 +384 @@
         Parse node type out of a request for the default node configuration.
         """
-        form = PubSubRequest._findForm(verbElement, NS_PUBSUB_NODE_CONFIG)
+        form = data_form.findForm(verbElement, NS_PUBSUB_NODE_CONFIG)
         if form and form.formType == 'submit':
             values = form.getValues()
@@ -379 +396 @@
         Parse options out of a request for setting the node configuration.
         """
-        form = PubSubRequest._findForm(verbElement, NS_PUBSUB_NODE_CONFIG)
+        form = data_form.findForm(verbElement, NS_PUBSUB_NODE_CONFIG)
         if form:
-            if form.formType == 'submit':
-                self.options = form.getValues()
-            elif form.formType == 'cancel':
-                self.options = {}
+            if form.formType in ('submit', 'cancel'):
+                self.options = form
             else:
-                raise BadRequest(text="Unexpected form type %r" % form.formType)
+                raise BadRequest(text=u"Unexpected form type '%s'" % form.formType)
         else:
             raise BadRequest(text="Missing configuration form")
 
+
+    def _parse_configureOrNone(self, verbElement):
+        """
+        Parse optional node configuration form in create request.
+        """
+        for element in verbElement.parent.elements():
+            if element.uri == NS_PUBSUB and element.name == 'configure':
+                form = data_form.findForm(element, NS_PUBSUB_NODE_CONFIG)
+                if form:
+                    if form.formType != 'submit':
+                        raise BadRequest(text=u"Unexpected form type '%s'" %
+                                              form.formType)
+                else:
+                    form = data_form.Form('submit',
+                                          formNamespace=NS_PUBSUB_NODE_CONFIG)
+                self.options = form
+
+
+    def _render_configureOrNone(self, verbElement):
+        """
+        Render optional node configuration form in create request.
+        """
+        if self.options is not None:
+            configure = verbElement.parent.addElement('configure')
+            configure.addChild(self.options.toElement())
 
 
@@ -431 +471 @@
     def _render_maxItems(self, verbElement):
         """
-        Parse maximum items into an items request.
+        Render maximum items into an items request.
         """
         if self.maxItems:
@@ -437 +477 @@
 
 
+    def _parse_subidOrNone(self, verbElement):
+        """
+        Parse subscription identifier out of a request.
+        """
+        self.subscriptionIdentifier = verbElement.getAttribute("subid")
+
+
+    def _render_subidOrNone(self, verbElement):
+        """
+        Render subscription identifier into a request.
+        """
+        if self.subscriptionIdentifier:
+            verbElement['subid'] = self.subscriptionIdentifier
+
+
     def _parse_options(self, verbElement):
-        form = PubSubRequest._findForm(verbElement, NS_PUBSUB_SUBSCRIBE_OPTIONS)
+        """
+        Parse options form out of a subscription options request.
+        """
+        form = data_form.findForm(verbElement, NS_PUBSUB_SUBSCRIBE_OPTIONS)
         if form:
-            if form.formType == 'submit':
-                self.options = form.getValues()
-            elif form.formType == 'cancel':
-                self.options = {}
+            if form.formType in ('submit', 'cancel'):
+                self.options = form
             else:
-                raise BadRequest(text="Unexpected form type %r" % form.formType)
+                raise BadRequest(text=u"Unexpected form type '%s'" % form.formType)
         else:
             raise BadRequest(text="Missing options form")
 
+
+
+    def _render_options(self, verbElement):
+        verbElement.addChild(self.options.toElement())
+
+
+    def _parse_optionsWithSubscribe(self, verbElement):
+        for element in verbElement.parent.elements():
+            if element.name == 'options' and element.uri == NS_PUBSUB:
+                form = data_form.findForm(element,
+                                          NS_PUBSUB_SUBSCRIBE_OPTIONS)
+                if form:
+                    if form.formType != 'submit':
+                        raise BadRequest(text=u"Unexpected form type '%s'" %
+                                              form.formType)
+                else:
+                    form = data_form.Form('submit',
+                                          formNamespace=NS_PUBSUB_SUBSCRIBE_OPTIONS)
+                self.options = form
+
+
+    def _render_optionsWithSubscribe(self, verbElement):
+        if self.options:
+            optionsElement = verbElement.parent.addElement('options')
+            self._render_options(optionsElement)
+
+
+    def _parse_affiliations(self, verbElement):
+        self.affiliations = {}
+        for element in verbElement.elements():
+            if (element.uri == NS_PUBSUB_OWNER and
+                element.name == 'affiliation'):
+                try:
+                    entity = jid.internJID(element['jid']).userhostJID()
+                except KeyError:
+                    raise BadRequest(text='Missing jid attribute')
+
+                if entity in self.affiliations:
+                    raise BadRequest(text='Multiple affiliations for an entity')
+
+                try:
+                    affiliation = element['affiliation']
+                except KeyError:
+                    raise BadRequest(text='Missing affiliation attribute')
+
+                self.affiliations[entity] = affiliation
+
+
     def parseElement(self, element):
         """
@@ -455 +559 @@
         generic.Stanza.parseElement(self, element)
 
+        verbs = []
+        verbElements = []
         for child in element.pubsub.elements():
             key = (self.stanzaType, child.uri, child.name)
@@ -461 +567 @@
             except KeyError:
                 continue
+
+            verbs.append(verb)
+            verbElements.append(child)
+
+        if not verbs:
+            raise NotImplementedError()
+
+        if len(verbs) > 1:
+            if 'optionsSet' in verbs and 'subscribe' in verbs:
+                self.verb = 'subscribe'
+                verbElement = verbElements[verbs.index('subscribe')]
             else:
-                self.verb = verb
-                break
-
-        if not self.verb:
-            raise NotImplementedError()
-
-        for parameter in self._parameters[verb]:
-            getattr(self, '_parse_%s' % parameter)(child)
+                raise NotImplementedError()
+        else:
+            self.verb = verbs[0]
+            verbElement = verbElements[0]
+
+        for parameter in self._parameters[self.verb]:
+            getattr(self, '_parse_%s' % parameter)(verbElement)
+
 
 
@@ -574 +691 @@
 
     def _onEvent(self, message):
+        if message.getAttribute('type') == 'error':
+            return
+
         try:
             sender = jid.JID(message["from"])
@@ -632 +752 @@
 
 
-    def createNode(self, service, nodeIdentifier=None, sender=None):
+    def createNode(self, service, nodeIdentifier=None, options=None,
+                         sender=None):
         """
         Create a publish subscribe node.
@@ -640 +761 @@
         @param nodeIdentifier: Optional suggestion for the id of the node.
         @type nodeIdentifier: C{unicode}
+        @param options: Optional node configuration options.
+        @type options: C{dict}
         """
         request = PubSubRequest('create')
@@ -645 +768 @@
         request.nodeIdentifier = nodeIdentifier
         request.sender = sender
+
+        if options:
+            form = data_form.Form(formType='submit',
+                                  formNamespace=NS_PUBSUB_NODE_CONFIG)
+            form.makeFields(options)
+            request.options = form
 
         def cb(iq):
@@ -675 +804 @@
 
 
-    def subscribe(self, service, nodeIdentifier, subscriber, sender=None):
+    def subscribe(self, service, nodeIdentifier, subscriber,
+                        options=None, sender=None):
         """
         Subscribe to a publish subscribe node.
@@ -681 +811 @@
         @param service: The publish subscribe service that keeps the node.
         @type service: L{JID}
+
         @param nodeIdentifier: The identifier of the node.
         @type nodeIdentifier: C{unicode}
+
         @param subscriber: The entity to subscribe to the node. This entity
-                           will get notifications of new published items.
+            will get notifications of new published items.
         @type subscriber: L{JID}
+
+        @param options: Subscription options.
+        @type options: C{dict}
+
+        @return: Deferred that fires with L{Subscription} or errbacks with
+            L{SubscriptionPending} or L{SubscriptionUnconfigured}.
+        @rtype: L{defer.Deferred}
         """
         request = PubSubRequest('subscribe')
@@ -693 +832 @@
         request.sender = sender
 
+        if options:
+            form = data_form.Form(formType='submit',
+                                  formNamespace=NS_PUBSUB_SUBSCRIBE_OPTIONS)
+            form.makeFields(options)
+            request.options = form
+
         def cb(iq):
-            subscription = iq.pubsub.subscription["subscription"]
-
-            if subscription == 'pending':
-                raise SubscriptionPending
-            elif subscription == 'unconfigured':
-                raise SubscriptionUnconfigured
+            subscription = Subscription.fromElement(iq.pubsub.subscription)
+
+            if subscription.state == 'pending':
+                raise SubscriptionPending()
+            elif subscription.state == 'unconfigured':
+                raise SubscriptionUnconfigured()
             else:
                 # we assume subscription == 'subscribed'
                 # any other value would be invalid, but that should have
                 # yielded a stanza error.
-                return None
+                return subscription
 
         d = request.send(self.xmlstream)
@@ -711 +856 @@
 
 
-    def unsubscribe(self, service, nodeIdentifier, subscriber, sender=None):
+    def unsubscribe(self, service, nodeIdentifier, subscriber,
+                          subscriptionIdentifier=None, sender=None):
         """
         Unsubscribe from a publish subscribe node.
@@ -717 +863 @@
         @param service: The publish subscribe service that keeps the node.
         @type service: L{JID}
+
         @param nodeIdentifier: The identifier of the node.
         @type nodeIdentifier: C{unicode}
+
         @param subscriber: The entity to unsubscribe from the node.
         @type subscriber: L{JID}
+
+        @param subscriptionIdentifier: Optional subscription identifier.
+        @type subscriptionIdentifier: C{unicode}
         """
         request = PubSubRequest('unsubscribe')
@@ -726 +877 @@
         request.nodeIdentifier = nodeIdentifier
         request.subscriber = subscriber
+        request.subscriptionIdentifier = subscriptionIdentifier
         request.sender = sender
         return request.send(self.xmlstream)
@@ -749 +901 @@
 
 
-    def items(self, service, nodeIdentifier, maxItems=None, sender=None):
+    def items(self, service, nodeIdentifier, maxItems=None,
+              subscriptionIdentifier=None, sender=None):
         """
         Retrieve previously published items from a publish subscribe node.
@@ -755 +908 @@
         @param service: The publish subscribe service that keeps the node.
         @type service: L{JID}
+
         @param nodeIdentifier: The identifier of the node.
         @type nodeIdentifier: C{unicode}
+
         @param maxItems: Optional limit on the number of retrieved items.
         @type maxItems: C{int}
+
+        @param subscriptionIdentifier: Optional subscription identifier. In
+            case the node has been subscribed to multiple times, this narrows
+            the results to the specific subscription.
+        @type subscriptionIdentifier: C{unicode}
         """
         request = PubSubRequest('items')
@@ -765 +925 @@
         if maxItems:
             request.maxItems = str(int(maxItems))
+        request.subscriptionIdentifier = subscriptionIdentifier
         request.sender = sender
 
@@ -779 +940 @@
 
 
+    def getOptions(self, service, nodeIdentifier, subscriber,
+                         subscriptionIdentifier=None, sender=None):
+        """
+        Get subscription options.
+
+        @param service: The publish subscribe service that keeps the node.
+        @type service: L{JID}
+
+        @param nodeIdentifier: The identifier of the node.
+        @type nodeIdentifier: C{unicode}
+
+        @param subscriber: The entity subscribed to the node.
+        @type subscriber: L{JID}
+
+        @param subscriptionIdentifier: Optional subscription identifier.
+        @type subscriptionIdentifier: C{unicode}
+
+        @rtype: L{data_form.Form}
+        """
+        request = PubSubRequest('optionsGet')
+        request.recipient = service
+        request.nodeIdentifier = nodeIdentifier
+        request.subscriber = subscriber
+        request.subscriptionIdentifier = subscriptionIdentifier
+        request.sender = sender
+
+        def cb(iq):
+            form = data_form.findForm(iq.pubsub.options,
+                                      NS_PUBSUB_SUBSCRIBE_OPTIONS)
+            form.typeCheck()
+            return form
+
+        d = request.send(self.xmlstream)
+        d.addCallback(cb)
+        return d
+
+
+    def setOptions(self, service, nodeIdentifier, subscriber,
+                         options, subscriptionIdentifier=None, sender=None):
+        """
+        Set subscription options.
+
+        @param service: The publish subscribe service that keeps the node.
+        @type service: L{JID}
+
+        @param nodeIdentifier: The identifier of the node.
+        @type nodeIdentifier: C{unicode}
+
+        @param subscriber: The entity subscribed to the node.
+        @type subscriber: L{JID}
+
+        @param options: Subscription options.
+        @type options: C{dict}.
+
+        @param subscriptionIdentifier: Optional subscription identifier.
+        @type subscriptionIdentifier: C{unicode}
+        """
+        request = PubSubRequest('optionsSet')
+        request.recipient = service
+        request.nodeIdentifier = nodeIdentifier
+        request.subscriber = subscriber
+        request.subscriptionIdentifier = subscriptionIdentifier
+        request.sender = sender
+
+        form = data_form.Form(formType='submit',
+                              formNamespace=NS_PUBSUB_SUBSCRIBE_OPTIONS)
+        form.makeFields(options)
+        request.options = form
+
+        d = request.send(self.xmlstream)
+        return d
+
+
 
 class PubSubService(XMPPHandler, IQHandlerMixin):
@@ -808 +1042 @@
     """
 
-    implements(IPubSubService)
+    implements(IPubSubService, disco.IDisco)
 
     iqHandlers = {
@@ -844 +1078 @@
         self.resource = resource
         self.discoIdentity = {'category': 'pubsub',
-                              'type': 'generic',
+                              'type': 'service',
                               'name': 'Generic Publish-Subscribe Service'}
 
@@ -854 +1088 @@
 
 
-    def getDiscoInfo(self, requestor, target, nodeIdentifier):
-        def toInfo(nodeInfo, info):
+    def getDiscoInfo(self, requestor, target, nodeIdentifier=''):
+        def toInfo(nodeInfo):
             if not nodeInfo:
-                return info
+                return
 
             (nodeType, metaData) = nodeInfo['type'], nodeInfo['meta-data']
@@ -877 +1111 @@
                 info.append(form)
 
-            return info
+            return
 
         info = []
@@ -889 +1123 @@
             getInfo = resource.getInfo
         else:
-            category, idType, name = self.discoIdentity
+            category = self.discoIdentity['category']
+            idType = self.discoIdentity['type']
+            name = self.discoIdentity['name']
             identity = disco.DiscoIdentity(category, idType, name)
             features = self.pubSubFeatures
@@ -900 +1136 @@
                          for feature in features])
 
-        d = getInfo(requestor, target, nodeIdentifier or '')
-        d.addCallback(toInfo, info)
+        d = defer.maybeDeferred(getInfo, requestor, target, nodeIdentifier or '')
+        d.addCallback(toInfo)
         d.addErrback(log.err)
+        d.addCallback(lambda _: info)
         return d
 
 
-    def getDiscoItems(self, requestor, target, nodeIdentifier):
+    def getDiscoItems(self, requestor, target, nodeIdentifier=''):
         if self.hideNodes:
             d = defer.succeed([])
@@ -917 +1154 @@
         else:
             d = defer.succeed([])
-            
-
 
         d.addCallback(lambda nodes: [disco.DiscoItem(target, node)
@@ -948 +1183 @@
                 handler = getattr(resource, request.verb)
             except AttributeError:
-                # fix lookup feature
                 text = "Request verb: %s" % request.verb
                 return defer.fail(Unsupported('', text))
@@ -954 +1188 @@
             d = handler(request)
         else:
-            handlerName, argNames = self._legacyHandlers[request.verb]
+            try:
+                handlerName, argNames = self._legacyHandlers[request.verb]
+            except KeyError:
+                text = "Request verb: %s" % request.verb
+                return defer.fail(Unsupported('', text))
+
             handler = getattr(self, handlerName)
+
             args = [getattr(request, arg) for arg in argNames]
+            if 'options' in argNames:
+                args[argNames.index('options')] = request.options.getValues()
+
             d = handler(*args)
 
@@ -972 +1215 @@
     def _toResponse_subscribe(self, result, resource, request):
         response = domish.Element((NS_PUBSUB, "pubsub"))
-        subscription = response.addElement("subscription")
-        if result.nodeIdentifier:
-            subscription["node"] = result.nodeIdentifier
-        subscription["jid"] = result.subscriber.full()
-        subscription["subscription"] = result.state
+        response.addChild(result.toElement(NS_PUBSUB))
         return response
 
@@ -984 +1223 @@
         subscriptions = response.addElement('subscriptions')
         for subscription in result:
-            item = subscriptions.addElement('subscription')
-            item['node'] = subscription.nodeIdentifier
-            item['jid'] = subscription.subscriber.full()
-            item['subscription'] = subscription.state
+            subscriptions.addChild(subscription.toElement(NS_PUBSUB))
         return response
 
@@ -1013 +1249 @@
 
 
-    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
 
 
-    def _checkConfiguration(self, resource, values):
-        options = resource.getConfigurationOptions()
-        processedValues = {}
-
-        for key, value in values.iteritems():
-            if key not in options:
-                continue
-
-            option = {'var': key}
-            option.update(options[key])
-            field = data_form.Field.fromDict(option)
-            if isinstance(value, list):
-                field.values = value
-            else:
-                field.value = value
-            field.typeCheck()
-
-            if isinstance(value, list):
-                processedValues[key] = field.values
-            else:
-                processedValues[key] = field.value
-
-        return processedValues
+    def _checkConfiguration(self, resource, form):
+        fieldDefs = resource.getConfigurationOptions()
+        form.typeCheck(fieldDefs, filterUnknown=True)
+
+
+    def _preProcess_create(self, resource, request):
+        if request.options:
+            self._checkConfiguration(resource, request.options)
+        return request
 
 
@@ -1092 +1296 @@
 
     def _preProcess_configureSet(self, resource, request):
-        if request.options:
-            request.options = self._checkConfiguration(resource,
-                                                       request.options)
+        if request.options.formType == 'cancel':
+            return None
+        else:
+            self._checkConfiguration(resource, request.options)
             return request
-        else:
-            return None
 
 
@@ -1106 +1309 @@
 
         for item in result:
+            item.uri = NS_PUBSUB
             items.addChild(item)
 
@@ -1132 +1336 @@
 
         return message
+
+
+    def _toResponse_affiliationsGet(self, result, resource, request):
+        response = domish.Element((NS_PUBSUB_OWNER, 'pubsub'))
+        affiliations = response.addElement('affiliations')
+
+        if request.nodeIdentifier:
+            affiliations['node'] = request.nodeIdentifier
+
+        for entity, affiliation in result.iteritems():
+            item = affiliations.addElement('affiliation')
+            item['jid'] = entity.full()
+            item['affiliation'] = affiliation
+
+        return response
+
 
     # public methods
@@ -1140 +1360 @@
                                                nodeIdentifier, subscriber,
                                                subscriptions)
-            message.event.items.children = items
+            for item in items:
+                item.uri = NS_PUBSUB_EVENT
+                message.event.items.addChild(item)
             self.send(message)
 

wokkel/server.py

@@ -1 +1 @@
 # -*- test-case-name: wokkel.test.test_server -*-
 #
-# Copyright (c) 2003-2008 Ralph Meijer
+# Copyright (c) Ralph Meijer.
 # See LICENSE for details.
 

wokkel/shim.py

@@ -1 +1 @@
 # -*- test-case-name: wokkel.test.test_shim -*-
 #
-# Copyright (c) 2003-2008 Ralph Meijer
+# Copyright (c) Ralph Meijer.
 # See LICENSE for details.
 

wokkel/subprotocols.py

@@ -1 +1 @@
 # -*- test-case-name: wokkel.test.test_subprotocols -*-
 #
-# Copyright (c) 2001-2009 Twisted Matrix Laboratories.
+# Copyright (c) Twisted Matrix Laboratories.
 # See LICENSE for details.
 
@@ -11 +11 @@
 
 from twisted.internet import defer
-from twisted.python import log
+from twisted.internet.error import ConnectionDone
+from twisted.python import failure, log
 from twisted.words.protocols.jabber import error, xmlstream
 from twisted.words.protocols.jabber.xmlstream import toResponse
@@ -92 +93 @@
         """
         self.parent.send(obj)
+
+
+    def request(self, request):
+        """
+        Send an IQ request and track the response.
+
+        This passes the request to the parent for sending and response
+        tracking.
+
+        @see: L{StreamManager.request}.
+        """
+        return self.parent.request(request)
 
 
@@ -156 +169 @@
     @ivar _packetQueue: internal buffer of unsent data. See L{send} for details.
     @type _packetQueue: L{list}
-    """
+    @ivar timeout: Default IQ request timeout in seconds.
+    @type timeout: C{int}
+    @ivar _reactor: A provider of L{IReactorTime} to track timeouts.
+    """
+    timeout = None
+    _reactor = None
 
     logTraffic = False
 
-    def __init__(self, factory):
+    def __init__(self, factory, reactor=None):
+        """
+        Construct a stream manager.
+
+        @param factory: The stream factory to connect with.
+        @param reactor: A provider of L{IReactorTime} to track timeouts.
+            If not provided, the global reactor will be used.
+        """
         XMPPHandlerCollection.__init__(self)
         self.xmlstream = None
@@ -173 +198 @@
         self.factory = factory
 
+        if reactor is None:
+            from twisted.internet import reactor
+        self._reactor = reactor
+
+        # Set up IQ response tracking
+        self._iqDeferreds = {}
+
 
     def addHandler(self, handler):
@@ -185 +217 @@
         # get protocol handler up to speed when a connection has already
         # been established
-        if self.xmlstream and self._initialized:
+        if self.xmlstream:
             handler.makeConnection(self.xmlstream)
+        if self._initialized:
             handler.connectionInitialized()
 
@@ -210 +243 @@
         self.xmlstream = xs
 
-        for e in self:
+        for e in list(self):
             e.makeConnection(xs)
 
@@ -221 +254 @@
         C{connectionInitialized} method.
         """
+
+        xs.addObserver('/iq[@type="result"]', self._onIQResponse)
+        xs.addObserver('/iq[@type="error"]', self._onIQResponse)
+
         # Flush all pending packets
         for p in self._packetQueue:
@@ -229 +266 @@
         # Notify all child services which implement
         # the IService interface
-        for e in self:
+        for e in list(self):
             e.connectionInitialized()
 
@@ -247 +284 @@
 
 
-    def _disconnected(self, _):
+    def _disconnected(self, reason):
         """
         Called when the stream has been closed.
@@ -258 +295 @@
         self._initialized = False
 
+        # Twisted versions before 11.0 passed an XmlStream here.
+        if not hasattr(reason, 'trap'):
+            reason = failure.Failure(ConnectionDone())
+
         # Notify all child services which implement
         # the IService interface
-        for e in self:
-            e.connectionLost(None)
+        for e in list(self):
+            e.connectionLost(reason)
+
+        # This errbacks all deferreds of iq's for which no response has
+        # been received with a L{ConnectionLost} failure. Otherwise, the
+        # deferreds will never be fired.
+        iqDeferreds = self._iqDeferreds
+        self._iqDeferreds = {}
+        for d in iqDeferreds.itervalues():
+            d.errback(reason)
+
+
+    def _onIQResponse(self, iq):
+        """
+        Handle iq response by firing associated deferred.
+        """
+        try:
+            d = self._iqDeferreds[iq["id"]]
+        except KeyError:
+            return
+
+        del self._iqDeferreds[iq["id"]]
+        iq.handled = True
+        if iq['type'] == 'error':
+            d.errback(error.exceptionFromStanza(iq))
+        else:
+            d.callback(iq)
 
 
@@ -278 +344 @@
         else:
             self._packetQueue.append(obj)
+
+
+    def request(self, request):
+        """
+        Send an IQ request and track the response.
+
+        A request is an IQ L{generic.Stanza} of type C{'get'} or C{'set'}. It
+        will have its C{toElement} called to render to a L{domish.Element}
+        which is then sent out over the current stream. If there is no such
+        stream (yet), it is queued and sent whenever a connection is
+        established and initialized, just like L{send}.
+
+        If the request doesn't have an identifier, it will be assigned a fresh
+        one, so the response can be tracked.
+
+        The deferred that is returned will fire with the L{domish.Element}
+        representation of the response if it is a result iq. If the response
+        is an error iq, a corresponding L{error.StanzaError} will be errbacked.
+
+        If the connection is closed before a response was received, the deferred
+        will be errbacked with the reason failure.
+
+        A request may also have a timeout, either by setting a default timeout
+        in L{StreamManager.timeout} or on the C{timeout} attribute of the
+        request.
+
+        @param request: The IQ request.
+        @type request: L{generic.Request}
+        """
+        if (request.stanzaKind != 'iq' or
+            request.stanzaType not in ('get', 'set')):
+            return defer.fail(ValueError("Not a request"))
+
+        element = request.toElement()
+
+        # Make sure we have a trackable id on the stanza
+        if not request.stanzaID:
+            element.addUniqueId()
+            request.stanzaID = element['id']
+
+        # Set up iq response tracking
+        d = defer.Deferred()
+        self._iqDeferreds[element['id']] = d
+
+        timeout = getattr(request, 'timeout', self.timeout)
+
+        if timeout is not None:
+            def onTimeout():
+                del self._iqDeferreds[element['id']]
+                d.errback(xmlstream.TimeoutError("IQ timed out"))
+
+            call = self._reactor.callLater(timeout, onTimeout)
+
+            def cancelTimeout(result):
+                if call.active():
+                    call.cancel()
+
+                return result
+
+            d.addBoth(cancelTimeout)
+        self.send(element)
+        return d
 
 

wokkel/test/__init__.py

@@ -1 @@
-# Copyright (c) 2003-2007 Ralph Meijer
+# Copyright (c) Ralph Meijer.
 # See LICENSE for details.
 

wokkel/test/helpers.py

@@ -1 @@
-# Copyright (c) 2003-2008 Ralph Meijer
+# Copyright (c) Ralph Meijer.
 # See LICENSE for details.
 

wokkel/test/test_client.py

@@ -1 @@
-# Copyright (c) 2003-2009 Ralph Meijer
+# Copyright (c) Ralph Meijer.
 # See LICENSE for details.
 

wokkel/test/test_compat.py

@@ -1 +1 @@
 # Copyright (c) 2001-2008 Twisted Matrix Laboratories.
-# Copyright (c) 2008-2009 Ralph Meijer
+# Copyright (c) Ralph Meijer.
 # See LICENSE for details.
 

wokkel/test/test_component.py

@@ -1 @@
-# Copyright (c) 2003-2008 Ralph Meijer
+# Copyright (c) Ralph Meijer.
 # See LICENSE for details.
 
@@ -369 +369 @@
         xs = self.xmlstream
         xs.addOnetimeObserver(xmlstream.STREAM_AUTHD_EVENT, authenticated)
-        xs.sid = '1234'
+        xs.sid = u'1234'
         theHash = '32532c0f7dbf1253c095b18b18e36d38d94c1256'
         xs.authenticator.onHandshake(theHash)
@@ -390 +390 @@
         xs.sendStreamError = streamErrors.append
 
-        xs.sid = '1234'
+        xs.sid = u'1234'
         theHash = '1234'
         xs.authenticator.onHandshake(theHash)

wokkel/test/test_data_form.py

@@ -1 @@
-# Copyright (c) 2003-2009 Ralph Meijer
+# Copyright (c) Ralph Meijer.
 # See LICENSE for details.
 
@@ -20 +20 @@
 
     def test_toElement(self):
+        """
+        An option is an option element with a value child with the option value.
+        """
+        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):
+        """
+        A label is rendered as an attribute on the option element.
+        """
         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))
 
 
@@ -43 +102 @@
         self.assertEqual('text-single', field.fieldType)
         self.assertEqual('test', field.var)
+
+
+    def test_labelAndOptions(self):
+        """
+        The label should be set, even if there are options with labels as dict.
+        """
+        field = data_form.Field(label='test',
+                                options={'test2': 'test 2', 'test3': 'test 3'})
+        self.assertEqual('test', field.label)
+
+
+    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))
 
 
@@ -61 +144 @@
 
 
-    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')
@@ -69 +152 @@
 
         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))
 
 
@@ -131 +237 @@
 
     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_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))
 
 
@@ -251 +410 @@
         self.assertEquals(u'user@example.org', field.value)
 
+
     def test_fromElementValueJIDMalformed(self):
         """
@@ -276 +436 @@
 
 
+    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 +528 @@
         form = data_form.Form('result')
         self.assertEqual('result', form.formType)
+
 
     def test_toElement(self):
@@ -304 +544 @@
 
 
+    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):
         """
@@ -348 +687 @@
 
         self.assertEquals(['instruction'], form.instructions)
+
 
     def test_fromElementInstructions2(self):
@@ -378 +718 @@
         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_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):
+        """
+        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)
+
+
+    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)
+
+
+
+class FindFormTest(unittest.TestCase):
+    """
+    Tests for L{data_form.findForm}.
+    """
+
+    def test_findForm(self):
+        element = domish.Element((None, 'test'))
+        theForm = data_form.Form('submit', formNamespace='myns')
+        element.addChild(theForm.toElement())
+        form = data_form.findForm(element, 'myns')
+        self.assertEqual('myns', form.formNamespace)
+
+
+    def test_noFormType(self):
+        element = domish.Element((None, 'test'))
+        otherForm = data_form.Form('submit')
+        element.addChild(otherForm.toElement())
+        form = data_form.findForm(element, 'myns')
+        self.assertIdentical(None, form)
+
+
+    def test_noFormTypeCancel(self):
+        """
+        Cancelled forms don't have a FORM_TYPE field, the first is returned.
+        """
+        element = domish.Element((None, 'test'))
+        cancelledForm = data_form.Form('cancel')
+        element.addChild(cancelledForm.toElement())
+        form = data_form.findForm(element, 'myns')
+        self.assertEqual('cancel', form.formType)
+
+
+    def test_otherFormType(self):
+        """
+        Forms with other FORM_TYPEs are ignored.
+        """
+        element = domish.Element((None, 'test'))
+        otherForm = data_form.Form('submit', formNamespace='otherns')
+        element.addChild(otherForm.toElement())
+        form = data_form.findForm(element, 'myns')
+        self.assertIdentical(None, form)
+
+
+    def test_otherFormTypeCancel(self):
+        """
+        Cancelled forms with another FORM_TYPE are ignored.
+        """
+        element = domish.Element((None, 'test'))
+        cancelledForm = data_form.Form('cancel', formNamespace='otherns')
+        element.addChild(cancelledForm.toElement())
+        form = data_form.findForm(element, 'myns')
+        self.assertIdentical(None, form)
+
+
+    def test_noElement(self):
+        """
+        When None is passed as element, None is returned.
+        """
+        element = None
+        form = data_form.findForm(element, 'myns')
+        self.assertIdentical(None, form)
+
+
+    def test_noForm(self):
+        """
+        When no child element is a form, None is returned.
+        """
+        element = domish.Element((None, 'test'))
+        form = data_form.findForm(element, 'myns')
+        self.assertIdentical(None, form)
+    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)

wokkel/test/test_disco.py

@@ -1 @@
-# Copyright (c) 2003-2009 Ralph Meijer
+# Copyright (c) Ralph Meijer.
 # See LICENSE for details.
 
@@ -10 +10 @@
 from twisted.internet import defer
 from twisted.trial import unittest
+from twisted.words.protocols.jabber.error import StanzaError
 from twisted.words.protocols.jabber.jid import JID
 from twisted.words.protocols.jabber.xmlstream import toResponse
-from twisted.words.xish import domish
+from twisted.words.xish import domish, utility
 
 from wokkel import data_form, disco
@@ -477 +478 @@
         """
         self.stub = XmlStreamStub()
+        self.patch(XMPPHandler, 'request', self.request)
         self.protocol = disco.DiscoClientProtocol()
-        self.protocol.xmlstream = self.stub.xmlstream
-        self.protocol.connectionInitialized()
+
+
+    def request(self, request):
+        element = request.toElement()
+        self.stub.xmlstream.send(element)
+        return defer.Deferred()
 
 
@@ -511 +517 @@
         element[u'jid'] = u"test2.example.org"
 
-        self.stub.send(response)
+        d.callback(response)
         return d
 
@@ -527 +533 @@
         response = toResponse(iq, u'result')
         response.addElement((NS_DISCO_ITEMS, u'query'))
-        self.stub.send(response)
-
+
+        d.callback(response)
         return d
 
@@ -566 +572 @@
         element[u'var'] = u'http://jabber.org/protocol/muc'
 
-        self.stub.send(response)
+        d.callback(response)
         return d
 
@@ -575 +581 @@
         """
         d = self.protocol.requestInfo(JID(u'example.org'),
-                                       sender=JID(u'test.example.org'))
+                                      sender=JID(u'test.example.org'))
 
         iq = self.stub.output[-1]
@@ -582 +588 @@
         response = toResponse(iq, u'result')
         response.addElement((NS_DISCO_INFO, u'query'))
-        self.stub.send(response)
-
+
+        d.callback(response)
         return d
 
@@ -595 +601 @@
     def setUp(self):
         self.service = disco.DiscoHandler()
+
+
+    def test_connectionInitializedObserveInfo(self):
+        """
+        An observer for Disco Info requests is setup on stream initialization.
+        """
+        xml = """<iq from='test@example.com' to='example.com'
+                     type='get'>
+                   <query xmlns='%s'/>
+                 </iq>""" % NS_DISCO_INFO
+
+        def handleRequest(iq):
+            called.append(iq)
+
+        called = []
+        self.service.xmlstream = utility.EventDispatcher()
+        self.service.handleRequest = handleRequest
+        self.service.connectionInitialized()
+        self.service.xmlstream.dispatch(parseXml(xml))
+        self.assertEqual(1, len(called))
+
+
+    def test_connectionInitializedObserveItems(self):
+        """
+        An observer for Disco Items requests is setup on stream initialization.
+        """
+        xml = """<iq from='test@example.com' to='example.com'
+                     type='get'>
+                   <query xmlns='%s'/>
+                 </iq>""" % NS_DISCO_ITEMS
+
+        def handleRequest(iq):
+            called.append(iq)
+
+        called = []
+        self.service.xmlstream = utility.EventDispatcher()
+        self.service.handleRequest = handleRequest
+        self.service.connectionInitialized()
+        self.service.xmlstream.dispatch(parseXml(xml))
+        self.assertEqual(1, len(called))
 
 
@@ -636 +682 @@
 
 
+    def test_onDiscoInfoWithNoFromAttribute(self):
+        """
+        Disco info request without a from attribute has requestor None.
+        """
+        xml = """<iq to='example.com'
+                     type='get'>
+                   <query xmlns='%s'/>
+                 </iq>""" % NS_DISCO_INFO
+
+        def info(requestor, target, nodeIdentifier):
+            self.assertEqual(None, requestor)
+
+            return defer.succeed([
+                disco.DiscoIdentity('dummy', 'generic', 'Generic Dummy Entity'),
+                disco.DiscoFeature('jabber:iq:version')
+            ])
+
+        self.service.info = info
+        d = self.handleRequest(xml)
+        return d
+
+
+    def test_onDiscoInfoWithNoToAttribute(self):
+        """
+        Disco info request without a to attribute has target None.
+        """
+        xml = """<iq from='test@example.com'
+                     type='get'>
+                   <query xmlns='%s'/>
+                 </iq>""" % NS_DISCO_INFO
+
+        def info(requestor, target, nodeIdentifier):
+            self.assertEqual(JID('test@example.com'), requestor)
+
+            return defer.succeed([
+                disco.DiscoIdentity('dummy', 'generic', 'Generic Dummy Entity'),
+                disco.DiscoFeature('jabber:iq:version')
+            ])
+
+        self.service.info = info
+        d = self.handleRequest(xml)
+        return d
+
+
     def test_onDiscoInfoWithNode(self):
         """
@@ -658 +748 @@
         self.service.info = info
         d = self.handleRequest(xml)
+        d.addCallback(cb)
+        return d
+
+
+    def test_onDiscoInfoWithNodeNoResults(self):
+        """
+        An info request for a node with no results returns items-not-found.
+        """
+        xml = """<iq from='test@example.com' to='example.com'
+                     type='get'>
+                   <query xmlns='%s' node='test'/>
+                 </iq>""" % NS_DISCO_INFO
+
+        def cb(exc):
+            self.assertEquals('item-not-found', exc.condition)
+
+        def info(requestor, target, nodeIdentifier):
+            self.assertEqual('test', nodeIdentifier)
+
+            return defer.succeed([])
+
+        self.service.info = info
+        d = self.handleRequest(xml)
+        self.assertFailure(d, StanzaError)
         d.addCallback(cb)
         return d

wokkel/test/test_generic.py

@@ -1 @@
-# Copyright (c) 2003-2008 Ralph Meijer
+# Copyright (c) Ralph Meijer.
 # See LICENSE for details.
 
@@ -8 +8 @@
 from twisted.trial import unittest
 from twisted.words.xish import domish
+from twisted.words.protocols.jabber.jid import JID
 
 from wokkel import generic
@@ -87 +88 @@
         self.pipe.sink.send(element)
         self.assertEquals([element], called)
+
+
+
+class RequestTest(unittest.TestCase):
+    """
+    Tests for L{generic.Request}.
+    """
+
+    def setUp(self):
+        self.request = generic.Request()
+
+
+    def test_toElementStanzaKind(self):
+        """
+        A request is an iq stanza.
+        """
+        element = self.request.toElement()
+        self.assertIdentical(None, element.uri)
+        self.assertEquals('iq', element.name)
+
+
+    def test_toElementStanzaType(self):
+        """
+        The request has type 'get'.
+        """
+        self.assertEquals('get', self.request.stanzaType)
+        element = self.request.toElement()
+        self.assertEquals('get', element.getAttribute('type'))
+
+
+    def test_toElementStanzaTypeSet(self):
+        """
+        The request has type 'set'.
+        """
+        self.request.stanzaType = 'set'
+        element = self.request.toElement()
+        self.assertEquals('set', element.getAttribute('type'))
+
+
+    def test_toElementStanzaID(self):
+        """
+        A request, when rendered, has an identifier.
+        """
+        element = self.request.toElement()
+        self.assertNotIdentical(None, self.request.stanzaID)
+        self.assertEquals(self.request.stanzaID, element.getAttribute('id'))
+
+
+    def test_toElementRecipient(self):
+        """
+        A request without recipient, has no 'to' attribute.
+        """
+        self.request = generic.Request(recipient=JID('other@example.org'))
+        self.assertEquals(JID('other@example.org'), self.request.recipient)
+        element = self.request.toElement()
+        self.assertEquals(u'other@example.org', element.getAttribute('to'))
+
+
+    def test_toElementRecipientNone(self):
+        """
+        A request without recipient, has no 'to' attribute.
+        """
+        element = self.request.toElement()
+        self.assertFalse(element.hasAttribute('to'))
+
+
+    def test_toElementSender(self):
+        """
+        A request with sender, has a 'from' attribute.
+        """
+        self.request = generic.Request(sender=JID('user@example.org'))
+        self.assertEquals(JID('user@example.org'), self.request.sender)
+        element = self.request.toElement()
+        self.assertEquals(u'user@example.org', element.getAttribute('from'))
+
+
+    def test_toElementSenderNone(self):
+        """
+        A request without sender, has no 'from' attribute.
+        """
+        element = self.request.toElement()
+        self.assertFalse(element.hasAttribute('from'))
+
+
+    def test_timeoutDefault(self):
+        """
+        The default is no timeout.
+        """
+        self.assertIdentical(None, self.request.timeout)

wokkel/test/test_ping.py

@@ -1 @@
-# Copyright (c) 2003-2009 Ralph Meijer
+# Copyright (c) Ralph Meijer.
 # See LICENSE for details.
 
@@ -134 +134 @@
 
 
+    def test_onPingHandled(self):
+        """
+        The ping handler should mark the stanza as handled.
+        """
+        xml = """<iq from='test@example.com' to='example.com' type='get'>
+                   <ping xmlns='urn:xmpp:ping'/>
+                 </iq>"""
+        iq = parseXml(xml)
+        self.stub.send(iq)
+
+        self.assertTrue(iq.handled)
+
+
     def test_interfaceIDisco(self):
         """

wokkel/test/test_pubsub.py

@@ -1 @@
-# Copyright (c) 2003-2009 Ralph Meijer
+# Copyright (c) Ralph Meijer.
 # See LICENSE for details.
 
@@ -20 +20 @@
 
 NS_PUBSUB = 'http://jabber.org/protocol/pubsub'
-NS_PUBSUB_CONFIG = 'http://jabber.org/protocol/pubsub#node_config'
+NS_PUBSUB_NODE_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'
 NS_PUBSUB_META_DATA = 'http://jabber.org/protocol/pubsub#meta-data'
+NS_PUBSUB_SUBSCRIBE_OPTIONS = 'http://jabber.org/protocol/pubsub#subscribe_options'
 
 def calledAsync(fn):
@@ -41 +42 @@
 
     return d, func
+
+
+class SubscriptionTest(unittest.TestCase):
+    """
+    Tests for L{pubsub.Subscription}.
+    """
+
+    def test_fromElement(self):
+        """
+        fromElement parses a subscription from XML DOM.
+        """
+        xml = """
+        <subscription node='test' jid='user@example.org/Home'
+                      subscription='pending'/>
+        """
+        subscription = pubsub.Subscription.fromElement(parseXml(xml))
+        self.assertEqual('test', subscription.nodeIdentifier)
+        self.assertEqual(JID('user@example.org/Home'), subscription.subscriber)
+        self.assertEqual('pending', subscription.state)
+        self.assertIdentical(None, subscription.subscriptionIdentifier)
+
+
+    def test_fromElementWithSubscriptionIdentifier(self):
+        """
+        A subscription identifier in the subscription should be parsed, too.
+        """
+        xml = """
+        <subscription node='test' jid='user@example.org/Home' subid='1234'
+                      subscription='pending'/>
+        """
+        subscription = pubsub.Subscription.fromElement(parseXml(xml))
+        self.assertEqual('1234', subscription.subscriptionIdentifier)
+
+
+    def test_toElement(self):
+        """
+        Rendering a Subscription should yield the proper attributes.
+        """
+        subscription = pubsub.Subscription('test',
+                                           JID('user@example.org/Home'),
+                                           'pending')
+        element = subscription.toElement()
+        self.assertEqual('subscription', element.name)
+        self.assertEqual(None, element.uri)
+        self.assertEqual('test', element.getAttribute('node'))
+        self.assertEqual('user@example.org/Home', element.getAttribute('jid'))
+        self.assertEqual('pending', element.getAttribute('subscription'))
+        self.assertFalse(element.hasAttribute('subid'))
+
+
+    def test_toElementEmptyNodeIdentifier(self):
+        """
+        The empty node identifier should not yield a node attribute.
+        """
+        subscription = pubsub.Subscription('',
+                                           JID('user@example.org/Home'),
+                                           'pending')
+        element = subscription.toElement()
+        self.assertFalse(element.hasAttribute('node'))
+
+
+    def test_toElementWithSubscriptionIdentifier(self):
+        """
+        The subscription identifier, if set, is in the subid attribute.
+        """
+        subscription = pubsub.Subscription('test',
+                                           JID('user@example.org/Home'),
+                                           'pending',
+                                           subscriptionIdentifier='1234')
+        element = subscription.toElement()
+        self.assertEqual('1234', element.getAttribute('subid'))
+
 
 
@@ -113 +186 @@
 
 
+    def test_eventItemsError(self):
+        """
+        An error message with embedded event should not be handled.
+
+        This test uses an items event, which should not result in itemsReceived
+        being called. In general message.handled should be False.
+        """
+        message = domish.Element((None, 'message'))
+        message['from'] = 'pubsub.example.org'
+        message['to'] = 'user@example.org/home'
+        message['type'] = 'error'
+        event = message.addElement((NS_PUBSUB_EVENT, 'event'))
+        items = event.addElement('items')
+        items['node'] = 'test'
+
+        class UnexpectedCall(Exception):
+            pass
+
+        def itemsReceived(event):
+            raise UnexpectedCall("Unexpected call to itemsReceived")
+
+        self.protocol.itemsReceived = itemsReceived
+        self.stub.send(message)
+        self.assertFalse(message.handled)
+
+
     def test_eventDelete(self):
         """
@@ -266 +365 @@
         iq = self.stub.output[-1]
         self.assertEquals('user@example.org', iq['from'])
+
+        response = toResponse(iq, 'result')
+        self.stub.send(response)
+        return d
+
+
+    def test_createNodeWithConfig(self):
+        """
+        Test sending create request with configuration options
+        """
+
+        options = {
+            'pubsub#title': 'Princely Musings (Atom)',
+            'pubsub#deliver_payloads': True,
+            'pubsub#persist_items': '1',
+            'pubsub#max_items': '10',
+            'pubsub#access_model': 'open',
+            'pubsub#type': 'http://www.w3.org/2005/Atom',
+        }
+
+        d = self.protocol.createNode(JID('pubsub.example.org'), 'test',
+                                     sender=JID('user@example.org'),
+                                     options=options)
+
+        iq = self.stub.output[-1]
+
+        # check if there is exactly one configure element
+        children = list(domish.generateElementsQNamed(iq.pubsub.children,
+                                                      'configure', NS_PUBSUB))
+        self.assertEqual(1, len(children))
+
+        # check that it has a configuration form
+        form = data_form.findForm(children[0], NS_PUBSUB_NODE_CONFIG)
+        self.assertEqual('submit', form.formType)
+
 
         response = toResponse(iq, 'result')
@@ -408 +542 @@
 
 
+    def test_subscribeReturnsSubscription(self):
+        """
+        A successful subscription should return a Subscription instance.
+        """
+        def cb(subscription):
+            self.assertEqual(JID('user@example.org'), subscription.subscriber)
+
+        d = self.protocol.subscribe(JID('pubsub.example.org'), 'test',
+                                      JID('user@example.org'))
+        d.addCallback(cb)
+
+        iq = self.stub.output[-1]
+
+        response = toResponse(iq, 'result')
+        pubsub = response.addElement((NS_PUBSUB, 'pubsub'))
+        subscription = pubsub.addElement('subscription')
+        subscription['node'] = 'test'
+        subscription['jid'] = 'user@example.org'
+        subscription['subscription'] = 'subscribed'
+        self.stub.send(response)
+        return d
+
+
     def test_subscribePending(self):
         """
@@ -448 +605 @@
 
 
-    def test_subscribeWithSender(self):
-        """
-        Test sending subscription request from a specific JID.
-        """
+    def test_subscribeWithOptions(self):
+        options = {'pubsub#deliver': False}
+
         d = self.protocol.subscribe(JID('pubsub.example.org'), 'test',
-                                      JID('user@example.org'),
-                                      sender=JID('user@example.org'))
-
+                                    JID('user@example.org'),
+                                    options=options)
         iq = self.stub.output[-1]
-        self.assertEquals('user@example.org', iq['from'])
-
+
+        # Check options present
+        childNames = []
+        for element in iq.pubsub.elements():
+            if element.uri == NS_PUBSUB:
+                childNames.append(element.name)
+
+        self.assertEqual(['subscribe', 'options'], childNames)
+        form = data_form.findForm(iq.pubsub.options,
+                                  NS_PUBSUB_SUBSCRIBE_OPTIONS)
+        self.assertEqual('submit', form.formType)
+        form.typeCheck({'pubsub#deliver': {'type': 'boolean'}})
+        self.assertEqual(options, form.getValues())
+
+        # Send response
         response = toResponse(iq, 'result')
         pubsub = response.addElement((NS_PUBSUB, 'pubsub'))
@@ -465 +633 @@
         subscription['jid'] = 'user@example.org'
         subscription['subscription'] = 'subscribed'
+        self.stub.send(response)
+
+        return d
+
+
+    def test_subscribeWithSender(self):
+        """
+        Test sending subscription request from a specific JID.
+        """
+        d = self.protocol.subscribe(JID('pubsub.example.org'), 'test',
+                                      JID('user@example.org'),
+                                      sender=JID('user@example.org'))
+
+        iq = self.stub.output[-1]
+        self.assertEquals('user@example.org', iq['from'])
+
+        response = toResponse(iq, 'result')
+        pubsub = response.addElement((NS_PUBSUB, 'pubsub'))
+        subscription = pubsub.addElement('subscription')
+        subscription['node'] = 'test'
+        subscription['jid'] = 'user@example.org'
+        subscription['subscription'] = 'subscribed'
+        self.stub.send(response)
+        return d
+
+
+    def test_subscribeReturningSubscriptionIdentifier(self):
+        """
+        Test sending subscription request with subscription identifier.
+        """
+        def cb(subscription):
+            self.assertEqual('1234', subscription.subscriptionIdentifier)
+
+        d = self.protocol.subscribe(JID('pubsub.example.org'), 'test',
+                                      JID('user@example.org'))
+        d.addCallback(cb)
+
+        iq = self.stub.output[-1]
+
+        response = toResponse(iq, 'result')
+        pubsub = response.addElement((NS_PUBSUB, 'pubsub'))
+        subscription = pubsub.addElement('subscription')
+        subscription['node'] = 'test'
+        subscription['jid'] = 'user@example.org'
+        subscription['subscription'] = 'subscribed'
+        subscription['subid'] = '1234'
         self.stub.send(response)
         return d
@@ -506 +720 @@
 
 
+    def test_unsubscribeWithSubscriptionIdentifier(self):
+        """
+        Test sending unsubscription request with subscription identifier.
+        """
+        d = self.protocol.unsubscribe(JID('pubsub.example.org'), 'test',
+                                      JID('user@example.org'),
+                                      subscriptionIdentifier='1234')
+
+        iq = self.stub.output[-1]
+        child = iq.pubsub.unsubscribe
+        self.assertEquals('1234', child['subid'])
+
+        self.stub.send(toResponse(iq, 'result'))
+        return d
+
+
     def test_items(self):
         """
@@ -572 +802 @@
 
 
-    def test_itemsWithSender(self):
-        """
-        Test sending items request from a specific JID.
+    def test_itemsWithSubscriptionIdentifier(self):
+        """
+        Test sending items request with a subscription identifier.
         """
 
         d = self.protocol.items(JID('pubsub.example.org'), 'test',
-                               sender=JID('user@example.org'))
+                               subscriptionIdentifier='1234')
 
         iq = self.stub.output[-1]
-        self.assertEquals('user@example.org', iq['from'])
+        child = iq.pubsub.items
+        self.assertEquals('1234', child['subid'])
 
         response = toResponse(iq, 'result')
@@ -591 +822 @@
 
 
+    def test_itemsWithSender(self):
+        """
+        Test sending items request from a specific JID.
+        """
+
+        d = self.protocol.items(JID('pubsub.example.org'), 'test',
+                               sender=JID('user@example.org'))
+
+        iq = self.stub.output[-1]
+        self.assertEquals('user@example.org', iq['from'])
+
+        response = toResponse(iq, 'result')
+        items = response.addElement((NS_PUBSUB, 'pubsub')).addElement('items')
+        items['node'] = 'test'
+
+        self.stub.send(response)
+        return d
+
+
+    def test_getOptions(self):
+        def cb(form):
+            self.assertEqual('form', form.formType)
+            self.assertEqual(NS_PUBSUB_SUBSCRIBE_OPTIONS, form.formNamespace)
+            field = form.fields['pubsub#deliver']
+            self.assertEqual('boolean', field.fieldType)
+            self.assertIdentical(True, field.value)
+            self.assertEqual('Enable delivery?', field.label)
+
+        d = self.protocol.getOptions(JID('pubsub.example.org'), 'test',
+                                     JID('user@example.org'),
+                                     sender=JID('user@example.org'))
+        d.addCallback(cb)
+
+        iq = self.stub.output[-1]
+        self.assertEqual('pubsub.example.org', iq.getAttribute('to'))
+        self.assertEqual('get', iq.getAttribute('type'))
+        self.assertEqual('pubsub', iq.pubsub.name)
+        self.assertEqual(NS_PUBSUB, iq.pubsub.uri)
+        children = list(domish.generateElementsQNamed(iq.pubsub.children,
+                                                      'options', NS_PUBSUB))
+        self.assertEqual(1, len(children))
+        child = children[0]
+        self.assertEqual('test', child['node'])
+
+        self.assertEqual(0, len(child.children))
+
+        # Send response
+        form = data_form.Form('form', formNamespace=NS_PUBSUB_SUBSCRIBE_OPTIONS)
+        form.addField(data_form.Field('boolean', var='pubsub#deliver',
+                                                 label='Enable delivery?',
+                                                 value=True))
+        response = toResponse(iq, 'result')
+        response.addElement((NS_PUBSUB, 'pubsub'))
+        response.pubsub.addElement('options')
+        response.pubsub.options.addChild(form.toElement())
+        self.stub.send(response)
+
+        return d
+
+
+    def test_getOptionsWithSubscriptionIdentifier(self):
+        """
+        Getting options with a subid should have the subid in the request.
+        """
+
+        d = self.protocol.getOptions(JID('pubsub.example.org'), 'test',
+                                     JID('user@example.org'),
+                                     sender=JID('user@example.org'),
+                                     subscriptionIdentifier='1234')
+
+        iq = self.stub.output[-1]
+        child = iq.pubsub.options
+        self.assertEqual('1234', child['subid'])
+
+        # Send response
+        form = data_form.Form('form', formNamespace=NS_PUBSUB_SUBSCRIBE_OPTIONS)
+        form.addField(data_form.Field('boolean', var='pubsub#deliver',
+                                                 label='Enable delivery?',
+                                                 value=True))
+        response = toResponse(iq, 'result')
+        response.addElement((NS_PUBSUB, 'pubsub'))
+        response.pubsub.addElement('options')
+        response.pubsub.options.addChild(form.toElement())
+        self.stub.send(response)
+
+        return d
+
+
+    def test_setOptions(self):
+        """
+        setOptions should send out a options-set request.
+        """
+        options = {'pubsub#deliver': False}
+
+        d = self.protocol.setOptions(JID('pubsub.example.org'), 'test',
+                                     JID('user@example.org'),
+                                     options,
+                                     sender=JID('user@example.org'))
+
+        iq = self.stub.output[-1]
+        self.assertEqual('pubsub.example.org', iq.getAttribute('to'))
+        self.assertEqual('set', iq.getAttribute('type'))
+        self.assertEqual('pubsub', iq.pubsub.name)
+        self.assertEqual(NS_PUBSUB, iq.pubsub.uri)
+        children = list(domish.generateElementsQNamed(iq.pubsub.children,
+                                                      'options', NS_PUBSUB))
+        self.assertEqual(1, len(children))
+        child = children[0]
+        self.assertEqual('test', child['node'])
+
+        form = data_form.findForm(child, NS_PUBSUB_SUBSCRIBE_OPTIONS)
+        self.assertEqual('submit', form.formType)
+        form.typeCheck({'pubsub#deliver': {'type': 'boolean'}})
+        self.assertEqual(options, form.getValues())
+
+        response = toResponse(iq, 'result')
+        self.stub.send(response)
+
+        return d
+
+
+    def test_setOptionsWithSubscriptionIdentifier(self):
+        """
+        setOptions should send out a options-set request with subid.
+        """
+        options = {'pubsub#deliver': False}
+
+        d = self.protocol.setOptions(JID('pubsub.example.org'), 'test',
+                                     JID('user@example.org'),
+                                     options,
+                                     subscriptionIdentifier='1234',
+                                     sender=JID('user@example.org'))
+
+        iq = self.stub.output[-1]
+        child = iq.pubsub.options
+        self.assertEqual('1234', child['subid'])
+
+        form = data_form.findForm(child, NS_PUBSUB_SUBSCRIBE_OPTIONS)
+        self.assertEqual('submit', form.formType)
+        form.typeCheck({'pubsub#deliver': {'type': 'boolean'}})
+        self.assertEqual(options, form.getValues())
+
+        response = toResponse(iq, 'result')
+        self.stub.send(response)
+
+        return d
+
 
 class PubSubRequestTest(unittest.TestCase):
+
+    def test_fromElementUnknown(self):
+        """
+        An unknown verb raises NotImplementedError.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <non-existing-verb/>
+          </pubsub>
+        </iq>
+        """
+
+        self.assertRaises(NotImplementedError,
+                          pubsub.PubSubRequest.fromElement, parseXml(xml))
+
+
+    def test_fromElementKnownBadCombination(self):
+        """
+        Multiple verbs in an unknown configuration raises NotImplementedError.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+             <publish/>
+             <create/>
+          </pubsub>
+        </iq>
+        """
+
+        self.assertRaises(NotImplementedError,
+                          pubsub.PubSubRequest.fromElement, parseXml(xml))
 
     def test_fromElementPublish(self):
@@ -639 +1053 @@
 
 
+    def test_fromElementPublishItemsOptions(self):
+        """
+        Test parsing a publish request with items and options.
+
+        Note that publishing options are not supported, but passing them
+        shouldn't affect processing of the publish request itself.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <publish node='test'>
+              <item id="item1"/>
+              <item id="item2"/>
+            </publish>
+            <publish-options/>
+          </pubsub>
+        </iq>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual(2, len(request.items))
+        self.assertEqual(u'item1', request.items[0]["id"])
+        self.assertEqual(u'item2', request.items[1]["id"])
+
     def test_fromElementPublishNoNode(self):
         """
@@ -719 +1159 @@
         self.assertEqual('jid-required', err.appCondition.name)
 
+
+    def test_fromElementSubscribeWithOptions(self):
+        """
+        Test parsing a subscription request.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <subscribe node='test' jid='user@example.org/Home'/>
+            <options>
+              <x xmlns="jabber:x:data" type='submit'>
+                <field var='FORM_TYPE' type='hidden'>
+                  <value>http://jabber.org/protocol/pubsub#subscribe_options</value>
+                </field>
+                <field var='pubsub#deliver' type='boolean'
+                       label='Enable delivery?'>
+                  <value>1</value>
+                </field>
+              </x>
+            </options>
+          </pubsub>
+        </iq>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual('subscribe', request.verb)
+        request.options.typeCheck({'pubsub#deliver': {'type': 'boolean'}})
+        self.assertEqual({'pubsub#deliver': True}, request.options.getValues())
+
+
+    def test_fromElementSubscribeWithOptionsBadFormType(self):
+        """
+        The options form should have the right type.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <subscribe node='test' jid='user@example.org/Home'/>
+            <options>
+              <x xmlns="jabber:x:data" type='result'>
+                <field var='FORM_TYPE' type='hidden'>
+                  <value>http://jabber.org/protocol/pubsub#subscribe_options</value>
+                </field>
+                <field var='pubsub#deliver' type='boolean'
+                       label='Enable delivery?'>
+                  <value>1</value>
+                </field>
+              </x>
+            </options>
+          </pubsub>
+        </iq>
+        """
+
+        err = self.assertRaises(error.StanzaError,
+                                pubsub.PubSubRequest.fromElement,
+                                parseXml(xml))
+        self.assertEqual('bad-request', err.condition)
+        self.assertEqual("Unexpected form type 'result'", err.text)
+        self.assertEqual(None, err.appCondition)
+
+
+    def test_fromElementSubscribeWithOptionsEmpty(self):
+        """
+        When no (suitable) form is found, the options are empty.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <subscribe node='test' jid='user@example.org/Home'/>
+            <options/>
+          </pubsub>
+        </iq>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual('subscribe', request.verb)
+        self.assertEqual({}, request.options.getValues())
+
+
     def test_fromElementUnsubscribe(self):
         """
@@ -741 +1266 @@
 
 
+    def test_fromElementUnsubscribeWithSubscriptionIdentifier(self):
+        """
+        Test parsing an unsubscription request with subscription identifier.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <unsubscribe node='test' jid='user@example.org/Home'
+                         subid='1234'/>
+          </pubsub>
+        </iq>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual('1234', request.subscriptionIdentifier)
+
+
     def test_fromElementUnsubscribeNoJID(self):
         """
@@ -777 +1321 @@
         request = pubsub.PubSubRequest.fromElement(parseXml(xml))
         self.assertEqual('optionsGet', request.verb)
+        self.assertEqual(JID('user@example.org'), request.sender)
+        self.assertEqual(JID('pubsub.example.org'), request.recipient)
+        self.assertEqual('test', request.nodeIdentifier)
+        self.assertEqual(JID('user@example.org/Home'), request.subscriber)
+
+
+    def test_fromElementOptionsGetWithSubscriptionIdentifier(self):
+        """
+        Test parsing a request for getting subscription options with subid.
+        """
+
+        xml = """
+        <iq type='get' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <options node='test' jid='user@example.org/Home'
+                     subid='1234'/>
+          </pubsub>
+        </iq>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual('1234', request.subscriptionIdentifier)
 
 
@@ -806 +1373 @@
         self.assertEqual('test', request.nodeIdentifier)
         self.assertEqual(JID('user@example.org/Home'), request.subscriber)
-        self.assertEqual({'pubsub#deliver': '1'}, request.options)
-
-
-    def test_fromElementOptionsSetCancel(self):
-        """
-        Test parsing a request for cancelling setting subscription options.
-        """
-
-        xml = """
-        <iq type='set' to='pubsub.example.org'
-                       from='user@example.org'>
-          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
-            <options node='test' jid='user@example.org/Home'>
-              <x xmlns='jabber:x:data' type='cancel'/>
-            </options>
-          </pubsub>
-        </iq>
-        """
-
-        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
-        self.assertEqual({}, request.options)
-
-
-    def test_fromElementOptionsSetBadFormType(self):
-        """
-        On a options set request unknown fields should be ignored.
-        """
-
-        xml = """
-        <iq type='set' to='pubsub.example.org'
-                       from='user@example.org'>
-          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
-            <options node='test' jid='user@example.org/Home'>
-              <x xmlns='jabber:x:data' type='result'>
+        self.assertEqual({'pubsub#deliver': '1'}, request.options.getValues())
+
+
+    def test_fromElementOptionsSetWithSubscriptionIdentifier(self):
+        """
+        Test parsing a request for setting subscription options with subid.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <options node='test' jid='user@example.org/Home'
+                     subid='1234'>
+              <x xmlns='jabber:x:data' type='submit'>
                 <field var='FORM_TYPE' type='hidden'>
-                  <value>http://jabber.org/protocol/pubsub#node_config</value>
+                  <value>http://jabber.org/protocol/pubsub#subscribe_options</value>
                 </field>
                 <field var='pubsub#deliver'><value>1</value></field>
@@ -850 +1398 @@
         """
 
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual('1234', request.subscriptionIdentifier)
+
+
+    def test_fromElementOptionsSetCancel(self):
+        """
+        Test parsing a request for cancelling setting subscription options.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <options node='test' jid='user@example.org/Home'>
+              <x xmlns='jabber:x:data' type='cancel'/>
+            </options>
+          </pubsub>
+        </iq>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual('cancel', request.options.formType)
+
+
+    def test_fromElementOptionsSetBadFormType(self):
+        """
+        On a options set request unknown fields should be ignored.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <options node='test' jid='user@example.org/Home'>
+              <x xmlns='jabber:x:data' type='result'>
+                <field var='FORM_TYPE' type='hidden'>
+                  <value>http://jabber.org/protocol/pubsub#subscribe_options</value>
+                </field>
+                <field var='pubsub#deliver'><value>1</value></field>
+              </x>
+            </options>
+          </pubsub>
+        </iq>
+        """
+
+        err = self.assertRaises(error.StanzaError,
+                                pubsub.PubSubRequest.fromElement,
+                                parseXml(xml))
+        self.assertEqual('bad-request', err.condition)
+        self.assertEqual("Unexpected form type 'result'", err.text)
+        self.assertEqual(None, err.appCondition)
+
+
+    def test_fromElementOptionsSetNoForm(self):
+        """
+        On a options set request a form is required.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <options node='test' jid='user@example.org/Home'/>
+          </pubsub>
+        </iq>
+        """
         err = self.assertRaises(error.StanzaError,
                                 pubsub.PubSubRequest.fromElement,
@@ -857 +1471 @@
 
 
-    def test_fromElementOptionsSetNoForm(self):
-        """
-        On a options set request a form is required.
-        """
-
-        xml = """
-        <iq type='set' to='pubsub.example.org'
-                       from='user@example.org'>
-          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
-            <options node='test' jid='user@example.org/Home'/>
-          </pubsub>
-        </iq>
-        """
-        err = self.assertRaises(error.StanzaError,
-                                pubsub.PubSubRequest.fromElement,
-                                parseXml(xml))
-        self.assertEqual('bad-request', err.condition)
-        self.assertEqual(None, err.appCondition)
-
-
     def test_fromElementSubscriptions(self):
         """
@@ -936 +1530 @@
         self.assertEqual(JID('pubsub.example.org'), request.recipient)
         self.assertEqual('mynode', request.nodeIdentifier)
+        self.assertIdentical(None, request.options)
 
 
@@ -956 +1551 @@
 
 
+    def test_fromElementCreateConfigureEmpty(self):
+        """
+        Test parsing a request to create a node with an empty configuration.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <create node='mynode'/>
+            <configure/>
+          </pubsub>
+        </iq>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual({}, request.options.getValues())
+        self.assertEqual(u'mynode', request.nodeIdentifier)
+
+
+    def test_fromElementCreateConfigureEmptyWrongOrder(self):
+        """
+        Test parsing a request to create a node and configure, wrong order.
+
+        The C{configure} element should come after the C{create} request,
+        but we should accept both orders.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <configure/>
+            <create node='mynode'/>
+          </pubsub>
+        </iq>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual({}, request.options.getValues())
+        self.assertEqual(u'mynode', request.nodeIdentifier)
+
+
+    def test_fromElementCreateConfigure(self):
+        """
+        Test parsing a request to create a node.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <create node='mynode'/>
+            <configure>
+              <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#access_model'><value>open</value></field>
+                <field var='pubsub#persist_items'><value>0</value></field>
+              </x>
+            </configure>
+          </pubsub>
+        </iq>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        values = request.options.getValues()
+        self.assertIn('pubsub#access_model', values)
+        self.assertEqual(u'open', values['pubsub#access_model'])
+        self.assertIn('pubsub#persist_items', values)
+        self.assertEqual(u'0', values['pubsub#persist_items'])
+
+
+    def test_fromElementCreateConfigureBadFormType(self):
+        """
+        The form of a node creation request should have the right type.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <create node='mynode'/>
+            <configure>
+              <x xmlns='jabber:x:data' type='result'>
+                <field var='FORM_TYPE' type='hidden'>
+                  <value>http://jabber.org/protocol/pubsub#node_config</value>
+                </field>
+                <field var='pubsub#access_model'><value>open</value></field>
+                <field var='pubsub#persist_items'><value>0</value></field>
+              </x>
+            </configure>
+          </pubsub>
+        </iq>
+        """
+
+        err = self.assertRaises(error.StanzaError,
+                                pubsub.PubSubRequest.fromElement,
+                                parseXml(xml))
+        self.assertEqual('bad-request', err.condition)
+        self.assertEqual("Unexpected form type 'result'", err.text)
+        self.assertEqual(None, err.appCondition)
+
+
     def test_fromElementDefault(self):
         """
-        Test parsing a request for the default node configuration.
+        Parsing default node configuration request sets required attributes.
+
+        Besides C{verb}, C{sender} and C{recipient}, we expect C{nodeType}
+        to be set. If not passed it receives the default C{u'leaf'}.
         """
 
@@ -971 +1674 @@
 
         request = pubsub.PubSubRequest.fromElement(parseXml(xml))
-        self.assertEqual('default', request.verb)
-        self.assertEqual(JID('user@example.org'), request.sender)
-        self.assertEqual(JID('pubsub.example.org'), request.recipient)
-        self.assertEqual('leaf', request.nodeType)
+        self.assertEquals(u'default', request.verb)
+        self.assertEquals(JID('user@example.org'), request.sender)
+        self.assertEquals(JID('pubsub.example.org'), request.recipient)
+        self.assertEquals(u'leaf', request.nodeType)
 
 
     def test_fromElementDefaultCollection(self):
         """
-        Parsing a request for the default configuration extracts the node type.
+        Parsing default request for collection sets nodeType to collection.
         """
 
@@ -1002 +1705 @@
 
         request = pubsub.PubSubRequest.fromElement(parseXml(xml))
-        self.assertEqual('collection', request.nodeType)
+        self.assertEquals('collection', request.nodeType)
 
 
@@ -1054 +1757 @@
         self.assertEqual('test', request.nodeIdentifier)
         self.assertEqual({'pubsub#deliver_payloads': '0',
-                          'pubsub#persist_items': '1'}, request.options)
+                          'pubsub#persist_items': '1'},
+                         request.options.getValues())
 
 
@@ -1074 +1778 @@
 
         request = pubsub.PubSubRequest.fromElement(parseXml(xml))
-        self.assertEqual({}, request.options)
+        self.assertEqual('cancel', request.options.formType)
 
 
     def test_fromElementConfigureSetBadFormType(self):
         """
-        On a node configuration set request unknown fields should be ignored.
+        The form of a node configuraton set request should have the right type.
         """
 
@@ -1103 +1807 @@
                                 parseXml(xml))
         self.assertEqual('bad-request', err.condition)
+        self.assertEqual("Unexpected form type 'result'", err.text)
         self.assertEqual(None, err.appCondition)
 
@@ -1145 +1850 @@
         self.assertEqual('test', request.nodeIdentifier)
         self.assertIdentical(None, request.maxItems)
+        self.assertIdentical(None, request.subscriptionIdentifier)
         self.assertEqual([], request.itemIdentifiers)
+
+
+    def test_fromElementItemsSubscriptionIdentifier(self):
+        """
+        Test parsing an items request with subscription identifier.
+        """
+        xml = """
+        <iq type='get' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <items node='test' subid='1234'/>
+          </pubsub>
+        </iq>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual('1234', request.subscriptionIdentifier)
 
 
@@ -1234 +1957 @@
 
 
+    def test_interfaceIDisco(self):
+        """
+        Do instances of L{pubsub.PubSubService} provide L{iwokkel.IDisco}?
+        """
+        verify.verifyObject(iwokkel.IDisco, self.service)
+
+
     def test_connectionMade(self):
         """
@@ -1336 +2066 @@
         d = self.service.getDiscoInfo(JID('user@example.org/home'),
                                       JID('pubsub.example.org'), '')
+        d.addCallback(cb)
+        return d
+
+
+    def test_getDiscoInfoBadResponse(self):
+        """
+        If getInfo returns invalid response, it should be logged, then ignored.
+        """
+        def cb(info):
+            self.assertEquals([], info)
+            self.assertEqual(1, len(self.flushLoggedErrors(TypeError)))
+
+        def getInfo(requestor, target, nodeIdentifier):
+            return defer.succeed('bad response')
+
+        self.resource.getInfo = getInfo
+        d = self.service.getDiscoInfo(JID('user@example.org/home'),
+                                      JID('pubsub.example.org'), 'test')
+        d.addCallback(cb)
+        return d
+
+
+    def test_getDiscoInfoException(self):
+        """
+        If getInfo returns invalid response, it should be logged, then ignored.
+        """
+        def cb(info):
+            self.assertEquals([], info)
+            self.assertEqual(1, len(self.flushLoggedErrors(NotImplementedError)))
+
+        def getInfo(requestor, target, nodeIdentifier):
+            return defer.fail(NotImplementedError())
+
+        self.resource.getInfo = getInfo
+        d = self.service.getDiscoInfo(JID('user@example.org/home'),
+                                      JID('pubsub.example.org'), 'test')
         d.addCallback(cb)
         return d
@@ -1489 +2255 @@
 
 
+    def test_on_subscribeSubscriptionIdentifier(self):
+        """
+        If a subscription returns a subid, this should be available.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <subscribe node='test' jid='user@example.org/Home'/>
+          </pubsub>
+        </iq>
+        """
+
+        def subscribe(request):
+            subscription = pubsub.Subscription(request.nodeIdentifier,
+                                               request.subscriber,
+                                               'subscribed',
+                                               subscriptionIdentifier='1234')
+            return defer.succeed(subscription)
+
+        def cb(element):
+            self.assertEqual('1234', element.subscription.getAttribute('subid'))
+
+        self.resource.subscribe = subscribe
+        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
+        d = self.handleRequest(xml)
+        d.addCallback(cb)
+        return d
+
+
     def test_on_unsubscribe(self):
         """
@@ -1504 +2301 @@
 
         def unsubscribe(request):
+            return defer.succeed(None)
+
+        def cb(element):
+            self.assertIdentical(None, element)
+
+        self.resource.unsubscribe = unsubscribe
+        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
+        d = self.handleRequest(xml)
+        d.addCallback(cb)
+        return d
+
+
+    def test_on_unsubscribeSubscriptionIdentifier(self):
+        """
+        A successful unsubscription with subid should return an empty response.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <unsubscribe node='test' jid='user@example.org/Home' subid='1234'/>
+          </pubsub>
+        </iq>
+        """
+
+        def unsubscribe(request):
+            self.assertEqual('1234', request.subscriptionIdentifier)
             return defer.succeed(None)
 
@@ -1602 +2427 @@
             subscription = children[0]
             self.assertEqual('subscription', subscription.name)
-            self.assertEqual(NS_PUBSUB, subscription.uri)
+            self.assertEqual(NS_PUBSUB, subscription.uri, NS_PUBSUB)
             self.assertEqual('user@example.org', subscription['jid'])
             self.assertEqual('test', subscription['node'])
             self.assertEqual('subscribed', subscription['subscription'])
+
+        self.resource.subscriptions = subscriptions
+        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
+        d = self.handleRequest(xml)
+        d.addCallback(cb)
+        return d
+
+
+    def test_on_subscriptionsWithSubscriptionIdentifier(self):
+        """
+        A subscriptions request response should include subids, if set.
+        """
+
+        xml = """
+        <iq type='get' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <subscriptions/>
+          </pubsub>
+        </iq>
+        """
+
+        def subscriptions(request):
+            subscription = pubsub.Subscription('test', JID('user@example.org'),
+                                               'subscribed',
+                                               subscriptionIdentifier='1234')
+            return defer.succeed([subscription])
+
+        def cb(element):
+            subscription = element.subscriptions.subscription
+            self.assertEqual('1234', subscription['subid'])
 
         self.resource.subscriptions = subscriptions
@@ -1741 +2597 @@
 
 
-    def test_on_default(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/>
+    def test_on_createWithConfig(self):
+        """
+        On a node create with configuration request the Data Form is parsed and
+        L{PubSubResource.create} 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'>
+            <create node='mynode'/>
+            <configure>
+              <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>
@@ -1766 +2631 @@
                 }
 
+        def create(request):
+            self.assertEqual({'pubsub#deliver_payloads': False,
+                              'pubsub#persist_items': True},
+                             request.options.getValues())
+            return defer.succeed(None)
+
+        self.resource.getConfigurationOptions = getConfigurationOptions
+        self.resource.create = create
+        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
+        return self.handleRequest(xml)
+
+
+    def test_on_default(self):
+        """
+        A default request returns default options filtered by available fields.
+        """
+
+        xml = """
+        <iq type='get' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'>
+            <default/>
+          </pubsub>
+        </iq>
+        """
+        fieldDefs = {
+                "pubsub#persist_items":
+                    {"type": "boolean",
+                     "label": "Persist items to storage"},
+                "pubsub#deliver_payloads":
+                    {"type": "boolean",
+                     "label": "Deliver payloads with event notifications"}
+                }
+
+        def getConfigurationOptions():
+            return fieldDefs
+
         def default(request):
-            return defer.succeed({})
+            return defer.succeed({'pubsub#persist_items': 'false',
+                                  'x-myfield': '1'})
 
         def cb(element):
-            self.assertEqual('pubsub', element.name)
-            self.assertEqual(NS_PUBSUB_OWNER, element.uri)
-            self.assertEqual(NS_PUBSUB_OWNER, element.default.uri)
+            self.assertEquals('pubsub', element.name)
+            self.assertEquals(NS_PUBSUB_OWNER, element.uri)
+            self.assertEquals(NS_PUBSUB_OWNER, element.default.uri)
             form = data_form.Form.fromElement(element.default.x)
-            self.assertEqual(NS_PUBSUB_CONFIG, form.formNamespace)
+            self.assertEquals(NS_PUBSUB_NODE_CONFIG, form.formNamespace)
+            form.typeCheck(fieldDefs)
+            self.assertIn('pubsub#persist_items', form.fields)
+            self.assertFalse(form.fields['pubsub#persist_items'].value)
+            self.assertNotIn('x-myfield', form.fields)
 
         self.resource.getConfigurationOptions = getConfigurationOptions
@@ -1784 +2691 @@
 
 
-    def test_on_defaultCollection(self):
-        """
-        Responses to default requests should depend on passed node type.
-        """
-
-        xml = """
-        <iq type='get' to='pubsub.example.org'
-                       from='user@example.org'>
-          <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'>
-            <default>
-              <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#node_type'>
-                  <value>collection</value>
-                </field>
-              </x>
-            </default>
-
-          </pubsub>
-        </iq>
-        """
-
-        def getConfigurationOptions():
-            return {
-                "pubsub#deliver_payloads":
-                    {"type": "boolean",
-                     "label": "Deliver payloads with event notifications"}
-                }
-
-        def default(request):
-            return defer.succeed({})
-
-        self.resource.getConfigurationOptions = getConfigurationOptions
-        self.resource.default = default
-        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
-        return self.handleRequest(xml)
-
-
     def test_on_defaultUnknownNodeType(self):
         """
-        A default request should result in
-        L{PubSubResource.default} being called.
+        Unknown node types yield non-acceptable.
+
+        Both C{getConfigurationOptions} and C{default} must not be called.
         """
 
@@ -1849 +2717 @@
         """
 
+        def getConfigurationOptions():
+            self.fail("Unexpected call to getConfigurationOptions")
+
         def default(request):
-            self.fail("Unexpected call to getConfiguration")
+            self.fail("Unexpected call to default")
 
         def cb(result):
             self.assertEquals('not-acceptable', result.condition)
 
+        self.resource.getConfigurationOptions = getConfigurationOptions
         self.resource.default = default
         verify.verifyObject(iwokkel.IPubSubResource, self.resource)
@@ -1896 +2768 @@
                                   'pubsub#persist_items': '1',
                                   'pubsub#owner': JID('user@example.org'),
-                                  'x-myfield': ['a', 'b']})
+                                  'x-myfield': 'a'})
 
         def cb(element):
@@ -1903 +2775 @@
             self.assertEqual(NS_PUBSUB_OWNER, element.configure.uri)
             form = data_form.Form.fromElement(element.configure.x)
-            self.assertEqual(NS_PUBSUB_CONFIG, form.formNamespace)
+            self.assertEqual(NS_PUBSUB_NODE_CONFIG, form.formNamespace)
             fields = form.fields
 
@@ -1969 +2841 @@
         def configureSet(request):
             self.assertEqual({'pubsub#deliver_payloads': False,
-                              'pubsub#persist_items': True}, request.options)
+                              'pubsub#persist_items': True},
+                             request.options.getValues())
             return defer.succeed(None)
 
@@ -2041 +2914 @@
         def configureSet(request):
             self.assertEquals(['pubsub#deliver_payloads'],
-                              request.options.keys())
+                              request.options.fields.keys())
 
         self.resource.getConfigurationOptions = getConfigurationOptions
@@ -2073 +2946 @@
         def cb(result):
             self.assertEquals('bad-request', result.condition)
+            self.assertEqual("Unexpected form type 'result'", result.text)
 
         d = self.handleRequest(xml)
@@ -2183 +3057 @@
         verify.verifyObject(iwokkel.IPubSubResource, self.resource)
         return self.handleRequest(xml)
+
+
+    def test_notifyPublish(self):
+        """
+        Publish notifications are sent to the subscribers.
+        """
+        subscriber = JID('user@example.org')
+        subscriptions = [pubsub.Subscription('test', subscriber, 'subscribed')]
+        items = [pubsub.Item('current')]
+        notifications = [(subscriber, subscriptions, items)]
+        self.service.notifyPublish(JID('pubsub.example.org'), 'test',
+                                   notifications)
+        message = self.stub.output[-1]
+
+        self.assertEquals('message', message.name)
+        self.assertIdentical(None, message.uri)
+        self.assertEquals('user@example.org', message['to'])
+        self.assertEquals('pubsub.example.org', message['from'])
+        self.assertTrue(message.event)
+        self.assertEquals(NS_PUBSUB_EVENT, message.event.uri)
+        self.assertTrue(message.event.items)
+        self.assertEquals(NS_PUBSUB_EVENT, message.event.items.uri)
+        self.assertTrue(message.event.items.hasAttribute('node'))
+        self.assertEquals('test', message.event.items['node'])
+        itemElements = list(domish.generateElementsQNamed(
+            message.event.items.children, 'item', NS_PUBSUB_EVENT))
+        self.assertEquals(1, len(itemElements))
+        self.assertEquals('current', itemElements[0].getAttribute('id'))
+
+
+    def test_notifyPublishCollection(self):
+        """
+        Publish notifications are sent to the subscribers of collections.
+
+        The node the item was published to is on the C{items} element, while
+        the subscribed-to node is in the C{'Collections'} SHIM header.
+        """
+        subscriber = JID('user@example.org')
+        subscriptions = [pubsub.Subscription('', subscriber, 'subscribed')]
+        items = [pubsub.Item('current')]
+        notifications = [(subscriber, subscriptions, items)]
+        self.service.notifyPublish(JID('pubsub.example.org'), 'test',
+                                   notifications)
+        message = self.stub.output[-1]
+
+        self.assertTrue(message.event.items.hasAttribute('node'))
+        self.assertEquals('test', message.event.items['node'])
+        headers = shim.extractHeaders(message)
+        self.assertIn('Collection', headers)
+        self.assertIn('', headers['Collection'])
 
 
@@ -2288 +3212 @@
     def test_on_affiliationsGet(self):
         """
-        Getting subscription options is not supported.
+        Getting node affiliations should have.
+        """
+
+        xml = """
+        <iq type='get' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'>
+            <affiliations node='test'/>
+          </pubsub>
+        </iq>
+        """
+
+        def affiliationsGet(request):
+            self.assertEquals('test', request.nodeIdentifier)
+            return defer.succeed({JID('user@example.org'): 'owner'})
+
+        def cb(element):
+            self.assertEquals(u'pubsub', element.name)
+            self.assertEquals(NS_PUBSUB_OWNER, element.uri)
+            self.assertEquals(NS_PUBSUB_OWNER, element.affiliations.uri)
+            self.assertEquals(u'test', element.affiliations[u'node'])
+            children = list(element.affiliations.elements())
+            self.assertEquals(1, len(children))
+            affiliation = children[0]
+            self.assertEquals(u'affiliation', affiliation.name)
+            self.assertEquals(NS_PUBSUB_OWNER, affiliation.uri)
+            self.assertEquals(u'user@example.org', affiliation[u'jid'])
+            self.assertEquals(u'owner', affiliation[u'affiliation'])
+
+        self.resource.affiliationsGet = affiliationsGet
+        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
+        d = self.handleRequest(xml)
+        d.addCallback(cb)
+        return d
+
+
+    def test_on_affiliationsGetEmptyNode(self):
+        """
+        Getting node affiliations without node should assume empty node.
         """
 
@@ -2300 +3262 @@
         """
 
+        def affiliationsGet(request):
+            self.assertIdentical('', request.nodeIdentifier)
+            return defer.succeed({})
+
+        def cb(element):
+            self.assertFalse(element.affiliations.hasAttribute(u'node'))
+
+        self.resource.affiliationsGet = affiliationsGet
+        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
+        d = self.handleRequest(xml)
+        d.addCallback(cb)
+        return d
+
+
+    def test_on_affiliationsSet(self):
+        """
+        Setting node affiliations has the affiliations to be modified.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'>
+            <affiliations node='test'>
+              <affiliation jid='other@example.org' affiliation='publisher'/>
+            </affiliations>
+          </pubsub>
+        </iq>
+        """
+
+        def affiliationsSet(request):
+            self.assertEquals(u'test', request.nodeIdentifier)
+            otherJID = JID(u'other@example.org')
+            self.assertIn(otherJID, request.affiliations)
+            self.assertEquals(u'publisher', request.affiliations[otherJID])
+
+        self.resource.affiliationsSet = affiliationsSet
+        return self.handleRequest(xml)
+
+
+    def test_on_affiliationsSetBareJID(self):
+        """
+        Affiliations are always on the bare JID.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'>
+            <affiliations node='test'>
+              <affiliation jid='other@example.org/Home'
+                           affiliation='publisher'/>
+            </affiliations>
+          </pubsub>
+        </iq>
+        """
+
+        def affiliationsSet(request):
+            otherJID = JID(u'other@example.org')
+            self.assertIn(otherJID, request.affiliations)
+
+        self.resource.affiliationsSet = affiliationsSet
+        return self.handleRequest(xml)
+
+
+    def test_on_affiliationsSetMultipleForSameEntity(self):
+        """
+        Setting node affiliations can only have one item per entity.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'>
+            <affiliations node='test'>
+              <affiliation jid='other@example.org' affiliation='publisher'/>
+              <affiliation jid='other@example.org' affiliation='owner'/>
+            </affiliations>
+          </pubsub>
+        </iq>
+        """
+
         def cb(result):
-            self.assertEquals('feature-not-implemented', result.condition)
-            self.assertEquals('unsupported', result.appCondition.name)
-            self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
-            self.assertEquals('modify-affiliations',
-                              result.appCondition['feature'])
+            self.assertEquals('bad-request', result.condition)
 
         d = self.handleRequest(xml)
@@ -2313 +3353 @@
 
 
-    def test_on_affiliationsSet(self):
-        """
-        Setting subscription options is not supported.
+    def test_on_affiliationsSetMissingJID(self):
+        """
+        Setting node affiliations must include a JID per affiliation.
         """
 
@@ -2322 +3362 @@
                        from='user@example.org'>
           <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'>
-            <affiliations/>
+            <affiliations node='test'>
+              <affiliation affiliation='publisher'/>
+            </affiliations>
           </pubsub>
         </iq>
@@ -2328 +3370 @@
 
         def cb(result):
-            self.assertEquals('feature-not-implemented', result.condition)
-            self.assertEquals('unsupported', result.appCondition.name)
-            self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
-            self.assertEquals('modify-affiliations',
-                              result.appCondition['feature'])
+            self.assertEquals('bad-request', result.condition)
+
+        d = self.handleRequest(xml)
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d
+
+
+    def test_on_affiliationsSetMissingAffiliation(self):
+        """
+        Setting node affiliations must include an affiliation.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'>
+            <affiliations node='test'>
+              <affiliation jid='other@example.org'/>
+            </affiliations>
+          </pubsub>
+        </iq>
+        """
+
+        def cb(result):
+            self.assertEquals('bad-request', result.condition)
 
         d = self.handleRequest(xml)
@@ -2347 +3410 @@
         self.service = pubsub.PubSubService()
         self.service.send = self.stub.xmlstream.send
+
+
+    def test_getDiscoInfo(self):
+        """
+        Test getDiscoInfo calls getNodeInfo and returns some minimal info.
+        """
+        def cb(info):
+            discoInfo = disco.DiscoInfo()
+            for item in info:
+                discoInfo.append(item)
+            self.assertIn(('pubsub', 'service'), discoInfo.identities)
+            self.assertIn(disco.NS_DISCO_ITEMS, discoInfo.features)
+
+        d = self.service.getDiscoInfo(JID('user@example.org/home'),
+                                      JID('pubsub.example.org'), '')
+        d.addCallback(cb)
+        return d
 
 
@@ -2596 +3676 @@
 
 
+    def test_setConfigurationOptionsDict(self):
+        """
+        Options should be passed as a dictionary, not a form.
+        """
+
+        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 getConfigurationOptions():
+            return {
+                "pubsub#persist_items":
+                    {"type": "boolean",
+                     "label": "Persist items to storage"},
+                "pubsub#deliver_payloads":
+                    {"type": "boolean",
+                     "label": "Deliver payloads with event notifications"}
+                }
+
+        def setConfiguration(requestor, service, nodeIdentifier, options):
+            self.assertEquals({'pubsub#deliver_payloads': False,
+                               'pubsub#persist_items': True}, options)
+
+
+        self.service.getConfigurationOptions = getConfigurationOptions
+        self.service.setConfiguration = setConfiguration
+        return self.handleRequest(xml)
+
+
     def test_items(self):
         """
@@ -2692 +3814 @@
             self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
             self.assertEquals('delete-nodes', result.appCondition['feature'])
+
+        d = self.handleRequest(xml)
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d
+
+
+    def test_unknown(self):
+        """
+        Unknown verb yields unsupported error.
+        """
+        xml = """
+        <iq type='get' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'>
+            <affiliations node='test'/>
+          </pubsub>
+        </iq>
+        """
+
+        def cb(result):
+            self.assertEquals('feature-not-implemented', result.condition)
+            self.assertEquals('unsupported', result.appCondition.name)
+            self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
 
         d = self.handleRequest(xml)
@@ -2951 +4097 @@
         d.addCallback(cb)
         return d
+
+
+    def test_affiliationsGet(self):
+        """
+        Non-overridden owner affiliations get yields unsupported error.
+        """
+
+        def cb(result):
+            self.assertEquals('feature-not-implemented', result.condition)
+            self.assertEquals('unsupported', result.appCondition.name)
+            self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
+            self.assertEquals('modify-affiliations',
+                              result.appCondition['feature'])
+
+        d = self.resource.affiliationsGet(pubsub.PubSubRequest())
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d
+
+
+    def test_affiliationsSet(self):
+        """
+        Non-overridden owner affiliations set yields unsupported error.
+        """
+
+        def cb(result):
+            self.assertEquals('feature-not-implemented', result.condition)
+            self.assertEquals('unsupported', result.appCondition.name)
+            self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
+            self.assertEquals('modify-affiliations',
+                              result.appCondition['feature'])
+
+        d = self.resource.affiliationsSet(pubsub.PubSubRequest())
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d

wokkel/test/test_server.py

@@ -1 @@
-# Copyright (c) 2003-2008 Ralph Meijer
+# Copyright (c) Ralph Meijer.
 # See LICENSE for details.
 

wokkel/test/test_shim.py

@@ -1 +1 @@
 # -*- test-case-name: wokkel.test.test_shim -*-
 #
-# Copyright (c) 2003-2008 Ralph Meijer
+# Copyright (c) Ralph Meijer.
 # See LICENSE for details.
 

wokkel/test/test_subprotocols.py

@@ -1 @@
-# Copyright (c) 2003-2007 Ralph Meijer
+# Copyright (c) Ralph Meijer.
 # See LICENSE for details.
 
@@ -10 +10 @@
 from twisted.trial import unittest
 from twisted.test import proto_helpers
-from twisted.internet import defer
+from twisted.internet import defer, task
+from twisted.internet.error import ConnectionDone
+from twisted.python import failure
 from twisted.words.xish import domish
 from twisted.words.protocols.jabber import error, xmlstream
 
-from wokkel import iwokkel, subprotocols
+from wokkel import generic, iwokkel, subprotocols
 
 class DummyFactory(object):
@@ -56 +58 @@
 
 
+class FailureReasonXMPPHandler(subprotocols.XMPPHandler):
+    """
+    Dummy handler specifically for failure Reason tests.
+    """
+    def __init__(self):
+        self.gotFailureReason = False
+
+
+    def connectionLost(self, reason):
+        if isinstance(reason, failure.Failure):
+            self.gotFailureReason = True
+
+
+
+class IQGetStanza(generic.Stanza):
+    timeout = None
+
+    stanzaKind = 'iq'
+    stanzaType = 'get'
+    stanzaID = 'test'
+
+
+
 class XMPPHandlerTest(unittest.TestCase):
     """
@@ -111 +136 @@
 
 
+    def test_request(self):
+        """
+        A request is passed up to the stream manager.
+        """
+        class DummyStreamManager(object):
+            def __init__(self):
+                self.requests = []
+
+            def request(self, request):
+                self.requests.append(request)
+                return defer.succeed(None)
+
+        handler = subprotocols.XMPPHandler()
+        handler.parent = DummyStreamManager()
+        request = IQGetStanza()
+        d = handler.request(request)
+        self.assertEquals(1, len(handler.parent.requests))
+        self.assertIdentical(request, handler.parent.requests[-1])
+        return d
+
+
 
 class XMPPHandlerCollectionTest(unittest.TestCase):
@@ -156 +202 @@
 
     def setUp(self):
+        factory = xmlstream.XmlStreamFactory(xmlstream.Authenticator())
+        self.clock = task.Clock()
+        self.streamManager = subprotocols.StreamManager(factory, self.clock)
+        self.xmlstream = factory.buildProtocol(None)
+        self.transport = proto_helpers.StringTransport()
+        self.xmlstream.transport = self.transport
+
+        self.request = IQGetStanza()
+
+    def _streamStarted(self):
+        """
+        Bring the test stream to the initialized state.
+        """
+        self.xmlstream.connectionMade()
+        self.xmlstream.dataReceived(
+                "<stream:stream xmlns='jabber:client' "
+                    "xmlns:stream='http://etherx.jabber.org/streams' "
+                    "from='example.com' id='12345'>")
+        self.xmlstream.dispatch(self.xmlstream, "//event/stream/authd")
+
+
+    def test_basic(self):
+        """
+        Test correct initialization and setup of factory observers.
+        """
         factory = DummyFactory()
-        self.streamManager = subprotocols.StreamManager(factory)
-
-    def test_basic(self):
-        """
-        Test correct initialization and setup of factory observers.
-        """
-        sm = self.streamManager
+        sm = subprotocols.StreamManager(factory)
         self.assertIdentical(None, sm.xmlstream)
         self.assertEquals([], sm.handlers)
@@ -235 +300 @@
     def test_disconnected(self):
         """
-        Test that protocol handlers have their connectionLost method
-        called when the XML stream is disconnected.
-        """
-        sm = self.streamManager
-        handler = DummyXMPPHandler()
-        handler.setHandlerParent(sm)
-        xs = xmlstream.XmlStream(xmlstream.Authenticator())
-        sm._disconnected(xs)
+        Protocol handlers have connectionLost called on stream disconnect.
+        """
+        sm = self.streamManager
+        handler = DummyXMPPHandler()
+        handler.setHandlerParent(sm)
+        sm._disconnected(None)
         self.assertEquals(0, handler.doneMade)
         self.assertEquals(0, handler.doneInitialized)
@@ -248 +311 @@
 
 
+    def test_disconnectedReason(self):
+        """
+        A L{STREAM_END_EVENT} results in L{StreamManager} firing the handlers
+        L{connectionLost} methods, passing a L{failure.Failure} reason.
+        """
+        sm = self.streamManager
+        handler = FailureReasonXMPPHandler()
+        handler.setHandlerParent(sm)
+        xs = xmlstream.XmlStream(xmlstream.Authenticator())
+        sm._disconnected(failure.Failure(Exception("no reason")))
+        self.assertEquals(True, handler.gotFailureReason)
+
+
     def test_addHandler(self):
         """
@@ -261 +337 @@
 
 
+    def test_addHandlerConnected(self):
+        """
+        Adding a handler when connected doesn't call connectionInitialized.
+        """
+        sm = self.streamManager
+        xs = xmlstream.XmlStream(xmlstream.Authenticator())
+        sm._connected(xs)
+        handler = DummyXMPPHandler()
+        handler.setHandlerParent(sm)
+
+        self.assertEquals(1, handler.doneMade)
+        self.assertEquals(0, handler.doneInitialized)
+        self.assertEquals(0, handler.doneLost)
+
+
+    def test_addHandlerConnectedNested(self):
+        """
+        Adding a handler in connectionMade doesn't cause 2nd call.
+        """
+        class NestingHandler(DummyXMPPHandler):
+            nestedHandler = None
+
+            def connectionMade(self):
+                DummyXMPPHandler.connectionMade(self)
+                self.nestedHandler = DummyXMPPHandler()
+                self.nestedHandler.setHandlerParent(self.parent)
+
+        sm = self.streamManager
+        xs = xmlstream.XmlStream(xmlstream.Authenticator())
+        handler = NestingHandler()
+        handler.setHandlerParent(sm)
+        sm._connected(xs)
+
+        self.assertEquals(1, handler.doneMade)
+        self.assertEquals(0, handler.doneInitialized)
+        self.assertEquals(0, handler.doneLost)
+
+        self.assertEquals(1, handler.nestedHandler.doneMade)
+        self.assertEquals(0, handler.nestedHandler.doneInitialized)
+        self.assertEquals(0, handler.nestedHandler.doneLost)
+
+
+
     def test_addHandlerInitialized(self):
         """
@@ -281 +400 @@
         self.assertEquals(0, handler.doneLost)
 
+
+    def test_addHandlerInitializedNested(self):
+        """
+        Adding a handler in connectionInitialized doesn't cause 2nd call.
+        """
+        class NestingHandler(DummyXMPPHandler):
+            nestedHandler = None
+
+            def connectionInitialized(self):
+                DummyXMPPHandler.connectionInitialized(self)
+                self.nestedHandler = DummyXMPPHandler()
+                self.nestedHandler.setHandlerParent(self.parent)
+
+        sm = self.streamManager
+        xs = xmlstream.XmlStream(xmlstream.Authenticator())
+        handler = NestingHandler()
+        handler.setHandlerParent(sm)
+        sm._connected(xs)
+        sm._authd(xs)
+
+        self.assertEquals(1, handler.doneMade)
+        self.assertEquals(1, handler.doneInitialized)
+        self.assertEquals(0, handler.doneLost)
+
+        self.assertEquals(1, handler.nestedHandler.doneMade)
+        self.assertEquals(1, handler.nestedHandler.doneInitialized)
+        self.assertEquals(0, handler.nestedHandler.doneLost)
+
+
+    def test_addHandlerConnectionLostNested(self):
+        """
+        Adding a handler in connectionLost doesn't call connectionLost there.
+        """
+        class NestingHandler(DummyXMPPHandler):
+            nestedHandler = None
+
+            def connectionLost(self, reason):
+                DummyXMPPHandler.connectionLost(self, reason)
+                self.nestedHandler = DummyXMPPHandler()
+                self.nestedHandler.setHandlerParent(self.parent)
+
+        sm = self.streamManager
+        xs = xmlstream.XmlStream(xmlstream.Authenticator())
+        handler = NestingHandler()
+        handler.setHandlerParent(sm)
+        sm._connected(xs)
+        sm._authd(xs)
+        sm._disconnected(xs)
+
+        self.assertEquals(1, handler.doneMade)
+        self.assertEquals(1, handler.doneInitialized)
+        self.assertEquals(1, handler.doneLost)
+
+        self.assertEquals(0, handler.nestedHandler.doneMade)
+        self.assertEquals(0, handler.nestedHandler.doneInitialized)
+        self.assertEquals(0, handler.nestedHandler.doneLost)
+
+
+
     def test_removeHandler(self):
         """
@@ -291 +469 @@
         self.assertNotIn(handler, sm)
         self.assertIdentical(None, handler.parent)
+
 
     def test_sendInitialized(self):
@@ -381 +560 @@
         self.assertEquals("", xs.transport.value())
         self.assertEquals("<presence/>", sm._packetQueue[0])
+
+
+    def test_requestSendInitialized(self):
+        """
+        A request is sent out over the wire when the stream is initialized.
+        """
+        self._streamStarted()
+
+        self.streamManager.request(self.request)
+        expected = u"<iq type='get' id='%s'/>" % self.request.stanzaID
+        self.assertEquals(expected, self.transport.value())
+
+
+    def test_requestSendInitializedFreshID(self):
+        """
+        A request without an ID gets a fresh one upon send.
+        """
+        self._streamStarted()
+
+        self.request.stanzaID = None
+        self.streamManager.request(self.request)
+        self.assertNotIdentical(None, self.request.stanzaID)
+        expected = u"<iq type='get' id='%s'/>" % self.request.stanzaID
+        self.assertEquals(expected, self.transport.value())
+
+
+    def test_requestSendNotConnected(self):
+        """
+        A request is queued until a stream is initialized.
+        """
+        handler = DummyXMPPHandler()
+        self.streamManager.addHandler(handler)
+
+        self.streamManager.request(self.request)
+        expected = u"<iq type='get' id='test'/>"
+
+        xs = self.xmlstream
+        self.assertEquals("", xs.transport.value())
+
+        xs.connectionMade()
+        self.assertEquals("", xs.transport.value())
+
+        xs.dataReceived("<stream:stream xmlns='jabber:client' "
+                        "xmlns:stream='http://etherx.jabber.org/streams' "
+                        "from='example.com' id='12345'>")
+        xs.dispatch(xs, "//event/stream/authd")
+
+        self.assertEquals(expected, xs.transport.value())
+        self.assertFalse(self.streamManager._packetQueue)
+
+
+    def test_requestResultResponse(self):
+        """
+        A result response gets the request deferred fired with the response.
+        """
+        def cb(result):
+            self.assertEquals(result['type'], 'result')
+
+        self._streamStarted()
+        d = self.streamManager.request(self.request)
+        d.addCallback(cb)
+
+        xs = self.xmlstream
+        xs.dataReceived("<iq type='result' id='test'/>")
+        return d
+
+
+    def test_requestErrorResponse(self):
+        """
+        An error response gets the request deferred fired with a failure.
+        """
+        self._streamStarted()
+        d = self.streamManager.request(self.request)
+        self.assertFailure(d, error.StanzaError)
+
+        xs = self.xmlstream
+        xs.dataReceived("<iq type='error' id='test'/>")
+        return d
+
+
+    def test_requestNonTrackedResponse(self):
+        """
+        Test that untracked iq responses don't trigger any action.
+
+        Untracked means that the id of the incoming response iq is not
+        in the stream's C{iqDeferreds} dictionary.
+        """
+        # Set up a fallback handler that checks the stanza's handled attribute.
+        # If that is set to True, the iq tracker claims to have handled the
+        # response.
+        dispatched = []
+        def cb(iq):
+            dispatched.append(iq)
+
+        self._streamStarted()
+        self.xmlstream.addObserver("/iq", cb, -1)
+
+        # Receive an untracked iq response
+        self.xmlstream.dataReceived("<iq type='result' id='other'/>")
+        self.assertEquals(1, len(dispatched))
+        self.assertFalse(getattr(dispatched[-1], 'handled', False))
+
+
+    def test_requestCleanup(self):
+        """
+        Test if the deferred associated with an iq request is removed
+        from the list kept in the L{XmlStream} object after it has
+        been fired.
+        """
+        self._streamStarted()
+        d = self.streamManager.request(self.request)
+        xs = self.xmlstream
+        xs.dataReceived("<iq type='result' id='test'/>")
+        self.assertNotIn('test', self.streamManager._iqDeferreds)
+        return d
+
+
+    def test_requestDisconnectCleanup(self):
+        """
+        Test if deferreds for iq's that haven't yet received a response
+        have their errback called on stream disconnect.
+        """
+        d = self.streamManager.request(self.request)
+        xs = self.xmlstream
+        xs.connectionLost(failure.Failure(ConnectionDone()))
+        self.assertFailure(d, ConnectionDone)
+        return d
+
+
+    def test_requestNoModifyingDict(self):
+        """
+        Test to make sure the errbacks cannot cause the iteration of the
+        iqDeferreds to blow up in our face.
+        """
+
+        def eb(failure):
+            d = xmlstream.IQ(self.xmlstream).send()
+            d.addErrback(eb)
+
+        d = self.streamManager.request(self.request)
+        d.addErrback(eb)
+        self.xmlstream.connectionLost(failure.Failure(ConnectionDone()))
+        return d
+
+
+    def test_requestTimingOut(self):
+        """
+        Test that an iq request with a defined timeout times out.
+        """
+        self.request.timeout = 60
+        d = self.streamManager.request(self.request)
+        self.assertFailure(d, xmlstream.TimeoutError)
+
+        self.clock.pump([1, 60])
+        self.assertFalse(self.clock.calls)
+        self.assertFalse(self.streamManager._iqDeferreds)
+        return d
+
+
+    def test_requestNotTimingOut(self):
+        """
+        Test that an iq request with a defined timeout does not time out
+        when a response was received before the timeout period elapsed.
+        """
+        self._streamStarted()
+        self.request.timeout = 60
+        d = self.streamManager.request(self.request)
+        self.clock.callLater(1, self.xmlstream.dataReceived,
+                             "<iq type='result' id='test'/>")
+        self.clock.pump([1, 1])
+        self.assertFalse(self.clock.calls)
+        return d
+
+
+    def test_requestDisconnectTimeoutCancellation(self):
+        """
+        Test if timeouts for iq's that haven't yet received a response
+        are cancelled on stream disconnect.
+        """
+
+        self.request.timeout = 60
+        d = self.streamManager.request(self.request)
+
+        self.xmlstream.connectionLost(failure.Failure(ConnectionDone()))
+        self.assertFailure(d, ConnectionDone)
+        self.assertFalse(self.clock.calls)
+        return d
+
+
+    def test_requestNotIQ(self):
+        """
+        The request stanza must be an iq.
+        """
+        stanza = generic.Stanza()
+        stanza.stanzaKind = 'message'
+
+        d = self.streamManager.request(stanza)
+        self.assertFailure(d, ValueError)
+
+
+    def test_requestNotResult(self):
+        """
+        The request stanza cannot be of type 'result'.
+        """
+        stanza = generic.Stanza()
+        stanza.stanzaKind = 'iq'
+        stanza.stanzaType = 'result'
+
+        d = self.streamManager.request(stanza)
+        self.assertFailure(d, ValueError)
+
+
+    def test_requestNotError(self):
+        """
+        The request stanza cannot be of type 'error'.
+        """
+        stanza = generic.Stanza()
+        stanza.stanzaKind = 'iq'
+        stanza.stanzaType = 'error'
+
+        d = self.streamManager.request(stanza)
+        self.assertFailure(d, ValueError)
 
 

wokkel/test/test_xmppim.py

@@ -1 @@
-# Copyright (c) 2003-2009 Ralph Meijer
+# Copyright (c) Ralph Meijer.
 # See LICENSE for details
 

wokkel/xmppim.py

@@ -1 +1 @@
 # -*- test-case-name: wokkel.test.test_xmppim -*-
 #
-# Copyright (c) 2003-2009 Ralph Meijer
+# Copyright (c) Ralph Meijer.
 # See LICENSE for details.