source: ralphm-patches/pubsub_request.patch @ 13:42b22edb29bb

wokkel/generic.py

@@ -10 +10 @@
 from zope.interface import implements
 
 from twisted.internet import defer, protocol
-from twisted.words.protocols.jabber import error, xmlstream
+from twisted.words.protocols.jabber import error, jid, xmlstream
 from twisted.words.protocols.jabber.xmlstream import toResponse
 from twisted.words.xish import domish, utility
 
@@ -162 +162 @@
         self.sink.send = lambda obj: self.source.dispatch(obj)
 
 
+
+class Stanza(object):
+    """
+    Abstract representation of a stanza.
+
+    @ivar sender: The sending entity.
+    @type sender: L{jid.JID}
+    @ivar recipient: The receiving entity.
+    @type recipient: L{jid.JID}
+    """
+
+    sender = None
+    recipient = None
+    stanzaType = None
+
+    @classmethod
+    def fromElement(Class, element):
+        stanza = Class()
+        stanza.parseElement(element)
+        return stanza
+
+
+    def parseElement(self, element):
+        self.sender = jid.internJID(element['from'])
+        if element.hasAttribute('from'):
+            self.sender = jid.internJID(element['from'])
+        if element.hasAttribute('to'):
+            self.recipient = jid.internJID(element['to'])
+        self.stanzaType = element.getAttribute('type')
+
+
 class DeferredXmlStreamFactory(BootstrapMixin, protocol.ClientFactory):
     protocol = xmlstream.XmlStream
 

wokkel/pubsub.py

@@ -16 +16 @@
 from twisted.words.protocols.jabber import jid, error, xmlstream
 from twisted.words.xish import domish
 
-from wokkel import disco, data_form, shim
+from wokkel import disco, data_form, generic, shim
 from wokkel.subprotocols import IQHandlerMixin, XMPPHandler
 from wokkel.iwokkel import IPubSubClient, IPubSubService
 
@@ -31 +31 @@
 NS_PUBSUB_OWNER = NS_PUBSUB + "#owner"
 NS_PUBSUB_NODE_CONFIG = NS_PUBSUB + "#node_config"
 NS_PUBSUB_META_DATA = NS_PUBSUB + "#meta-data"
+NS_PUBSUB_SUBSCRIBE_OPTIONS = NS_PUBSUB + "#subscribe_options"
 
-# In publish-subscribe namespace XPath query selector.
-IN_NS_PUBSUB = '[@xmlns="' + NS_PUBSUB + '"]'
-IN_NS_PUBSUB_OWNER = '[@xmlns="' + NS_PUBSUB_OWNER + '"]'
-
-# Publish-subscribe XPath queries
-PUBSUB_ELEMENT = '/pubsub' + IN_NS_PUBSUB
-PUBSUB_OWNER_ELEMENT = '/pubsub' + IN_NS_PUBSUB_OWNER
-PUBSUB_GET = IQ_GET + PUBSUB_ELEMENT
-PUBSUB_SET = IQ_SET + PUBSUB_ELEMENT
-PUBSUB_OWNER_GET = IQ_GET + PUBSUB_OWNER_ELEMENT
-PUBSUB_OWNER_SET = IQ_SET + PUBSUB_OWNER_ELEMENT
-
-# Publish-subscribe command XPath queries
-PUBSUB_PUBLISH = PUBSUB_SET + '/publish' + IN_NS_PUBSUB
-PUBSUB_CREATE = PUBSUB_SET + '/create' + IN_NS_PUBSUB
-PUBSUB_SUBSCRIBE = PUBSUB_SET + '/subscribe' + IN_NS_PUBSUB
-PUBSUB_UNSUBSCRIBE = PUBSUB_SET + '/unsubscribe' + IN_NS_PUBSUB
-PUBSUB_OPTIONS_GET = PUBSUB_GET + '/options' + IN_NS_PUBSUB
-PUBSUB_OPTIONS_SET = PUBSUB_SET + '/options' + IN_NS_PUBSUB
-PUBSUB_DEFAULT = PUBSUB_OWNER_GET + '/default' + IN_NS_PUBSUB_OWNER
-PUBSUB_CONFIGURE_GET = PUBSUB_OWNER_GET + '/configure' + IN_NS_PUBSUB_OWNER
-PUBSUB_CONFIGURE_SET = PUBSUB_OWNER_SET + '/configure' + IN_NS_PUBSUB_OWNER
-PUBSUB_SUBSCRIPTIONS = PUBSUB_GET + '/subscriptions' + IN_NS_PUBSUB
-PUBSUB_AFFILIATIONS = PUBSUB_GET + '/affiliations' + IN_NS_PUBSUB
-PUBSUB_AFFILIATIONS_GET = PUBSUB_OWNER_GET + '/affiliations' + \
-                          IN_NS_PUBSUB_OWNER
-PUBSUB_AFFILIATIONS_SET = PUBSUB_OWNER_SET + '/affiliations' + \
-                          IN_NS_PUBSUB_OWNER
-PUBSUB_SUBSCRIPTIONS_GET = PUBSUB_OWNER_GET + '/subscriptions' + \
-                          IN_NS_PUBSUB_OWNER
-PUBSUB_SUBSCRIPTIONS_SET = PUBSUB_OWNER_SET + '/subscriptions' + \
-                          IN_NS_PUBSUB_OWNER
-PUBSUB_ITEMS = PUBSUB_GET + '/items' + IN_NS_PUBSUB
-PUBSUB_RETRACT = PUBSUB_SET + '/retract' + IN_NS_PUBSUB
-PUBSUB_PURGE = PUBSUB_OWNER_SET + '/purge' + IN_NS_PUBSUB_OWNER
-PUBSUB_DELETE = PUBSUB_OWNER_SET + '/delete' + IN_NS_PUBSUB_OWNER
+# XPath to match pubsub requests
+PUBSUB_REQUEST = '/iq[@type="get" or @type="set"]/' + \
+                    'pubsub[@xmlns="' + NS_PUBSUB + '" or ' + \
+                           '@xmlns="' + NS_PUBSUB_OWNER + '"]'
 
 class SubscriptionPending(Exception):
     """
@@ -98 +67 @@
 
 
 
-class BadRequest(PubSubError):
+class BadRequest(error.StanzaError):
     """
     Bad request stanza error.
     """
     def __init__(self, pubsubCondition=None, text=None):
-        PubSubError.__init__(self, 'bad-request', pubsubCondition, text)
+        if pubsubCondition:
+            appCondition = domish.Element((NS_PUBSUB_ERRORS, pubsubCondition))
+        else:
+            appCondition = None
+        error.StanzaError.__init__(self, 'bad-request',
+                                         text=text,
+                                         appCondition=appCondition)
 
 
 
@@ -167 +142 @@
 
 
 
-class _PubSubRequest(xmlstream.IQ):
+class PubSubRequest(generic.Stanza):
     """
-    Publish subscribe request.
+    A publish-subscribe request.
 
-    @ivar verb: Request verb
-    @type verb: C{str}
-    @ivar namespace: Request namespace.
-    @type namespace: C{str}
-    @ivar method: Type attribute of the IQ request. Either C{'set'} or C{'get'}
-    @type method: C{str}
-    @ivar command: Command element of the request. This is the direct child of
-                   the C{pubsub} element in the C{namespace} with the name
-                   C{verb}.
+    The set of instance variables used depends on the type of request. If
+    a variable is not applicable or not passed in the request, its value is
+    C{None}.
+
+    @ivar verb: The type of publish-subscribe request. See L{_requestVerbMap}.
+    @type verb: C{str}.
+
+    @ivar affiliations: Affiliations to be modified.
+    @type affiliations: C{set}
+    @ivar items: The items to be published, as L{domish.Element}s.
+    @type items: C{list}
+    @ivar itemIdentifiers: Identifiers of the items to be retrieved or
+                           retracted.
+    @type itemIdentifiers: C{set}
+    @ivar maxItems: Maximum number of items to retrieve.
+    @type maxItems: C{int}.
+    @ivar nodeIdentifier: Identifier of the node the request is about.
+    @type nodeIdentifier: C{unicode}
+    @ivar nodeType: The type of node that should be created, or for which the
+                    configuration is retrieved. C{'leaf'} or C{'collection'}.
+    @type nodeType: C{str}
+    @ivar options: Configurations options for nodes, subscriptions and publish
+                   requests.
+    @type options: L{data_form.Form}
+    @ivar subscriber: The subscribing entity.
+    @type subscriber: L{JID}
+    @ivar subscriptionIdentifier: Identifier for a specific subscription.
+    @type subscriptionIdentifier: C{unicode}
+    @ivar subscriptions: Subscriptions to be modified, as a set of
+                         L{Subscription}.
+    @type subscriptions: C{set}
     """
 
-    def __init__(self, xs, verb, namespace=NS_PUBSUB, method='set'):
-        xmlstream.IQ.__init__(self, xs, method)
-        self.addElement((namespace, 'pubsub'))
+    verb = None
 
-        self.command = self.pubsub.addElement(verb)
+    affiliations = None
+    items = None
+    itemIdentifiers = None
+    maxItems = None
+    nodeIdentifier = None
+    nodeType = None
+    options = None
+    subscriber = None
+    subscriptionIdentifier = None
+    subscriptions = None
 
+    # Map request iq type and subelement name to request verb
+    _requestVerbMap = {
+        ('set', NS_PUBSUB, 'publish'): 'publish',
+        ('set', NS_PUBSUB, 'subscribe'): 'subscribe',
+        ('set', NS_PUBSUB, 'unsubscribe'): 'unsubscribe',
+        ('get', NS_PUBSUB, 'options'): 'optionsGet',
+        ('set', NS_PUBSUB, 'options'): 'optionsSet',
+        ('get', NS_PUBSUB, 'subscriptions'): 'subscriptions',
+        ('get', NS_PUBSUB, 'affiliations'): 'affiliations',
+        ('set', NS_PUBSUB, 'create'): 'create',
+        ('get', NS_PUBSUB_OWNER, 'default'): 'default',
+        ('get', NS_PUBSUB_OWNER, 'configure'): 'configureGet',
+        ('set', NS_PUBSUB_OWNER, 'configure'): 'configureSet',
+        ('get', NS_PUBSUB, 'items'): 'items',
+        ('set', NS_PUBSUB, 'retract'): 'retract',
+        ('set', NS_PUBSUB_OWNER, 'purge'): 'purge',
+        ('set', NS_PUBSUB_OWNER, 'delete'): 'delete',
+        ('get', NS_PUBSUB_OWNER, 'affiliations'): 'affiliationsGet',
+        ('set', NS_PUBSUB_OWNER, 'affiliations'): 'affiliationsSet',
+        ('get', NS_PUBSUB_OWNER, 'subscriptions'): 'subscriptionsGet',
+        ('set', NS_PUBSUB_OWNER, 'subscriptions'): 'subscriptionsSet',
+    }
 
-    def send(self, to):
+    # Map request verb to request iq type and subelement name
+    _verbRequestMap = dict(((v, k) for k, v in _requestVerbMap.iteritems()))
+
+    # Map request verb to parameter handler names
+    _parameters = {
+        'publish': ['node', 'items'],
+        'subscribe': ['nodeOrEmpty', 'jid'],
+        'unsubscribe': ['nodeOrEmpty', 'jid'],
+        'optionsGet': ['nodeOrEmpty', 'jid'],
+        'optionsSet': ['nodeOrEmpty', 'jid', 'options'],
+        'subscriptions': [],
+        'affiliations': [],
+        'create': ['nodeOrNone'],
+        'default': ['default'],
+        'configureGet': ['nodeOrEmpty'],
+        'configureSet': ['nodeOrEmpty', 'configure'],
+        'items': ['node', 'maxItems', 'itemIdentifiers'],
+        'retract': ['node', 'itemIdentifiers'],
+        'purge': ['node'],
+        'delete': ['node'],
+        'affiliationsGet': [],
+        'affiliationsSet': [],
+        'subscriptionsGet': [],
+        'subscriptionsSet': [],
+    }
+
+    def __init__(self, verb=None):
+        self.verb = verb
+
+
+    @staticmethod
+    def _findForm(element, formNamespace):
         """
-        Send out request.
+        Find a Data Form.
 
-        Extends L{xmlstream.IQ.send} by requiring the C{to} parameter to be
-        a L{JID} instance.
+        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
 
-        @param to: Entity to send the request to.
-        @type to: L{JID}
+        form = None
+        for child in element.elements():
+            try:
+                form = data_form.Form.fromElement(child)
+            except data_form.Error:
+                continue
+
+            if form.formNamespace != NS_PUBSUB_NODE_CONFIG:
+                continue
+
+        return form
+
+
+    def _parse_node(self, verbElement):
         """
-        destination = to.full()
-        return xmlstream.IQ.send(self, destination)
+        Parse the required node identifier out of the verbElement.
+        """
+        try:
+            self.nodeIdentifier = verbElement["node"]
+        except KeyError:
+            raise BadRequest('nodeid-required')
+
+
+    def _render_node(self, verbElement):
+        """
+        Render the required node identifier on the verbElement.
+        """
+        if not self.nodeIdentifier:
+            raise Exception("Node identifier is required")
+
+        verbElement['node'] = self.nodeIdentifier
+
+
+    def _parse_nodeOrEmpty(self, verbElement):
+        """
+        Parse the node identifier out of the verbElement. May be empty.
+        """
+        self.nodeIdentifier = verbElement.getAttribute("node", '')
+
+
+    def _render_nodeOrEmpty(self, verbElement):
+        """
+        Render the node identifier on the verbElement. May be empty.
+        """
+        if self.nodeIdentifier:
+            verbElement['node'] = self.nodeIdentifier
+
+
+    def _parse_nodeOrNone(self, verbElement):
+        """
+        Parse the optional node identifier out of the verbElement.
+        """
+        self.nodeIdentifier = verbElement.getAttribute("node")
+
+
+    def _render_nodeOrNone(self, verbElement):
+        """
+        Render the optional node identifier on the verbElement.
+        """
+        if self.nodeIdentifier:
+            verbElement['node'] = self.nodeIdentifier
+
+
+    def _parse_items(self, verbElement):
+        """
+        Parse items out of the verbElement for publish requests.
+        """
+        self.items = []
+        for element in verbElement.elements():
+            if element.uri == NS_PUBSUB and element.name == 'item':
+                self.items.append(element)
+
+
+    def _render_items(self, verbElement):
+        """
+        Render items into the verbElement for publish requests.
+        """
+        if self.items:
+            for item in self.items:
+                verbElement.addChild(item)
+
+
+    def _parse_jid(self, verbElement):
+        """
+        Parse subscriber out of the verbElement for un-/subscribe requests.
+        """
+        try:
+            self.subscriber = jid.internJID(verbElement["jid"])
+        except KeyError:
+            raise BadRequest('jid-required')
+
+
+    def _render_jid(self, verbElement):
+        """
+        Render subscriber into the verbElement for un-/subscribe requests.
+        """
+        verbElement['jid'] = self.subscriber.full()
+
+
+    def _parse_default(self, verbElement):
+        """
+        Parse node type out of a request for the default node configuration.
+        """
+        form = PubSubRequest._findForm(verbElement, NS_PUBSUB_NODE_CONFIG)
+        if form and form.formType == 'submit':
+            values = form.getValues()
+            self.nodeType = values.get('pubsub#node_type', 'leaf')
+        else:
+            self.nodeType = 'leaf'
+
+
+    def _parse_configure(self, verbElement):
+        """
+        Parse options out of a request for setting the node configuration.
+        """
+        form = PubSubRequest._findForm(verbElement, NS_PUBSUB_NODE_CONFIG)
+        if form:
+            if form.formType == 'submit':
+                self.options = form.getValues()
+            elif form.formType == 'cancel':
+                self.options = {}
+            else:
+                raise BadRequest(text="Unexpected form type %r" % form.formType)
+        else:
+            raise BadRequest(text="Missing configuration form")
+
+
+
+    def _parse_itemIdentifiers(self, verbElement):
+        """
+        Parse item identifiers out of items and retract requests.
+        """
+        self.itemIdentifiers = []
+        for element in verbElement.elements():
+            if element.uri == NS_PUBSUB and element.name == 'item':
+                try:
+                    self.itemIdentifiers.append(element["id"])
+                except KeyError:
+                    raise BadRequest()
+
+
+    def _render_itemIdentifiers(self, verbElement):
+        """
+        Render item identifiers into items and retract requests.
+        """
+        if self.itemIdentifiers:
+            for itemIdentifier in self.itemIdentifiers:
+                item = verbElement.addElement('item')
+                item['id'] = itemIdentifier
+
+
+    def _parse_maxItems(self, verbElement):
+        """
+        Parse maximum items out of an items request.
+        """
+        value = verbElement.getAttribute('max_items')
+
+        if value:
+            try:
+                self.maxItems = int(value)
+            except ValueError:
+                raise BadRequest(text="Field max_items requires a positive " +
+                                      "integer value")
+
+
+    def _render_maxItems(self, verbElement):
+        """
+        Parse maximum items into an items request.
+        """
+        if self.maxItems:
+            verbElement['max_items'] = unicode(self.maxItems)
+
+
+    def _parse_options(self, verbElement):
+        form = PubSubRequest._findForm(verbElement, NS_PUBSUB_SUBSCRIBE_OPTIONS)
+        if form:
+            if form.formType == 'submit':
+                self.options = form.getValues()
+            elif form.formType == 'cancel':
+                self.options = {}
+            else:
+                raise BadRequest(text="Unexpected form type %r" % form.formType)
+        else:
+            raise BadRequest(text="Missing options form")
+
+    def parseElement(self, element):
+        """
+        Parse the publish-subscribe verb and parameters out of a request.
+        """
+        generic.Stanza.parseElement(self, element)
+
+        for child in element.pubsub.elements():
+            key = (self.stanzaType, child.uri, child.name)
+            try:
+                verb = self._requestVerbMap[key]
+            except KeyError:
+                continue
+            else:
+                self.verb = verb
+                break
+
+        if not self.verb:
+            raise NotImplementedError()
+
+        for parameter in self._parameters[verb]:
+            getattr(self, '_parse_%s' % parameter)(child)
+
+
+    def send(self, xs):
+        """
+        Send this request to its recipient.
+
+        This renders all of the relevant parameters for this specific
+        requests into an L{xmlstream.IQ}, and invoke its C{send} method.
+        This returns a deferred that fires upon reception of a response. See
+        L{xmlstream.IQ} for details.
+
+        @param xs: The XML stream to send the request on.
+        @type xs: L{xmlstream.XmlStream}
+        @rtype: L{defer.Deferred}.
+        """
+
+        try:
+            (self.stanzaType,
+             childURI,
+             childName) = self._verbRequestMap[self.verb]
+        except KeyError:
+            raise NotImplementedError()
+
+        iq = xmlstream.IQ(xs, self.stanzaType)
+        iq.addElement((childURI, 'pubsub'))
+        verbElement = iq.pubsub.addElement(childName)
+
+        if self.sender:
+            iq['from'] = self.sender.full()
+        if self.recipient:
+            iq['to'] = self.recipient.full()
+
+        for parameter in self._parameters[self.verb]:
+            getattr(self, '_render_%s' % parameter)(verbElement)
+
+        return iq.send()
 
 
 
@@ -336 +633 @@
         @param nodeIdentifier: Optional suggestion for the id of the node.
         @type nodeIdentifier: C{unicode}
         """
-
-
-        request = _PubSubRequest(self.xmlstream, 'create')
-        if nodeIdentifier:
-            request.command['node'] = nodeIdentifier
+        request = PubSubRequest('create')
+        request.recipient = service
+        request.nodeIdentifier = nodeIdentifier
 
         def cb(iq):
             try:
@@ -350 +645 @@
                 new_node = nodeIdentifier
             return new_node
 
-        return request.send(service).addCallback(cb)
+        d = request.send(self.xmlstream)
+        d.addCallback(cb)
+        return d
 
 
     def deleteNode(self, service, nodeIdentifier):
@@ -362 +659 @@
         @param nodeIdentifier: The identifier of the node.
         @type nodeIdentifier: C{unicode}
         """
-        request = _PubSubRequest(self.xmlstream, 'delete', NS_PUBSUB_OWNER)
-        request.command['node'] = nodeIdentifier
-        return request.send(service)
+        request = PubSubRequest('delete')
+        request.recipient = service
+        request.nodeIdentifier = nodeIdentifier
+        return request.send(self.xmlstream)
 
 
     def subscribe(self, service, nodeIdentifier, subscriber):
@@ -379 +677 @@
                            will get notifications of new published items.
         @type subscriber: L{JID}
         """
-        request = _PubSubRequest(self.xmlstream, 'subscribe')
-        if nodeIdentifier:
-            request.command['node'] = nodeIdentifier
-        request.command['jid'] = subscriber.full()
+        request = PubSubRequest('subscribe')
+        request.recipient = service
+        request.nodeIdentifier = nodeIdentifier
+        request.subscriber = subscriber
 
         def cb(iq):
             subscription = iq.pubsub.subscription["subscription"]
@@ -397 +695 @@
                 # yielded a stanza error.
                 return None
 
-        return request.send(service).addCallback(cb)
+        d = request.send(self.xmlstream)
+        d.addCallback(cb)
+        return d
 
 
     def unsubscribe(self, service, nodeIdentifier, subscriber):
@@ -411 +711 @@
         @param subscriber: The entity to unsubscribe from the node.
         @type subscriber: L{JID}
         """
-        request = _PubSubRequest(self.xmlstream, 'unsubscribe')
-        if nodeIdentifier:
-            request.command['node'] = nodeIdentifier
-        request.command['jid'] = subscriber.full()
-        return request.send(service)
+        request = PubSubRequest('unsubscribe')
+        request.recipient = service
+        request.nodeIdentifier = nodeIdentifier
+        request.subscriber = subscriber
+        return request.send(self.xmlstream)
 
 
     def publish(self, service, nodeIdentifier, items=None):
@@ -429 +729 @@
         @param items: Optional list of L{Item}s to publish.
         @type items: C{list}
         """
-        request = _PubSubRequest(self.xmlstream, 'publish')
-        request.command['node'] = nodeIdentifier
-        if items:
-            for item in items:
-                request.command.addChild(item)
-
-        return request.send(service)
+        request = PubSubRequest('publish')
+        request.recipient = service
+        request.nodeIdentifier = nodeIdentifier
+        request.items = items
+        return request.send(self.xmlstream)
 
 
     def items(self, service, nodeIdentifier, maxItems=None):
@@ -449 +747 @@
         @param maxItems: Optional limit on the number of retrieved items.
         @type maxItems: C{int}
         """
-        request = _PubSubRequest(self.xmlstream, 'items', method='get')
-        if nodeIdentifier:
-            request.command['node'] = nodeIdentifier
+        request = PubSubRequest('items')
+        request.recipient = service
+        request.nodeIdentifier = nodeIdentifier
         if maxItems:
-            request.command["max_items"] = str(int(maxItems))
+            request.maxItems = str(int(maxItems))
 
         def cb(iq):
             items = []
@@ -462 +760 @@
                     items.append(element)
             return items
 
-        return request.send(service).addCallback(cb)
+        d = request.send(self.xmlstream)
+        d.addCallback(cb)
+        return d
 
 
 
@@ -497 +797 @@
     implements(IPubSubService)
 
     iqHandlers = {
-            PUBSUB_PUBLISH: '_onPublish',
-            PUBSUB_CREATE: '_onCreate',
-            PUBSUB_SUBSCRIBE: '_onSubscribe',
-            PUBSUB_OPTIONS_GET: '_onOptionsGet',
-            PUBSUB_OPTIONS_SET: '_onOptionsSet',
-            PUBSUB_AFFILIATIONS: '_onAffiliations',
-            PUBSUB_ITEMS: '_onItems',
-            PUBSUB_RETRACT: '_onRetract',
-            PUBSUB_SUBSCRIPTIONS: '_onSubscriptions',
-            PUBSUB_UNSUBSCRIBE: '_onUnsubscribe',
-
-            PUBSUB_AFFILIATIONS_GET: '_onAffiliationsGet',
-            PUBSUB_AFFILIATIONS_SET: '_onAffiliationsSet',
-            PUBSUB_CONFIGURE_GET: '_onConfigureGet',
-            PUBSUB_CONFIGURE_SET: '_onConfigureSet',
-            PUBSUB_DEFAULT: '_onDefault',
-            PUBSUB_PURGE: '_onPurge',
-            PUBSUB_DELETE: '_onDelete',
-            PUBSUB_SUBSCRIPTIONS_GET: '_onSubscriptionsGet',
-            PUBSUB_SUBSCRIPTIONS_SET: '_onSubscriptionsSet',
-
+            '/*': '_onPubSubRequest',
             }
 
 
@@ -530 +810 @@
 
 
     def connectionMade(self):
-        self.xmlstream.addObserver(PUBSUB_GET, self.handleRequest)
-        self.xmlstream.addObserver(PUBSUB_SET, self.handleRequest)
-        self.xmlstream.addObserver(PUBSUB_OWNER_GET, self.handleRequest)
-        self.xmlstream.addObserver(PUBSUB_OWNER_SET, self.handleRequest)
+        self.xmlstream.addObserver(PUBSUB_REQUEST, self.handleRequest)
 
 
     def getDiscoInfo(self, requestor, target, nodeIdentifier):
@@ -585 +862 @@
         return d
 
 
-    def _findForm(self, element, formNamespace):
-        if not element:
-            return None
+    def _onPubSubRequest(self, iq):
+        request = PubSubRequest.fromElement(iq)
+        handler = getattr(self, '_on_%s' % request.verb)
+        return handler(request)
 
-        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
+    def _on_publish(self, request):
+        return self.publish(request.sender, request.recipient,
+                            request.nodeIdentifier, request.items)
 
-        return form
 
-
-    def _getParameter_node(self, commandElement):
-        try:
-            return commandElement["node"]
-        except KeyError:
-            raise BadRequest('nodeid-required')
-
-
-    def _getParameter_nodeOrEmpty(self, commandElement):
-        return commandElement.getAttribute("node", '')
-
-
-    def _getParameter_jid(self, commandElement):
-        try:
-            return jid.internJID(commandElement["jid"])
-        except KeyError:
-            raise BadRequest('jid-required')
-
-
-    def _getParameter_max_items(self, commandElement):
-        value = commandElement.getAttribute('max_items')
-
-        if value:
-            try:
-                return int(value)
-            except ValueError:
-                raise BadRequest(text="Field max_items requires a positive " +
-                                      "integer value")
-        else:
-            return None
-
-
-    def _getParameters(self, iq, *names):
-        requestor = jid.internJID(iq["from"]).userhostJID()
-        service = jid.internJID(iq["to"])
-
-        params = [requestor, service]
-
-        if names:
-            command = names[0]
-            commandElement = getattr(iq.pubsub, command)
-            if not commandElement:
-                raise Exception("Could not find command element %r" % command)
-
-        for name in names[1:]:
-            try:
-                getter = getattr(self, '_getParameter_' + name)
-            except KeyError:
-                raise Exception("No parameter getter for this name")
-
-            params.append(getter(commandElement))
-
-        return params
-
-
-    def _onPublish(self, iq):
-        requestor, service, nodeIdentifier = self._getParameters(
-                iq, 'publish', 'node')
-
-        items = []
-        for element in iq.pubsub.publish.elements():
-            if element.uri == NS_PUBSUB and element.name == 'item':
-                items.append(element)
-
-        return self.publish(requestor, service, nodeIdentifier, items)
-
-
-    def _onSubscribe(self, iq):
-        requestor, service, nodeIdentifier, subscriber = self._getParameters(
-                iq, 'subscribe', 'nodeOrEmpty', 'jid')
+    def _on_subscribe(self, request):
 
         def toResponse(result):
             response = domish.Element((NS_PUBSUB, "pubsub"))
@@ -681 +884 @@
             subscription["subscription"] = result.state
             return response
 
-        d = self.subscribe(requestor, service, nodeIdentifier, subscriber)
+        d = self.subscribe(request.sender, request.recipient,
+                           request.nodeIdentifier, request.subscriber)
         d.addCallback(toResponse)
         return d
 
 
-    def _onUnsubscribe(self, iq):
-        requestor, service, nodeIdentifier, subscriber = self._getParameters(
-                iq, 'unsubscribe', 'nodeOrEmpty', 'jid')
+    def _on_unsubscribe(self, request):
+        return self.unsubscribe(request.sender, request.recipient,
+                                request.nodeIdentifier, request.subscriber)
 
-        return self.unsubscribe(requestor, service, nodeIdentifier, subscriber)
 
-
-    def _onOptionsGet(self, iq):
+    def _on_optionsGet(self, request):
         raise Unsupported('subscription-options')
 
 
-    def _onOptionsSet(self, iq):
+    def _on_optionsSet(self, request):
         raise Unsupported('subscription-options')
 
 
-    def _onSubscriptions(self, iq):
-        requestor, service = self._getParameters(iq)
+    def _on_subscriptions(self, request):
 
         def toResponse(result):
             response = domish.Element((NS_PUBSUB, 'pubsub'))
@@ -714 +915 @@
                 item['subscription'] = subscription.state
             return response
 
-        d = self.subscriptions(requestor, service)
+        d = self.subscriptions(request.sender, request.recipient)
         d.addCallback(toResponse)
         return d
 
 
-    def _onAffiliations(self, iq):
-        requestor, service = self._getParameters(iq)
+    def _on_affiliations(self, request):
 
         def toResponse(result):
             response = domish.Element((NS_PUBSUB, 'pubsub'))
@@ -733 +933 @@
 
             return response
 
-        d = self.affiliations(requestor, service)
+        d = self.affiliations(request.sender, request.recipient)
         d.addCallback(toResponse)
         return d
 
 
-    def _onCreate(self, iq):
-        requestor, service = self._getParameters(iq)
-        nodeIdentifier = iq.pubsub.create.getAttribute("node")
+    def _on_create(self, request):
 
         def toResponse(result):
-            if not nodeIdentifier or nodeIdentifier != result:
+            if not request.nodeIdentifier or request.nodeIdentifier != result:
                 response = domish.Element((NS_PUBSUB, 'pubsub'))
                 create = response.addElement('create')
                 create['node'] = result
@@ -751 +949 @@
             else:
                 return None
 
-        d = self.create(requestor, service, nodeIdentifier)
+        d = self.create(request.sender, request.recipient,
+                        request.nodeIdentifier)
         d.addCallback(toResponse)
         return d
 
@@ -771 +970 @@
             fields.append(data_form.Field.fromDict(option))
         return fields
 
+
     def _formFromConfiguration(self, values):
         options = self.getConfigurationOptions()
         fields = self._makeFields(options, values)
@@ -780 +980 @@
 
         return form
 
+
     def _checkConfiguration(self, values):
         options = self.getConfigurationOptions()
         processedValues = {}
@@ -805 +1006 @@
         return processedValues
 
 
-    def _onDefault(self, iq):
-        requestor, service = self._getParameters(iq)
+    def _on_default(self, request):
 
         def toResponse(options):
             response = domish.Element((NS_PUBSUB_OWNER, "pubsub"))
@@ -814 +1014 @@
             default.addChild(self._formFromConfiguration(options).toElement())
             return response
 
-        form = self._findForm(iq.pubsub.config, NS_PUBSUB_NODE_CONFIG)
-        values = form and form.formType == 'result' and form.getValues() or {}
-        nodeType = values.get('pubsub#node_type', 'leaf')
-
-        if nodeType not in ('leaf', 'collections'):
+        if request.nodeType not in ('leaf', 'collection'):
             return defer.fail(error.StanzaError('not-acceptable'))
 
-        d = self.getDefaultConfiguration(requestor, service, nodeType)
+        d = self.getDefaultConfiguration(request.sender, request.recipient,
+                                         request.nodeType)
         d.addCallback(toResponse)
         return d
 
 
-    def _onConfigureGet(self, iq):
-        requestor, service, nodeIdentifier = self._getParameters(
-                iq, 'configure', 'nodeOrEmpty')
-
+    def _on_configureGet(self, request):
         def toResponse(options):
             response = domish.Element((NS_PUBSUB_OWNER, "pubsub"))
             configure = response.addElement("configure")
-            configure.addChild(self._formFromConfiguration(options).toElement())
+            form = self._formFromConfiguration(options)
+            configure.addChild(form.toElement())
 
-            if nodeIdentifier:
-                configure["node"] = nodeIdentifier
+            if request.nodeIdentifier:
+                configure["node"] = request.nodeIdentifier
 
             return response
 
-        d = self.getConfiguration(requestor, service, nodeIdentifier)
+        d = self.getConfiguration(request.sender, request.recipient,
+                                  request.nodeIdentifier)
         d.addCallback(toResponse)
         return d
 
 
-    def _onConfigureSet(self, iq):
-        requestor, service, nodeIdentifier = self._getParameters(
-                iq, 'configure', 'nodeOrEmpty')
+    def _on_configureSet(self, request):
+        if request.options:
+            request.options = self._checkConfiguration(request.options)
+            return self.setConfiguration(request.sender, request.recipient,
+                                         request.nodeIdentifier,
+                                         request.options)
+        else:
+            return None
 
-        # Search configuration form with correct FORM_TYPE and process it
 
-        form = self._findForm(iq.pubsub.configure, NS_PUBSUB_NODE_CONFIG)
 
-        if form:
-            if form.formType == 'submit':
-                options = self._checkConfiguration(form.getValues())
-
-                return self.setConfiguration(requestor, service,
-                                             nodeIdentifier, options)
-            elif form.formType == 'cancel':
-                return None
-
-        raise BadRequest()
-
-
-    def _onItems(self, iq):
-        requestor, service, nodeIdentifier, maxItems = self._getParameters(
-                iq, 'items', 'nodeOrEmpty', 'max_items')
-
-        itemIdentifiers = []
-        for child in iq.pubsub.items.elements():
-            if child.name == 'item' and child.uri == NS_PUBSUB:
-                try:
-                    itemIdentifiers.append(child["id"])
-                except KeyError:
-                    raise BadRequest()
+    def _on_items(self, request):
 
         def toResponse(result):
             response = domish.Element((NS_PUBSUB, 'pubsub'))
             items = response.addElement('items')
-            if nodeIdentifier:
-                items["node"] = nodeIdentifier
+            items["node"] = request.nodeIdentifier
 
             for item in result:
                 items.addChild(item)
 
             return response
 
-        d = self.items(requestor, service, nodeIdentifier, maxItems,
-                       itemIdentifiers)
+        d = self.items(request.sender, request.recipient,
+                       request.nodeIdentifier, request.maxItems,
+                       request.itemIdentifiers)
         d.addCallback(toResponse)
         return d
 
 
-    def _onRetract(self, iq):
-        requestor, service, nodeIdentifier = self._getParameters(
-                iq, 'retract', 'node')
+    def _on_retract(self, request):
+        return self.retract(request.sender, request.recipient,
+                            request.nodeIdentifier, request.itemIdentifiers)
 
-        itemIdentifiers = []
-        for child in iq.pubsub.retract.elements():
-            if child.uri == NS_PUBSUB and child.name == 'item':
-                try:
-                    itemIdentifiers.append(child["id"])
-                except KeyError:
-                    raise BadRequest()
 
-        return self.retract(requestor, service, nodeIdentifier,
-                            itemIdentifiers)
+    def _on_purge(self, request):
+        return self.purge(request.sender, request.recipient,
+                          request.nodeIdentifier)
 
 
-    def _onPurge(self, iq):
-        requestor, service, nodeIdentifier = self._getParameters(
-                iq, 'purge', 'node')
-        return self.purge(requestor, service, nodeIdentifier)
+    def _on_delete(self, request):
+        return self.delete(request.sender, request.recipient,
+                           request.nodeIdentifier)
 
 
-    def _onDelete(self, iq):
-        requestor, service, nodeIdentifier = self._getParameters(
-                iq, 'delete', 'node')
-        return self.delete(requestor, service, nodeIdentifier)
-
-
-    def _onAffiliationsGet(self, iq):
+    def _on_affiliationsGet(self, iq):
         raise Unsupported('modify-affiliations')
 
 
-    def _onAffiliationsSet(self, iq):
+    def _on_affiliationsSet(self, iq):
         raise Unsupported('modify-affiliations')
 
 
-    def _onSubscriptionsGet(self, iq):
+    def _on_subscriptionsGet(self, iq):
         raise Unsupported('manage-subscriptions')
 
 
-    def _onSubscriptionsSet(self, iq):
+    def _on_subscriptionsSet(self, iq):
         raise Unsupported('manage-subscriptions')
 
     # public methods

wokkel/test/test_pubsub.py

@@ -15 +15 @@
 from twisted.words.protocols.jabber.xmlstream import toResponse
 
 from wokkel import data_form, disco, iwokkel, pubsub, shim
+from wokkel.generic import parseXml
 from wokkel.test.helpers import TestableRequestHandlerMixin, XmlStreamStub
 
 NS_PUBSUB = 'http://jabber.org/protocol/pubsub'
@@ -487 +488 @@
 
 
 
+class PubSubRequestTest(unittest.TestCase):
+
+    def test_fromElementPublish(self):
+        """
+        Test parsing a publish request.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <publish node='test'/>
+          </pubsub>
+        </iq>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual('publish', 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([], request.items)
+
+
+    def test_fromElementPublishItems(self):
+        """
+        Test parsing a publish request with items.
+        """
+
+        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>
+          </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):
+        """
+        A publish request to the root node should raise an exception.
+        """
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <publish/>
+          </pubsub>
+        </iq>
+        """
+
+        err = self.assertRaises(error.StanzaError,
+                                pubsub.PubSubRequest.fromElement,
+                                parseXml(xml))
+        self.assertEqual('bad-request', err.condition)
+        self.assertEqual(NS_PUBSUB_ERRORS, err.appCondition.uri)
+        self.assertEqual('nodeid-required', err.appCondition.name)
+
+
+    def test_fromElementSubscribe(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'/>
+          </pubsub>
+        </iq>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual('subscribe', 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_fromElementSubscribeEmptyNode(self):
+        """
+        Test parsing a subscription request to the root node.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <subscribe jid='user@example.org/Home'/>
+          </pubsub>
+        </iq>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual('', request.nodeIdentifier)
+
+
+    def test_fromElementSubscribeNoJID(self):
+        """
+        Subscribe requests without a JID should raise a bad-request exception.
+        """
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <subscribe node='test'/>
+          </pubsub>
+        </iq>
+        """
+        err = self.assertRaises(error.StanzaError,
+                                pubsub.PubSubRequest.fromElement,
+                                parseXml(xml))
+        self.assertEqual('bad-request', err.condition)
+        self.assertEqual(NS_PUBSUB_ERRORS, err.appCondition.uri)
+        self.assertEqual('jid-required', err.appCondition.name)
+
+    def test_fromElementUnsubscribe(self):
+        """
+        Test parsing an unsubscription request.
+        """
+
+        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'/>
+          </pubsub>
+        </iq>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual('unsubscribe', 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_fromElementUnsubscribeNoJID(self):
+        """
+        Unsubscribe requests without a JID should raise a bad-request exception.
+        """
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <unsubscribe node='test'/>
+          </pubsub>
+        </iq>
+        """
+        err = self.assertRaises(error.StanzaError,
+                                pubsub.PubSubRequest.fromElement,
+                                parseXml(xml))
+        self.assertEqual('bad-request', err.condition)
+        self.assertEqual(NS_PUBSUB_ERRORS, err.appCondition.uri)
+        self.assertEqual('jid-required', err.appCondition.name)
+
+
+    def test_fromElementOptionsGet(self):
+        """
+        Test parsing a request for getting subscription options.
+        """
+
+        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'/>
+          </pubsub>
+        </iq>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual('optionsGet', request.verb)
+
+
+    def test_fromElementOptionsSet(self):
+        """
+        Test parsing a request for 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='submit'>
+                <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>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual('optionsSet', 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)
+        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'>
+                <field var='FORM_TYPE' type='hidden'>
+                  <value>http://jabber.org/protocol/pubsub#node_config</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(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,
+                                parseXml(xml))
+        self.assertEqual('bad-request', err.condition)
+        self.assertEqual(None, err.appCondition)
+
+
+    def test_fromElementSubscriptions(self):
+        """
+        Test parsing a request for all subscriptions.
+        """
+
+        xml = """
+        <iq type='get' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <subscriptions/>
+          </pubsub>
+        </iq>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual('subscriptions', request.verb)
+        self.assertEqual(JID('user@example.org'), request.sender)
+        self.assertEqual(JID('pubsub.example.org'), request.recipient)
+
+
+    def test_fromElementAffiliations(self):
+        """
+        Test parsing a request for all affiliations.
+        """
+
+        xml = """
+        <iq type='get' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <affiliations/>
+          </pubsub>
+        </iq>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual('affiliations', request.verb)
+        self.assertEqual(JID('user@example.org'), request.sender)
+        self.assertEqual(JID('pubsub.example.org'), request.recipient)
+
+
+    def test_fromElementCreate(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'/>
+          </pubsub>
+        </iq>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual('create', request.verb)
+        self.assertEqual(JID('user@example.org'), request.sender)
+        self.assertEqual(JID('pubsub.example.org'), request.recipient)
+        self.assertEqual('mynode', request.nodeIdentifier)
+
+
+    def test_fromElementCreateInstant(self):
+        """
+        Test parsing a request to create an instant node.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <create/>
+          </pubsub>
+        </iq>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertIdentical(None, request.nodeIdentifier)
+
+
+    def test_fromElementDefault(self):
+        """
+        Test parsing a request for the default node configuration.
+        """
+
+        xml = """
+        <iq type='get' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'>
+            <default/>
+          </pubsub>
+        </iq>
+        """
+
+        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)
+
+
+    def test_fromElementDefaultCollection(self):
+        """
+        Parsing a request for the default configuration extracts the 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>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual('collection', request.nodeType)
+
+
+    def test_fromElementConfigureGet(self):
+        """
+        Test parsing a node configuration get request.
+        """
+
+        xml = """
+        <iq type='get' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'>
+            <configure node='test'/>
+          </pubsub>
+        </iq>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual('configureGet', request.verb)
+        self.assertEqual(JID('user@example.org'), request.sender)
+        self.assertEqual(JID('pubsub.example.org'), request.recipient)
+        self.assertEqual('test', request.nodeIdentifier)
+
+
+    def test_fromElementConfigureSet(self):
+        """
+        On a node configuration set request the Data Form is parsed.
+        """
+
+        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>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual('configureSet', 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({'pubsub#deliver_payloads': '0',
+                          'pubsub#persist_items': '1'}, request.options)
+
+
+    def test_fromElementConfigureSetCancel(self):
+        """
+        The node configuration is cancelled, so no options.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'>
+            <configure node='test'>
+              <x xmlns='jabber:x:data' type='cancel'/>
+            </configure>
+          </pubsub>
+        </iq>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual({}, request.options)
+
+
+    def test_fromElementConfigureSetBadFormType(self):
+        """
+        On a node configuration 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#owner'>
+            <configure node='test'>
+              <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#deliver_payloads'><value>0</value></field>
+                <field var='x-myfield'><value>1</value></field>
+              </x>
+            </configure>
+          </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_fromElementConfigureSetNoForm(self):
+        """
+        On a node configuration 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#owner'>
+            <configure node='test'/>
+          </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_fromElementItems(self):
+        """
+        Test parsing an items request.
+        """
+        xml = """
+        <iq type='get' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <items node='test'/>
+          </pubsub>
+        </iq>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual('items', request.verb)
+        self.assertEqual(JID('user@example.org'), request.sender)
+        self.assertEqual(JID('pubsub.example.org'), request.recipient)
+        self.assertEqual('test', request.nodeIdentifier)
+        self.assertIdentical(None, request.maxItems)
+        self.assertEqual([], request.itemIdentifiers)
+
+
+    def test_fromElementRetract(self):
+        """
+        Test parsing a retract request.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <retract node='test'>
+              <item id='item1'/>
+              <item id='item2'/>
+            </retract>
+          </pubsub>
+        </iq>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual('retract', 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(['item1', 'item2'], request.itemIdentifiers)
+
+
+    def test_fromElementPurge(self):
+        """
+        Test parsing a purge request.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'>
+            <purge node='test'/>
+          </pubsub>
+        </iq>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual('purge', request.verb)
+        self.assertEqual(JID('user@example.org'), request.sender)
+        self.assertEqual(JID('pubsub.example.org'), request.recipient)
+        self.assertEqual('test', request.nodeIdentifier)
+
+
+    def test_fromElementDelete(self):
+        """
+        Test parsing a delete request.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'>
+            <delete node='test'/>
+          </pubsub>
+        </iq>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual('delete', request.verb)
+        self.assertEqual(JID('user@example.org'), request.sender)
+        self.assertEqual(JID('pubsub.example.org'), request.recipient)
+        self.assertEqual('test', request.nodeIdentifier)
+
+
+
 class PubSubServiceTest(unittest.TestCase, TestableRequestHandlerMixin):
     """
     Tests for L{pubsub.PubSubService}.
@@ -504 +1129 @@
         verify.verifyObject(iwokkel.IPubSubService, self.service)
 
 
+    def test_connectionMade(self):
+        """
+        Verify setup of observers in L{pubsub.connectionMade}.
+        """
+        requests = []
+
+        def handleRequest(iq):
+            requests.append(iq)
+
+        self.service.xmlstream = self.stub.xmlstream
+        self.service.handleRequest = handleRequest
+        self.service.connectionMade()
+
+        for namespace in (NS_PUBSUB, NS_PUBSUB_OWNER):
+            for stanzaType in ('get', 'set'):
+                iq = domish.Element((None, 'iq'))
+                iq['type'] = stanzaType
+                iq.addElement((namespace, 'pubsub'))
+                self.stub.xmlstream.dispatch(iq)
+
+        self.assertEqual(4, len(requests))
+
+
     def test_getDiscoInfo(self):
         """
         Test getDiscoInfo calls getNodeInfo and returns some minimal info.
@@ -569 +1217 @@
         return d
 
 
-    def test_onPublishNoNode(self):
-        """
-        The root node is always a collection, publishing is a bad request.
-        """
-        xml = """
-        <iq type='set' to='pubsub.example.org'
-                       from='user@example.org'>
-          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
-            <publish/>
-          </pubsub>
-        </iq>
-        """
-
-        def cb(result):
-            self.assertEquals('bad-request', result.condition)
-
-        d = self.handleRequest(xml)
-        self.assertFailure(d, error.StanzaError)
-        d.addCallback(cb)
-        return d
-
-
     def test_onPublish(self):
         """
         A publish request should result in L{PubSubService.publish} being
@@ -607 +1233 @@
         """
 
         def publish(requestor, service, nodeIdentifier, items):
-            self.assertEqual(JID('user@example.org'), requestor)
-            self.assertEqual(JID('pubsub.example.org'), service)
-            self.assertEqual('test', nodeIdentifier)
-            self.assertEqual([], items)
             return defer.succeed(None)
 
         self.service.publish = publish
+        verify.verifyObject(iwokkel.IPubSubService, self.service)
         return self.handleRequest(xml)
 
 
+    def test_onSubscribe(self):
+        """
+        A successful subscription should return the current subscription.
+        """
+
+        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(requestor, service, nodeIdentifier, subscriber):
+            return defer.succeed(pubsub.Subscription(nodeIdentifier,
+                                                     subscriber,
+                                                     'subscribed'))
+
+        def cb(element):
+            self.assertEqual('pubsub', element.name)
+            self.assertEqual(NS_PUBSUB, element.uri)
+            subscription = element.subscription
+            self.assertEqual(NS_PUBSUB, subscription.uri)
+            self.assertEqual('test', subscription['node'])
+            self.assertEqual('user@example.org/Home', subscription['jid'])
+            self.assertEqual('subscribed', subscription['subscription'])
+
+        self.service.subscribe = subscribe
+        verify.verifyObject(iwokkel.IPubSubService, self.service)
+        d = self.handleRequest(xml)
+        d.addCallback(cb)
+        return d
+
+
+    def test_onSubscribeEmptyNode(self):
+        """
+        A successful subscription on root node should return no node attribute.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <subscribe jid='user@example.org/Home'/>
+          </pubsub>
+        </iq>
+        """
+
+        def subscribe(requestor, service, nodeIdentifier, subscriber):
+            return defer.succeed(pubsub.Subscription(nodeIdentifier,
+                                                     subscriber,
+                                                     'subscribed'))
+
+        def cb(element):
+            self.assertFalse(element.subscription.hasAttribute('node'))
+
+        self.service.subscribe = subscribe
+        verify.verifyObject(iwokkel.IPubSubService, self.service)
+        d = self.handleRequest(xml)
+        d.addCallback(cb)
+        return d
+
+
+    def test_onUnsubscribe(self):
+        """
+        A successful unsubscription 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'/>
+          </pubsub>
+        </iq>
+        """
+
+        def unsubscribe(requestor, service, nodeIdentifier, subscriber):
+            return defer.succeed(None)
+
+        def cb(element):
+            self.assertIdentical(None, element)
+
+        self.service.unsubscribe = unsubscribe
+        verify.verifyObject(iwokkel.IPubSubService, self.service)
+        d = self.handleRequest(xml)
+        d.addCallback(cb)
+        return d
+
+
     def test_onOptionsGet(self):
         """
-        Subscription options are not supported.
+        Getting subscription options is not supported.
         """
 
         xml = """
         <iq type='get' to='pubsub.example.org'
                        from='user@example.org'>
           <pubsub xmlns='http://jabber.org/protocol/pubsub'>
-            <options/>
+            <options node='test' jid='user@example.org/Home'/>
+          </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)
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d
+
+
+    def test_onOptionsSet(self):
+        """
+        Setting subscription options is not supported.
+        """
+
+        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='submit'>
+                <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>
         """
@@ -673 +1419 @@
 
 
         def subscriptions(requestor, service):
-            self.assertEqual(JID('user@example.org'), requestor)
-            self.assertEqual(JID('pubsub.example.org'), service)
             subscription = pubsub.Subscription('test', JID('user@example.org'),
                                                'subscribed')
             return defer.succeed([subscription])
 
         self.service.subscriptions = subscriptions
+        verify.verifyObject(iwokkel.IPubSubService, self.service)
+        d = self.handleRequest(xml)
+        d.addCallback(cb)
+        return d
+
+
+    def test_onAffiliations(self):
+        """
+        A subscriptions request should result in
+        L{PubSubService.affiliations} being called and the result prepared
+        for the response.
+        """
+
+        xml = """
+        <iq type='get' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <affiliations/>
+          </pubsub>
+        </iq>
+        """
+
+        def cb(element):
+            self.assertEqual('pubsub', element.name)
+            self.assertEqual(NS_PUBSUB, element.uri)
+            self.assertEqual(NS_PUBSUB, element.affiliations.uri)
+            children = list(element.affiliations.elements())
+            self.assertEqual(1, len(children))
+            affiliation = children[0]
+            self.assertEqual('affiliation', affiliation.name)
+            self.assertEqual(NS_PUBSUB, affiliation.uri)
+            self.assertEqual('test', affiliation['node'])
+            self.assertEqual('owner', affiliation['affiliation'])
+
+
+        def affiliations(requestor, service):
+            affiliation = ('test', 'owner')
+            return defer.succeed([affiliation])
+
+        self.service.affiliations = affiliations
+        verify.verifyObject(iwokkel.IPubSubService, self.service)
+        d = self.handleRequest(xml)
+        d.addCallback(cb)
+        return d
+
+
+    def test_onCreate(self):
+        """
+        Replies to create node requests don't return the created node.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <create node='mynode'/>
+          </pubsub>
+        </iq>
+        """
+
+        def create(requestor, service, nodeIdentifier):
+            return defer.succeed(nodeIdentifier)
+
+        def cb(element):
+            self.assertIdentical(None, element)
+
+        self.service.create = create
+        verify.verifyObject(iwokkel.IPubSubService, self.service)
+        d = self.handleRequest(xml)
+        d.addCallback(cb)
+        return d
+
+
+    def test_onCreateChanged(self):
+        """
+        Replies to create node requests return the created node if changed.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <create node='mynode'/>
+          </pubsub>
+        </iq>
+        """
+
+        def create(requestor, service, nodeIdentifier):
+            return defer.succeed(u'myrenamednode')
+
+        def cb(element):
+            self.assertEqual('pubsub', element.name)
+            self.assertEqual(NS_PUBSUB, element.uri)
+            self.assertEqual(NS_PUBSUB, element.create.uri)
+            self.assertEqual(u'myrenamednode',
+                             element.create.getAttribute('node'))
+
+        self.service.create = create
+        verify.verifyObject(iwokkel.IPubSubService, self.service)
+        d = self.handleRequest(xml)
+        d.addCallback(cb)
+        return d
+
+
+    def test_onCreateInstant(self):
+        """
+        Replies to create instant node requests return the created node.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <create/>
+          </pubsub>
+        </iq>
+        """
+
+        def create(requestor, service, nodeIdentifier):
+            return defer.succeed(u'random')
+
+        def cb(element):
+            self.assertEqual('pubsub', element.name)
+            self.assertEqual(NS_PUBSUB, element.uri)
+            self.assertEqual(NS_PUBSUB, element.create.uri)
+            self.assertEqual(u'random', element.create.getAttribute('node'))
+
+        self.service.create = create
+        verify.verifyObject(iwokkel.IPubSubService, self.service)
         d = self.handleRequest(xml)
         d.addCallback(cb)
         return d
@@ -711 +1584 @@
                 }
 
         def getDefaultConfiguration(requestor, service, nodeType):
-            self.assertEqual(JID('user@example.org'), requestor)
-            self.assertEqual(JID('pubsub.example.org'), service)
-            self.assertEqual('leaf', nodeType)
             return defer.succeed({})
 
         def cb(element):
@@ -731 +1601 @@
         return d
 
 
+    def test_onDefaultCollection(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 getDefaultConfiguration(requestor, service, nodeType):
+            return defer.succeed({})
+
+        self.service.getConfigurationOptions = getConfigurationOptions
+        self.service.getDefaultConfiguration = getDefaultConfiguration
+        verify.verifyObject(iwokkel.IPubSubService, self.service)
+        return self.handleRequest(xml)
+
+
+    def test_onDefaultUnknownNodeType(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>
+              <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>unknown</value>
+                </field>
+              </x>
+            </default>
+
+          </pubsub>
+        </iq>
+        """
+
+        def getDefaultConfiguration(requestor, service, nodeType):
+            self.fail("Unexpected call to getConfiguration")
+
+        def cb(result):
+            self.assertEquals('not-acceptable', result.condition)
+
+        self.service.getDefaultConfiguration = getDefaultConfiguration
+        verify.verifyObject(iwokkel.IPubSubService, self.service)
+        d = self.handleRequest(xml)
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d
+
+
     def test_onConfigureGet(self):
         """
         On a node configuration get request L{PubSubService.getConfiguration}
@@ -760 +1709 @@
                 }
 
         def getConfiguration(requestor, service, nodeIdentifier):
-            self.assertEqual(JID('user@example.org'), requestor)
-            self.assertEqual(JID('pubsub.example.org'), service)
-            self.assertEqual('test', nodeIdentifier)
-
             return defer.succeed({'pubsub#deliver_payloads': '0',
                                   'pubsub#persist_items': '1',
-                                  'pubsub#owner': JID('user@example.org')})
+                                  'pubsub#owner': JID('user@example.org'),
+                                  'x-myfield': ['a', 'b']})
 
         def cb(element):
             self.assertEqual('pubsub', element.name)
@@ -794 +1740 @@
             field.typeCheck()
             self.assertEqual(JID('user@example.org'), field.value)
 
+            self.assertNotIn('x-myfield', fields)
+
+
         self.service.getConfigurationOptions = getConfigurationOptions
         self.service.getConfiguration = getConfiguration
+        verify.verifyObject(iwokkel.IPubSubService, self.service)
         d = self.handleRequest(xml)
         d.addCallback(cb)
         return d
@@ -835 +1785 @@
                 }
 
         def setConfiguration(requestor, service, nodeIdentifier, options):
-            self.assertEqual(JID('user@example.org'), requestor)
-            self.assertEqual(JID('pubsub.example.org'), service)
-            self.assertEqual('test', nodeIdentifier)
             self.assertEqual({'pubsub#deliver_payloads': False,
                               'pubsub#persist_items': True}, options)
             return defer.succeed(None)
 
         self.service.getConfigurationOptions = getConfigurationOptions
         self.service.setConfiguration = setConfiguration
+        verify.verifyObject(iwokkel.IPubSubService, self.service)
         return self.handleRequest(xml)
 
 
@@ -872 +1820 @@
             self.fail("Unexpected call to setConfiguration")
 
         self.service.setConfiguration = setConfiguration
+        verify.verifyObject(iwokkel.IPubSubService, self.service)
         return self.handleRequest(xml)
 
 
@@ -912 +1861 @@
 
         self.service.getConfigurationOptions = getConfigurationOptions
         self.service.setConfiguration = setConfiguration
+        verify.verifyObject(iwokkel.IPubSubService, self.service)
         return self.handleRequest(xml)
 
 
+    def test_onConfigureSetBadFormType(self):
+        """
+        On a node configuration 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#owner'>
+            <configure node='test'>
+              <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#deliver_payloads'><value>0</value></field>
+                <field var='x-myfield'><value>1</value></field>
+              </x>
+            </configure>
+          </pubsub>
+        </iq>
+        """
+
+        def cb(result):
+            self.assertEquals('bad-request', result.condition)
+
+        d = self.handleRequest(xml)
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d
+
+
     def test_onItems(self):
         """
         On a items request, return all items for the given node.
@@ -928 +1909 @@
         </iq>
         """
 
-        def items(requestor, service, nodeIdentifier, maxItems, items):
-            self.assertEqual(JID('user@example.org'), requestor)
-            self.assertEqual(JID('pubsub.example.org'), service)
-            self.assertEqual('test', nodeIdentifier)
-            self.assertIdentical(None, maxItems)
-            self.assertEqual([], items)
+        def items(requestor, service, nodeIdentifier, maxItems,
+                  itemIdentifiers):
             return defer.succeed([pubsub.Item('current')])
 
         def cb(element):
@@ -971 +1948 @@
         """
 
         def retract(requestor, service, nodeIdentifier, itemIdentifiers):
-            self.assertEqual(JID('user@example.org'), requestor)
-            self.assertEqual(JID('pubsub.example.org'), service)
-            self.assertEqual('test', nodeIdentifier)
-            self.assertEqual(['item1', 'item2'], itemIdentifiers)
             return defer.succeed(None)
 
         self.service.retract = retract
@@ -997 +1970 @@
         """
 
         def purge(requestor, service, nodeIdentifier):
-            self.assertEqual(JID('user@example.org'), requestor)
-            self.assertEqual(JID('pubsub.example.org'), service)
-            self.assertEqual('test', nodeIdentifier)
             return defer.succeed(None)
 
         self.service.purge = purge
@@ -1022 +1992 @@
         """
 
         def delete(requestor, service, nodeIdentifier):
-            self.assertEqual(JID('user@example.org'), requestor)
-            self.assertEqual(JID('pubsub.example.org'), service)
-            self.assertEqual('test', nodeIdentifier)
             return defer.succeed(None)
 
         self.service.delete = delete
@@ -1076 +2043 @@
         self.assertEqual(NS_PUBSUB_EVENT, message.event.delete.redirect.uri)
         self.assertTrue(message.event.delete.redirect.hasAttribute('uri'))
         self.assertEqual(redirectURI, message.event.delete.redirect['uri'])
+
+
+    def test_onSubscriptionsGet(self):
+        """
+        Getting subscription options is not supported.
+        """
+
+        xml = """
+        <iq type='get' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'>
+            <subscriptions/>
+          </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('manage-subscriptions',
+                              result.appCondition['feature'])
+
+        d = self.handleRequest(xml)
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d
+
+
+    def test_onSubscriptionsSet(self):
+        """
+        Setting subscription options is not supported.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'>
+            <subscriptions/>
+          </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('manage-subscriptions',
+                              result.appCondition['feature'])
+
+        d = self.handleRequest(xml)
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d
+
+
+    def test_onAffiliationsGet(self):
+        """
+        Getting subscription options is not supported.
+        """
+
+        xml = """
+        <iq type='get' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub#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'])
+
+        d = self.handleRequest(xml)
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d
+
+
+    def test_onAffiliationsSet(self):
+        """
+        Setting subscription options is not supported.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub#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'])
+
+        d = self.handleRequest(xml)
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d
+
+
+    def test_publish(self):
+        """
+        Non-overridden L{PubSubService.publish} yields unsupported error.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <publish node='mynode'/>
+          </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('publish', result.appCondition['feature'])
+
+        d = self.handleRequest(xml)
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d
+
+
+    def test_subscribe(self):
+        """
+        Non-overridden L{PubSubService.subscribe} yields unsupported error.
+        """
+
+        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 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('subscribe', result.appCondition['feature'])
+
+        d = self.handleRequest(xml)
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d
+
+
+    def test_unsubscribe(self):
+        """
+        Non-overridden L{PubSubService.unsubscribe} yields unsupported error.
+        """
+
+        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'/>
+          </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('subscribe', result.appCondition['feature'])
+
+        d = self.handleRequest(xml)
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d
+
+
+    def test_subscriptions(self):
+        """
+        Non-overridden L{PubSubService.subscriptions} yields unsupported error.
+        """
+
+        xml = """
+        <iq type='get' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <subscriptions/>
+          </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('retrieve-subscriptions',
+                              result.appCondition['feature'])
+
+        d = self.handleRequest(xml)
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d
+
+
+    def test_affiliations(self):
+        """
+        Non-overridden L{PubSubService.affiliations} yields unsupported error.
+        """
+
+        xml = """
+        <iq type='get' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <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('retrieve-affiliations',
+                              result.appCondition['feature'])
+
+        d = self.handleRequest(xml)
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d
+
+
+    def test_create(self):
+        """
+        Non-overridden L{PubSubService.create} yields unsupported error.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <create node='mynode'/>
+          </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('create-nodes', result.appCondition['feature'])
+
+        d = self.handleRequest(xml)
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d
+
+
+    def test_getDefaultConfiguration(self):
+        """
+        Non-overridden L{PubSubService.getDefaultConfiguration} yields
+        unsupported error.
+        """
+
+        xml = """
+        <iq type='get' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'>
+            <default/>
+          </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('retrieve-default', result.appCondition['feature'])
+
+        d = self.handleRequest(xml)
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d
+
+
+    def test_getConfiguration(self):
+        """
+        Non-overridden L{PubSubService.getConfiguration} yields unsupported
+        error.
+        """
+
+        xml = """
+        <iq type='get' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'>
+            <configure/>
+          </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('config-node', result.appCondition['feature'])
+
+        d = self.handleRequest(xml)
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d
+
+
+    def test_setConfiguration(self):
+        """
+        Non-overridden L{PubSubService.setConfiguration} yields unsupported
+        error.
+        """
+
+        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 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('config-node', result.appCondition['feature'])
+
+        d = self.handleRequest(xml)
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d
+
+
+    def test_items(self):
+        """
+        Non-overridden L{PubSubService.items} yields unsupported error.
+        """
+        xml = """
+        <iq type='get' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <items 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)
+            self.assertEquals('retrieve-items', result.appCondition['feature'])
+
+        d = self.handleRequest(xml)
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d
+
+
+    def test_retract(self):
+        """
+        Non-overridden L{PubSubService.retract} yields unsupported error.
+        """
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <retract node='test'>
+              <item id='item1'/>
+              <item id='item2'/>
+            </retract>
+          </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('retract-items', result.appCondition['feature'])
+
+        d = self.handleRequest(xml)
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d
+
+
+    def test_purge(self):
+        """
+        Non-overridden L{PubSubService.purge} yields unsupported error.
+        """
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'>
+            <purge 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)
+            self.assertEquals('purge-nodes', result.appCondition['feature'])
+
+        d = self.handleRequest(xml)
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d
+
+
+    def test_delete(self):
+        """
+        Non-overridden L{PubSubService.delete} yields unsupported error.
+        """
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'>
+            <delete 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)
+            self.assertEquals('delete-nodes', result.appCondition['feature'])
+
+        d = self.handleRequest(xml)
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d