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

wokkel/iwokkel.py

@@ -278 +278 @@
                              C{list} of L{domish.Element})
         """
 
+
     def notifyDelete(service, nodeIdentifier, subscribers,
                      redirectURI=None):
         """
@@ -526 +527 @@
         @param nodeIdentifier: The identifier of the node to be delete.
         @type nodeIdentifier: C{unicode}
         """
+
+
+
+class IPubSubResource(Interface):
+
+    def locateResource(request):
+        """
+        Locate a resource that will handle the request.
+
+        @param request: The publish-subscribe request.
+        @type request: L{wokkel.pubsub.PubSubRequest}
+        """
+
+
+    def getInfo(requestor, service, nodeIdentifier):
+        """
+        Get node type and meta data.
+
+        @param requestor: The entity the request originated from.
+        @type requestor: L{jid.JID}
+        @param service: The publish-subscribe service entity.
+        @type service: L{jid.JID}
+        @param nodeIdentifier: Identifier of the node to request the info for.
+        @type nodeIdentifier: L{unicode}
+        @return: A deferred that fires with a dictionary. If not empty,
+                 it must have the keys C{'type'} and C{'meta-data'} to keep
+                 respectively the node type and a dictionary with the meta
+                 data for that node.
+        @rtype: L{defer.Deferred}
+        """
+
+
+    def getNodes(requestor, service, nodeIdentifier):
+        """
+        Get all nodes contained by this node.
+
+        @param requestor: The entity the request originated from.
+        @type requestor: L{jid.JID}
+        @param service: The publish-subscribe service entity.
+        @type service: L{jid.JID}
+        @param nodeIdentifier: Identifier of the node to request the childs for.
+        @type nodeIdentifier: L{unicode}
+        @return: A deferred that fires with a list of child node identifiers.
+        @rtype: L{defer.Deferred}
+        """
+
+
+    def getConfigurationOptions():
+        """
+        Retrieve all known node configuration options.
+
+        The returned dictionary holds the possible node configuration options
+        by option name. The value of each entry represents the specifics for
+        that option in a dictionary:
+
+         - C{'type'} (C{str}): The option's type (see
+           L{Field<wokkel.data_form.Field>}'s doc string for possible values).
+         - C{'label'} (C{unicode}): A human readable label for this option.
+         - C{'options'} (C{dict}): Optional list of possible values for this
+           option.
+
+        Example::
+
+            {
+            "pubsub#persist_items":
+                {"type": "boolean",
+                 "label": "Persist items to storage"},
+            "pubsub#deliver_payloads":
+                {"type": "boolean",
+                 "label": "Deliver payloads with event notifications"},
+            "pubsub#send_last_published_item":
+                {"type": "list-single",
+                 "label": "When to send the last published item",
+                 "options": {
+                     "never": "Never",
+                     "on_sub": "When a new subscription is processed"}
+                }
+            }
+
+        @rtype: C{dict}.
+        """
+
+
+    def publish(request):
+        """
+        Called when a publish request has been received.
+
+        @param request: The publish-subscribe request.
+        @type request: L{wokkel.pubsub.PubSubRequest}
+        @return: deferred that fires on success.
+        @rtype: L{defer.Deferred}
+        """
+
+
+    def subscribe(request):
+        """
+        Called when a subscribe request has been received.
+
+        @param request: The publish-subscribe request.
+        @type request: L{wokkel.pubsub.PubSubRequest}
+        @return: A deferred that fires with a
+                 L{Subscription<wokkel.pubsub.Subscription>}.
+        @rtype: L{defer.Deferred}
+        """
+
+
+    def unsubscribe(request):
+        """
+        Called when a subscribe request has been received.
+
+        @param request: The publish-subscribe request.
+        @type request: L{wokkel.pubsub.PubSubRequest}
+        @return: A deferred that fires with C{None} when unsubscription has
+                 succeeded.
+        @rtype: L{defer.Deferred}
+        """
+
+
+    def subscriptions(request):
+        """
+        Called when a subscriptions retrieval request has been received.
+
+        @param request: The publish-subscribe request.
+        @type request: L{wokkel.pubsub.PubSubRequest}
+        @return: A deferred that fires with a C{list} of subscriptions as
+                 L{Subscription<wokkel.pubsub.Subscription>}.
+        @rtype: L{defer.Deferred}
+        """
+
+
+    def affiliations(request):
+        """
+        Called when a affiliations retrieval request has been received.
+
+        @param request: The publish-subscribe request.
+        @type request: L{wokkel.pubsub.PubSubRequest}
+        @return: A deferred that fires with a C{list} of affiliations as
+                 C{tuple}s of (node identifier as C{unicode}, affiliation state
+                 as C{str}). The affiliation can be C{'owner'}, C{'publisher'},
+                 or C{'outcast'}.
+        @rtype: L{defer.Deferred}
+        """
+
+
+    def create(request):
+        """
+        Called when a node creation request has been received.
+
+        @param request: The publish-subscribe request.
+        @type request: L{wokkel.pubsub.PubSubRequest}
+        @return: A deferred that fires with a C{unicode} that represents
+                 the identifier of the new node.
+        @rtype: L{defer.Deferred}
+        """
+
+
+    def default(request):
+        """
+        Called when a default node configuration request has been received.
+
+        @param request: The publish-subscribe request.
+        @type request: L{wokkel.pubsub.PubSubRequest}
+        @return: A deferred that fires with a C{dict} representing the default
+                 node configuration. Keys are C{str}s that represent the
+                 field name. Values can be of types C{unicode}, C{int} or
+                 C{bool}.
+        @rtype: L{defer.Deferred}
+        """
+
+
+    def configureGet(request):
+        """
+        Called when a node configuration retrieval request has been received.
+
+        @param request: The publish-subscribe request.
+        @type request: L{wokkel.pubsub.PubSubRequest}
+        @return: A deferred that fires with a C{dict} representing the node
+                 configuration. Keys are C{str}s that represent the field name.
+                 Values can be of types C{unicode}, C{int} or C{bool}.
+        @rtype: L{defer.Deferred}
+        """
+
+
+    def configureSet(request):
+        """
+        Called when a node configuration change request has been received.
+
+        @param request: The publish-subscribe request.
+        @type request: L{wokkel.pubsub.PubSubRequest}
+        @return: A deferred that fires with C{None} when the node's
+                 configuration has been changed.
+        @rtype: L{defer.Deferred}
+        """
+
+
+    def items(request):
+        """
+        Called when a items retrieval request has been received.
+
+        @param request: The publish-subscribe request.
+        @type request: L{wokkel.pubsub.PubSubRequest}
+        @return: A deferred that fires with a C{list} of L{pubsub.Item}.
+        @rtype: L{defer.Deferred}
+        """
+
+
+    def retract(request):
+        """
+        Called when a item retraction request has been received.
+
+        @param request: The publish-subscribe request.
+        @type request: L{wokkel.pubsub.PubSubRequest}
+        @return: A deferred that fires with C{None} when the given items have
+                 been retracted.
+        @rtype: L{defer.Deferred}
+        """
+
+
+    def purge(request):
+        """
+        Called when a node purge request has been received.
+
+        @param request: The publish-subscribe request.
+        @type request: L{wokkel.pubsub.PubSubRequest}
+        @return: A deferred that fires with C{None} when the node has been
+                 purged.
+        @rtype: L{defer.Deferred}
+        """
+
+
+    def delete(request):
+        """
+        Called when a node deletion request has been received.
+
+        @param request: The publish-subscribe request.
+        @type request: L{wokkel.pubsub.PubSubRequest}
+        @return: A deferred that fires with C{None} when the node has been
+                 deleted.
+        @rtype: L{defer.Deferred}
+        """

wokkel/pubsub.py

@@ -13 +13 @@
 from zope.interface import implements
 
 from twisted.internet import defer
+from twisted.python import log
 from twisted.words.protocols.jabber import jid, error, xmlstream
 from twisted.words.xish import domish
 
 from wokkel import disco, data_form, generic, shim
 from wokkel.subprotocols import IQHandlerMixin, XMPPHandler
-from wokkel.iwokkel import IPubSubClient, IPubSubService
+from wokkel.iwokkel import IPubSubClient, IPubSubService, IPubSubResource
 
 # Iq get and set XPath queries
 IQ_GET = '/iq[@type="get"]'
@@ -84 +85 @@
 
 class Unsupported(PubSubError):
     def __init__(self, feature, text=None):
+        self.feature = feature
         PubSubError.__init__(self, 'feature-not-implemented',
                                    'unsupported',
                                    feature,
                                    text)
 
+    def __str__(self):
+        message = PubSubError.__str__(self)
+        message += ', feature %r' % self.feature
+        return message
 
 
 class Subscription(object):
@@ -235 +241 @@
         'retract': ['node', 'itemIdentifiers'],
         'purge': ['node'],
         'delete': ['node'],
-        'affiliationsGet': [],
+        'affiliationsGet': ['nodeOrEmpty'],
         'affiliationsSet': [],
-        'subscriptionsGet': [],
+        'subscriptionsGet': ['nodeOrEmpty'],
         'subscriptionsSet': [],
     }
 
@@ -806 +812 @@
             '/*': '_onPubSubRequest',
             }
 
+    _legacyHandlers = {
+        'publish': ('publish', ['sender', 'recipient',
+                                'nodeIdentifier', 'items']),
+        'subscribe': ('subscribe', ['sender', 'recipient',
+                                    'nodeIdentifier', 'subscriber']),
+        'unsubscribe': ('unsubscribe', ['sender', 'recipient',
+                                        'nodeIdentifier', 'subscriber']),
+        'subscriptions': ('subscriptions', ['sender', 'recipient']),
+        'affiliations': ('affiliations', ['sender', 'recipient']),
+        'create': ('create', ['sender', 'recipient', 'nodeIdentifier']),
+        'getConfigurationOptions': ('getConfigurationOptions', []),
+        'default': ('getDefaultConfiguration',
+                    ['sender', 'recipient', 'nodeType']),
+        'configureGet': ('getConfiguration', ['sender', 'recipient',
+                                              'nodeIdentifier']),
+        'configureSet': ('setConfiguration', ['sender', 'recipient',
+                                              'nodeIdentifier', 'options']),
+        'items': ('items', ['sender', 'recipient', 'nodeIdentifier',
+                            'maxItems', 'itemIdentifiers']),
+        'retract': ('retract', ['sender', 'recipient', 'nodeIdentifier',
+                                'itemIdentifiers']),
+        'purge': ('purge', ['sender', 'recipient', 'nodeIdentifier']),
+        'delete': ('delete', ['sender', 'recipient', 'nodeIdentifier']),
+    }
 
-    def __init__(self):
+    hideNodes = False
+
+    def __init__(self, resource=None):
+        self.resource = resource
         self.discoIdentity = {'category': 'pubsub',
                               'type': 'generic',
                               'name': 'Generic Publish-Subscribe Service'}
@@ -820 +853 @@
 
 
     def getDiscoInfo(self, requestor, target, nodeIdentifier):
-        info = []
-
-        if not nodeIdentifier:
-            category, idType, name = self.discoIdentity
-            info.append(disco.DiscoIdentity(category, idType, name))
-
-            info.append(disco.DiscoFeature(disco.NS_DISCO_ITEMS))
-            info.extend([disco.DiscoFeature("%s#%s" % (NS_PUBSUB, feature))
-                         for feature in self.pubSubFeatures])
-
-        def toInfo(nodeInfo):
+        def toInfo(nodeInfo, info):
             if not nodeInfo:
-                return
+                return info
 
             (nodeType, metaData) = nodeInfo['type'], nodeInfo['meta-data']
             info.append(disco.DiscoIdentity('pubsub', nodeType))
@@ -852 +875 @@
 
                 info.append(form)
 
-        d = self.getNodeInfo(requestor, target, nodeIdentifier or '')
-        d.addCallback(toInfo)
-        d.addBoth(lambda result: info)
+            return info
+
+        info = []
+
+        request = PubSubRequest('discoInfo')
+
+        if self.resource is not None:
+            resource = self.resource.locateResource(request)
+            identity = resource.discoIdentity
+            features = resource.features
+            getInfo = resource.getInfo
+        else:
+            category, idType, name = self.discoIdentity
+            identity = disco.DiscoIdentity(category, idType, name)
+            features = self.pubSubFeatures
+            getInfo = self.getNodeInfo
+
+        if not nodeIdentifier:
+            info.append(identity)
+            info.append(disco.DiscoFeature(disco.NS_DISCO_ITEMS))
+            info.extend([disco.DiscoFeature("%s#%s" % (NS_PUBSUB, feature))
+                         for feature in features])
+
+        d = getInfo(requestor, target, nodeIdentifier or '')
+        d.addCallback(toInfo, info)
+        d.addErrback(log.err)
         return d
 
 
     def getDiscoItems(self, requestor, target, nodeIdentifier):
-        if nodeIdentifier or self.hideNodes:
-            return defer.succeed([])
+        if self.hideNodes:
+            d = defer.succeed([])
+        elif self.resource is not None:
+            request = PubSubRequest('discoInfo')
+            resource = self.resource.locateResource(request)
+            d = resource.getNodes(requestor, target, nodeIdentifier)
+        elif nodeIdentifier:
+            d = self.getNodes(requestor, target)
+        else:
+            d = defer.succeed([])
+            
 
-        d = self.getNodes(requestor, target)
+
         d.addCallback(lambda nodes: [disco.DiscoItem(target, node)
                                      for node in nodes])
         return d
@@ -870 +925 @@
 
     def _onPubSubRequest(self, iq):
         request = PubSubRequest.fromElement(iq)
-        handler = getattr(self, '_on_%s' % request.verb)
-        return handler(request)
 
+        if self.resource is not None:
+            resource = self.resource.locateResource(request)
+        else:
+            resource = self
 
-    def _on_publish(self, request):
-        return self.publish(request.sender, request.recipient,
-                            request.nodeIdentifier, request.items)
+        # Preprocess the request, knowing the handling resource
+        try:
+            preProcessor = getattr(self, '_preProcess_%s' % request.verb)
+        except AttributeError:
+            pass
+        else:
+            request = preProcessor(resource, request)
+            if request is None:
+                return defer.succeed(None)
 
+        # Process the request itself, 
+        if resource is not self:
+            try:
+                handler = getattr(resource, request.verb)
+            except AttributeError:
+                # fix lookup feature
+                text = "Request verb: %s" % request.verb
+                return defer.fail(Unsupported('', text))
 
-    def _on_subscribe(self, request):
+            d = handler(request)
+        else:
+            handlerName, argNames = self._legacyHandlers[request.verb]
+            handler = getattr(self, handlerName)
+            args = [getattr(request, arg) for arg in argNames]
+            d = handler(*args)
 
-        def toResponse(result):
-            response = domish.Element((NS_PUBSUB, "pubsub"))
-            subscription = response.addElement("subscription")
-            if result.nodeIdentifier:
-                subscription["node"] = result.nodeIdentifier
-            subscription["jid"] = result.subscriber.full()
-            subscription["subscription"] = result.state
-            return response
+        # If needed, translate the result into a response
+        try:
+            cb = getattr(self, '_toResponse_%s' % request.verb)
+        except AttributeError:
+            pass
+        else:
+            d.addCallback(cb, resource, request)
 
-        d = self.subscribe(request.sender, request.recipient,
-                           request.nodeIdentifier, request.subscriber)
-        d.addCallback(toResponse)
         return d
 
 
-    def _on_unsubscribe(self, request):
-        return self.unsubscribe(request.sender, request.recipient,
-                                request.nodeIdentifier, request.subscriber)
+    def _toResponse_subscribe(self, result, resource, request):
+        response = domish.Element((NS_PUBSUB, "pubsub"))
+        subscription = response.addElement("subscription")
+        if result.nodeIdentifier:
+            subscription["node"] = result.nodeIdentifier
+        subscription["jid"] = result.subscriber.full()
+        subscription["subscription"] = result.state
+        return response
 
 
-    def _on_optionsGet(self, request):
-        raise Unsupported('subscription-options')
+    def _toResponse_subscriptions(self, result, resource, request):
+        response = domish.Element((NS_PUBSUB, 'pubsub'))
+        subscriptions = response.addElement('subscriptions')
+        for subscription in result:
+            item = subscriptions.addElement('subscription')
+            item['node'] = subscription.nodeIdentifier
+            item['jid'] = subscription.subscriber.full()
+            item['subscription'] = subscription.state
+        return response
 
 
-    def _on_optionsSet(self, request):
-        raise Unsupported('subscription-options')
+    def _toResponse_affiliations(self, result, resource, request):
+        response = domish.Element((NS_PUBSUB, 'pubsub'))
+        affiliations = response.addElement('affiliations')
 
+        for nodeIdentifier, affiliation in result:
+            item = affiliations.addElement('affiliation')
+            item['node'] = nodeIdentifier
+            item['affiliation'] = affiliation
 
-    def _on_subscriptions(self, request):
+        return response
 
-        def toResponse(result):
+
+    def _toResponse_create(self, result, resource, request):
+        if not request.nodeIdentifier or request.nodeIdentifier != result:
             response = domish.Element((NS_PUBSUB, 'pubsub'))
-            subscriptions = response.addElement('subscriptions')
-            for subscription in result:
-                item = subscriptions.addElement('subscription')
-                item['node'] = subscription.nodeIdentifier
-                item['jid'] = subscription.subscriber.full()
-                item['subscription'] = subscription.state
+            create = response.addElement('create')
+            create['node'] = result
             return response
-
-        d = self.subscriptions(request.sender, request.recipient)
-        d.addCallback(toResponse)
-        return d
-
-
-    def _on_affiliations(self, request):
-
-        def toResponse(result):
-            response = domish.Element((NS_PUBSUB, 'pubsub'))
-            affiliations = response.addElement('affiliations')
-
-            for nodeIdentifier, affiliation in result:
-                item = affiliations.addElement('affiliation')
-                item['node'] = nodeIdentifier
-                item['affiliation'] = affiliation
-
-            return response
-
-        d = self.affiliations(request.sender, request.recipient)
-        d.addCallback(toResponse)
-        return d
-
-
-    def _on_create(self, request):
-
-        def toResponse(result):
-            if not request.nodeIdentifier or request.nodeIdentifier != result:
-                response = domish.Element((NS_PUBSUB, 'pubsub'))
-                create = response.addElement('create')
-                create['node'] = result
-                return response
-            else:
-                return None
-
-        d = self.create(request.sender, request.recipient,
-                        request.nodeIdentifier)
-        d.addCallback(toResponse)
-        return d
+        else:
+            return None
 
 
     def _makeFields(self, options, values):
@@ -977 +1027 @@
         return fields
 
 
-    def _formFromConfiguration(self, values):
-        options = self.getConfigurationOptions()
+    def _formFromConfiguration(self, resource, values):
+        options = resource.getConfigurationOptions()
         fields = self._makeFields(options, values)
         form = data_form.Form(formType="form",
                               formNamespace=NS_PUBSUB_NODE_CONFIG,
@@ -987 +1037 @@
         return form
 
 
-    def _checkConfiguration(self, values):
-        options = self.getConfigurationOptions()
+    def _checkConfiguration(self, resource, values):
+        options = resource.getConfigurationOptions()
         processedValues = {}
 
         for key, value in values.iteritems():
@@ -1012 +1062 @@
         return processedValues
 
 
-    def _on_default(self, request):
+    def _preProcess_default(self, resource, request):
+        if request.nodeType not in ('leaf', 'collection'):
+            raise error.StanzaError('not-acceptable')
+        else:
+            return request
 
-        def toResponse(options):
-            response = domish.Element((NS_PUBSUB_OWNER, "pubsub"))
-            default = response.addElement("default")
-            default.addChild(self._formFromConfiguration(options).toElement())
-            return response
 
-        if request.nodeType not in ('leaf', 'collection'):
-            return defer.fail(error.StanzaError('not-acceptable'))
+    def _toResponse_default(self, options, resource, request):
+        response = domish.Element((NS_PUBSUB_OWNER, "pubsub"))
+        default = response.addElement("default")
+        form = self._formFromConfiguration(resource, options)
+        default.addChild(form.toElement())
+        return response
 
-        d = self.getDefaultConfiguration(request.sender, request.recipient,
-                                         request.nodeType)
-        d.addCallback(toResponse)
-        return d
 
+    def _toResponse_configureGet(self, options, resource, request):
+        response = domish.Element((NS_PUBSUB_OWNER, "pubsub"))
+        configure = response.addElement("configure")
+        form = self._formFromConfiguration(resource, options)
+        configure.addChild(form.toElement())
 
-    def _on_configureGet(self, request):
-        def toResponse(options):
-            response = domish.Element((NS_PUBSUB_OWNER, "pubsub"))
-            configure = response.addElement("configure")
-            form = self._formFromConfiguration(options)
-            configure.addChild(form.toElement())
+        if request.nodeIdentifier:
+            configure["node"] = request.nodeIdentifier
 
-            if request.nodeIdentifier:
-                configure["node"] = request.nodeIdentifier
+        return response
 
-            return response
 
-        d = self.getConfiguration(request.sender, request.recipient,
-                                  request.nodeIdentifier)
-        d.addCallback(toResponse)
-        return d
-
-
-    def _on_configureSet(self, request):
+    def _preProcess_configureSet(self, resource, request):
         if request.options:
-            request.options = self._checkConfiguration(request.options)
-            return self.setConfiguration(request.sender, request.recipient,
-                                         request.nodeIdentifier,
-                                         request.options)
+            request.options = self._checkConfiguration(resource,
+                                                       request.options)
+            return request
         else:
             return None
 
 
+    def _toResponse_items(self, result, resource, request):
+        response = domish.Element((NS_PUBSUB, 'pubsub'))
+        items = response.addElement('items')
+        items["node"] = request.nodeIdentifier
 
-    def _on_items(self, request):
+        for item in result:
+            items.addChild(item)
 
-        def toResponse(result):
-            response = domish.Element((NS_PUBSUB, 'pubsub'))
-            items = response.addElement('items')
-            items["node"] = request.nodeIdentifier
+        return response
 
-            for item in result:
-                items.addChild(item)
-
-            return response
-
-        d = self.items(request.sender, request.recipient,
-                       request.nodeIdentifier, request.maxItems,
-                       request.itemIdentifiers)
-        d.addCallback(toResponse)
-        return d
-
-
-    def _on_retract(self, request):
-        return self.retract(request.sender, request.recipient,
-                            request.nodeIdentifier, request.itemIdentifiers)
-
-
-    def _on_purge(self, request):
-        return self.purge(request.sender, request.recipient,
-                          request.nodeIdentifier)
-
-
-    def _on_delete(self, request):
-        return self.delete(request.sender, request.recipient,
-                           request.nodeIdentifier)
-
-
-    def _on_affiliationsGet(self, iq):
-        raise Unsupported('modify-affiliations')
-
-
-    def _on_affiliationsSet(self, iq):
-        raise Unsupported('modify-affiliations')
-
-
-    def _on_subscriptionsGet(self, iq):
-        raise Unsupported('manage-subscriptions')
-
-
-    def _on_subscriptionsSet(self, iq):
-        raise Unsupported('manage-subscriptions')
-
-    # public methods
 
     def _createNotification(self, eventType, service, nodeIdentifier,
                                   subscriber, subscriptions=None):
@@ -1131 +1131 @@
 
         return message
 
+    # public methods
+
     def notifyPublish(self, service, nodeIdentifier, notifications):
         for subscriber, subscriptions, items in notifications:
             message = self._createNotification('items', service,
@@ -1215 +1217 @@
 
     def delete(self, requestor, service, nodeIdentifier):
         raise Unsupported('delete-nodes')
+
+
+
+class PubSubResource(object):
+
+    implements(IPubSubResource)
+
+    features = []
+    discoIdentity = disco.DiscoIdentity('pubsub',
+                                        'service',
+                                        'Publish-Subscribe Service')
+
+
+    def locateResource(self, request):
+        return self
+
+
+    def getInfo(self, requestor, service, nodeIdentifier):
+        return defer.succeed(None)
+
+
+    def getNodes(self, requestor, service, nodeIdentifier):
+        return defer.succeed([])
+
+
+    def getConfigurationOptions(self):
+        return {}
+
+
+    def publish(self, request):
+        return defer.fail(Unsupported('publish'))
+
+
+    def subscribe(self, request):
+        return defer.fail(Unsupported('subscribe'))
+
+
+    def unsubscribe(self, request):
+        return defer.fail(Unsupported('subscribe'))
+
+
+    def subscriptions(self, request):
+        return defer.fail(Unsupported('retrieve-subscriptions'))
+
+
+    def affiliations(self, request):
+        return defer.fail(Unsupported('retrieve-affiliations'))
+
+
+    def create(self, request):
+        return defer.fail(Unsupported('create-nodes'))
+
+
+    def default(self, request):
+        return defer.fail(Unsupported('retrieve-default'))
+
+
+    def configureGet(self, request):
+        return defer.fail(Unsupported('config-node'))
+
+
+    def configureSet(self, request):
+        return defer.fail(Unsupported('config-node'))
+
+
+    def items(self, request):
+        return defer.fail(Unsupported('retrieve-items'))
+
+
+    def retract(self, request):
+        return defer.fail(Unsupported('retract-items'))
+
+
+    def purge(self, request):
+        return defer.fail(Unsupported('purge-nodes'))
+
+
+    def delete(self, request):
+        return defer.fail(Unsupported('delete-nodes'))
+
+
+    def affiliationsGet(self, request):
+        return defer.fail(Unsupported('modify-affiliations'))
+
+
+    def affiliationsSet(self, request):
+        return defer.fail(Unsupported('modify-affiliations'))
+
+
+    def subscriptionsGet(self, request):
+        return defer.fail(Unsupported('manage-subscriptions'))
+
+
+    def subscriptionsSet(self, request):
+        return defer.fail(Unsupported('manage-subscriptions'))

wokkel/test/test_pubsub.py

@@ -1222 +1222 @@
 
     def setUp(self):
         self.stub = XmlStreamStub()
-        self.service = pubsub.PubSubService()
+        self.resource = pubsub.PubSubResource()
+        self.service = pubsub.PubSubService(self.resource)
         self.service.send = self.stub.xmlstream.send
 
     def test_interface(self):
@@ -1260 +1261 @@
         Test getDiscoInfo calls getNodeInfo and returns some minimal info.
         """
         def cb(info):
-            self.assertEqual(2, len(info))
+            discoInfo = disco.DiscoInfo()
+            for item in info:
+                discoInfo.append(item)
+            self.assertIn(('pubsub', 'service'), discoInfo.identities)
+            self.assertIn(disco.NS_DISCO_ITEMS, discoInfo.features)
 
-        def getNodeInfo(requestor, target, nodeIdentifier):
-            return defer.succeed(None)
-
-        self.service.getNodeInfo = getNodeInfo
         d = self.service.getDiscoInfo(JID('user@example.org/home'),
                                       JID('pubsub.example.org'), '')
         d.addCallback(cb)
@@ -1282 +1283 @@
                 discoInfo.append(item)
             self.assertIn(('pubsub', 'collection'), discoInfo.identities)
 
-        def getNodeInfo(requestor, target, nodeIdentifier):
+        def getInfo(requestor, target, nodeIdentifier):
             return defer.succeed({'type': 'collection',
                                   'meta-data': {}})
 
-        self.service.getNodeInfo = getNodeInfo
+        self.resource.getInfo = getInfo
         d = self.service.getDiscoInfo(JID('user@example.org/home'),
                                       JID('pubsub.example.org'), '')
         d.addCallback(cb)
@@ -1307 +1308 @@
             form = discoInfo.extensions[NS_PUBSUB_META_DATA]
             self.assertIn('pubsub#node_type', form.fields)
 
-        def getNodeInfo(requestor, target, nodeIdentifier):
+        def getInfo(requestor, target, nodeIdentifier):
             metaData = [{'var': 'pubsub#persist_items',
                          'label': 'Persist items to storage',
                          'value': True}]
             return defer.succeed({'type': 'leaf', 'meta-data': metaData})
 
-        self.service.getNodeInfo = getNodeInfo
+        self.resource.getInfo = getInfo
         d = self.service.getDiscoInfo(JID('user@example.org/home'),
                                       JID('pubsub.example.org'), '')
         d.addCallback(cb)
         return d
 
 
-    def test_onPublish(self):
+    def test_getDiscoInfoResourceFeatures(self):
+        """
+        Test getDiscoInfo with the resource features.
+        """
+        def cb(info):
+            discoInfo = disco.DiscoInfo()
+            for item in info:
+                discoInfo.append(item)
+            self.assertIn('http://jabber.org/protocol/pubsub#publish',
+                          discoInfo.features)
+
+        self.resource.features = ['publish']
+        d = self.service.getDiscoInfo(JID('user@example.org/home'),
+                                      JID('pubsub.example.org'), '')
+        d.addCallback(cb)
+        return d
+
+
+    def test_getDiscoItemsRoot(self):
+        """
+        Test getDiscoItems on the root node.
+        """
+        def getNodes(requestor, service, nodeIdentifier):
+            return defer.succeed(['node1', 'node2'])
+
+        def cb(items):
+            self.assertEqual(2, len(items))
+            item1, item2 = items
+
+            self.assertEqual(JID('pubsub.example.org'), item1.entity)
+            self.assertEqual('node1', item1.nodeIdentifier)
+
+            self.assertEqual(JID('pubsub.example.org'), item2.entity)
+            self.assertEqual('node2', item2.nodeIdentifier)
+
+        self.resource.getNodes = getNodes
+        d = self.service.getDiscoItems(JID('user@example.org/home'),
+                                       JID('pubsub.example.org'),
+                                       '')
+        d.addCallback(cb)
+        return d
+
+
+    def test_getDiscoItemsRootHideNodes(self):
+        """
+        Test getDiscoItems on the root node.
+        """
+        def getNodes(requestor, service, nodeIdentifier):
+            raise Exception("Unexpected call to getNodes")
+
+        def cb(items):
+            self.assertEqual([], items)
+
+        self.service.hideNodes = True
+        self.resource.getNodes = getNodes
+        d = self.service.getDiscoItems(JID('user@example.org/home'),
+                                       JID('pubsub.example.org'),
+                                       '')
+        d.addCallback(cb)
+        return d
+
+
+    def test_getDiscoItemsNonRoot(self):
+        """
+        Test getDiscoItems on a non-root node.
+        """
+        def getNodes(requestor, service, nodeIdentifier):
+            return defer.succeed(['node1', 'node2'])
+
+        def cb(items):
+            self.assertEqual(2, len(items))
+
+        self.resource.getNodes = getNodes
+        d = self.service.getDiscoItems(JID('user@example.org/home'),
+                                       JID('pubsub.example.org'),
+                                       'test')
+        d.addCallback(cb)
+        return d
+
+
+    def test_on_publish(self):
         """
         A publish request should result in L{PubSubService.publish} being
         called.
@@ -1335 +1416 @@
         </iq>
         """
 
-        def publish(requestor, service, nodeIdentifier, items):
+        def publish(request):
             return defer.succeed(None)
 
-        self.service.publish = publish
-        verify.verifyObject(iwokkel.IPubSubService, self.service)
+        self.resource.publish = publish
+        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
         return self.handleRequest(xml)
 
 
-    def test_onSubscribe(self):
+    def test_on_subscribe(self):
         """
         A successful subscription should return the current subscription.
         """
@@ -1357 +1438 @@
         </iq>
         """
 
-        def subscribe(requestor, service, nodeIdentifier, subscriber):
-            return defer.succeed(pubsub.Subscription(nodeIdentifier,
-                                                     subscriber,
+        def subscribe(request):
+            return defer.succeed(pubsub.Subscription(request.nodeIdentifier,
+                                                     request.subscriber,
                                                      'subscribed'))
 
         def cb(element):
@@ -1371 +1452 @@
             self.assertEqual('user@example.org/Home', subscription['jid'])
             self.assertEqual('subscribed', subscription['subscription'])
 
-        self.service.subscribe = subscribe
-        verify.verifyObject(iwokkel.IPubSubService, self.service)
+        self.resource.subscribe = subscribe
+        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
         d = self.handleRequest(xml)
         d.addCallback(cb)
         return d
 
 
-    def test_onSubscribeEmptyNode(self):
+    def test_on_subscribeEmptyNode(self):
         """
         A successful subscription on root node should return no node attribute.
         """
@@ -1392 +1473 @@
         </iq>
         """
 
-        def subscribe(requestor, service, nodeIdentifier, subscriber):
-            return defer.succeed(pubsub.Subscription(nodeIdentifier,
-                                                     subscriber,
+        def subscribe(request):
+            return defer.succeed(pubsub.Subscription(request.nodeIdentifier,
+                                                     request.subscriber,
                                                      'subscribed'))
 
         def cb(element):
             self.assertFalse(element.subscription.hasAttribute('node'))
 
-        self.service.subscribe = subscribe
-        verify.verifyObject(iwokkel.IPubSubService, self.service)
+        self.resource.subscribe = subscribe
+        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
         d = self.handleRequest(xml)
         d.addCallback(cb)
         return d
 
 
-    def test_onUnsubscribe(self):
+    def test_on_unsubscribe(self):
         """
         A successful unsubscription should return an empty response.
         """
@@ -1421 +1502 @@
         </iq>
         """
 
-        def unsubscribe(requestor, service, nodeIdentifier, subscriber):
+        def unsubscribe(request):
             return defer.succeed(None)
 
         def cb(element):
             self.assertIdentical(None, element)
 
-        self.service.unsubscribe = unsubscribe
-        verify.verifyObject(iwokkel.IPubSubService, self.service)
+        self.resource.unsubscribe = unsubscribe
+        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
         d = self.handleRequest(xml)
         d.addCallback(cb)
         return d
 
 
-    def test_onOptionsGet(self):
+    def test_on_optionsGet(self):
         """
         Getting subscription options is not supported.
         """
@@ -1459 +1540 @@
         return d
 
 
-    def test_onOptionsSet(self):
+    def test_on_optionsSet(self):
         """
         Setting subscription options is not supported.
         """
@@ -1491 +1572 @@
         return d
 
 
-    def test_onSubscriptions(self):
+    def test_on_subscriptions(self):
         """
         A subscriptions request should result in
         L{PubSubService.subscriptions} being called and the result prepared
@@ -1507 +1588 @@
         </iq>
         """
 
+        def subscriptions(request):
+            subscription = pubsub.Subscription('test', JID('user@example.org'),
+                                               'subscribed')
+            return defer.succeed([subscription])
+
         def cb(element):
             self.assertEqual('pubsub', element.name)
             self.assertEqual(NS_PUBSUB, element.uri)
@@ -1520 +1606 @@
             self.assertEqual('test', subscription['node'])
             self.assertEqual('subscribed', subscription['subscription'])
 
-
-        def subscriptions(requestor, service):
-            subscription = pubsub.Subscription('test', JID('user@example.org'),
-                                               'subscribed')
-            return defer.succeed([subscription])
-
-        self.service.subscriptions = subscriptions
-        verify.verifyObject(iwokkel.IPubSubService, self.service)
+        self.resource.subscriptions = subscriptions
+        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
         d = self.handleRequest(xml)
         d.addCallback(cb)
         return d
 
 
-    def test_onAffiliations(self):
+    def test_on_affiliations(self):
         """
         A subscriptions request should result in
         L{PubSubService.affiliations} being called and the result prepared
@@ -1549 +1629 @@
         </iq>
         """
 
+        def affiliations(request):
+            affiliation = ('test', 'owner')
+            return defer.succeed([affiliation])
+
         def cb(element):
             self.assertEqual('pubsub', element.name)
             self.assertEqual(NS_PUBSUB, element.uri)
@@ -1561 +1645 @@
             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)
+        self.resource.affiliations = affiliations
+        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
         d = self.handleRequest(xml)
         d.addCallback(cb)
         return d
 
 
-    def test_onCreate(self):
+    def test_on_create(self):
         """
         Replies to create node requests don't return the created node.
         """
@@ -1587 +1666 @@
         </iq>
         """
 
-        def create(requestor, service, nodeIdentifier):
-            return defer.succeed(nodeIdentifier)
+        def create(request):
+            return defer.succeed(request.nodeIdentifier)
 
         def cb(element):
             self.assertIdentical(None, element)
 
-        self.service.create = create
-        verify.verifyObject(iwokkel.IPubSubService, self.service)
+        self.resource.create = create
+        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
         d = self.handleRequest(xml)
         d.addCallback(cb)
         return d
 
 
-    def test_onCreateChanged(self):
+    def test_on_createChanged(self):
         """
         Replies to create node requests return the created node if changed.
         """
@@ -1614 +1693 @@
         </iq>
         """
 
-        def create(requestor, service, nodeIdentifier):
+        def create(request):
             return defer.succeed(u'myrenamednode')
 
         def cb(element):
@@ -1624 +1703 @@
             self.assertEqual(u'myrenamednode',
                              element.create.getAttribute('node'))
 
-        self.service.create = create
-        verify.verifyObject(iwokkel.IPubSubService, self.service)
+        self.resource.create = create
+        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
         d = self.handleRequest(xml)
         d.addCallback(cb)
         return d
 
 
-    def test_onCreateInstant(self):
+    def test_on_createInstant(self):
         """
         Replies to create instant node requests return the created node.
         """
@@ -1645 +1724 @@
         </iq>
         """
 
-        def create(requestor, service, nodeIdentifier):
+        def create(request):
             return defer.succeed(u'random')
 
         def cb(element):
@@ -1654 +1733 @@
             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)
+        self.resource.create = create
+        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
         d = self.handleRequest(xml)
         d.addCallback(cb)
         return d
 
 
-    def test_onDefault(self):
+    def test_on_default(self):
         """
         A default request should result in
         L{PubSubService.getDefaultConfiguration} being called.
@@ -1686 +1765 @@
                      "label": "Deliver payloads with event notifications"}
                 }
 
-        def getDefaultConfiguration(requestor, service, nodeType):
+        def default(request):
             return defer.succeed({})
 
         def cb(element):
@@ -1696 +1775 @@
             form = data_form.Form.fromElement(element.default.x)
             self.assertEqual(NS_PUBSUB_CONFIG, form.formNamespace)
 
-        self.service.getConfigurationOptions = getConfigurationOptions
-        self.service.getDefaultConfiguration = getDefaultConfiguration
-        verify.verifyObject(iwokkel.IPubSubService, self.service)
+        self.resource.getConfigurationOptions = getConfigurationOptions
+        self.resource.default = default
+        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
         d = self.handleRequest(xml)
         d.addCallback(cb)
         return d
 
 
-    def test_onDefaultCollection(self):
+    def test_on_defaultCollection(self):
         """
         Responses to default requests should depend on passed node type.
         """
@@ -1735 +1814 @@
                      "label": "Deliver payloads with event notifications"}
                 }
 
-        def getDefaultConfiguration(requestor, service, nodeType):
+        def default(request):
             return defer.succeed({})
 
-        self.service.getConfigurationOptions = getConfigurationOptions
-        self.service.getDefaultConfiguration = getDefaultConfiguration
-        verify.verifyObject(iwokkel.IPubSubService, self.service)
+        self.resource.getConfigurationOptions = getConfigurationOptions
+        self.resource.default = default
+        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
         return self.handleRequest(xml)
 
 
-    def test_onDefaultUnknownNodeType(self):
+    def test_on_defaultUnknownNodeType(self):
         """
         A default request should result in
-        L{PubSubService.getDefaultConfiguration} being called.
+        L{PubSubResource.default} being called.
         """
 
         xml = """
@@ -1769 +1848 @@
         </iq>
         """
 
-        def getDefaultConfiguration(requestor, service, nodeType):
+        def default(request):
             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)
+        self.resource.default = default
+        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
         d = self.handleRequest(xml)
         self.assertFailure(d, error.StanzaError)
         d.addCallback(cb)
         return d
 
 
-    def test_onConfigureGet(self):
+    def test_on_configureGet(self):
         """
-        On a node configuration get request L{PubSubService.getConfiguration}
-        is called and results in a data form with the configuration.
+        On a node configuration get
+        requestL{PubSubResource.configureGet} is called and results in a
+        data form with the configuration.
         """
 
         xml = """
@@ -1811 +1891 @@
                      "label": "Owner of the node"}
                 }
 
-        def getConfiguration(requestor, service, nodeIdentifier):
+        def configureGet(request):
             return defer.succeed({'pubsub#deliver_payloads': '0',
                                   'pubsub#persist_items': '1',
                                   'pubsub#owner': JID('user@example.org'),
@@ -1845 +1925 @@
 
             self.assertNotIn('x-myfield', fields)
 
-
-        self.service.getConfigurationOptions = getConfigurationOptions
-        self.service.getConfiguration = getConfiguration
-        verify.verifyObject(iwokkel.IPubSubService, self.service)
+        self.resource.getConfigurationOptions = getConfigurationOptions
+        self.resource.configureGet = configureGet
+        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
         d = self.handleRequest(xml)
         d.addCallback(cb)
         return d
 
 
-    def test_onConfigureSet(self):
+    def test_on_configureSet(self):
         """
         On a node configuration set request the Data Form is parsed and
-        L{PubSubService.setConfiguration} is called with the passed options.
+        L{PubSubResource.configureSet} is called with the passed options.
         """
 
         xml = """
@@ -1887 +1966 @@
                      "label": "Deliver payloads with event notifications"}
                 }
 
-        def setConfiguration(requestor, service, nodeIdentifier, options):
+        def configureSet(request):
             self.assertEqual({'pubsub#deliver_payloads': False,
-                              'pubsub#persist_items': True}, options)
+                              'pubsub#persist_items': True}, request.options)
             return defer.succeed(None)
 
-        self.service.getConfigurationOptions = getConfigurationOptions
-        self.service.setConfiguration = setConfiguration
-        verify.verifyObject(iwokkel.IPubSubService, self.service)
+        self.resource.getConfigurationOptions = getConfigurationOptions
+        self.resource.configureSet = configureSet
+        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
         return self.handleRequest(xml)
 
 
-    def test_onConfigureSetCancel(self):
+    def test_on_configureSetCancel(self):
         """
-        The node configuration is cancelled, L{PubSubService.setConfiguration}
-        not called.
+        The node configuration is cancelled,
+        L{PubSubResource.configureSet} not called.
         """
 
         xml = """
@@ -1919 +1998 @@
         </iq>
         """
 
-        def setConfiguration(requestor, service, nodeIdentifier, options):
+        def configureSet(request):
             self.fail("Unexpected call to setConfiguration")
 
-        self.service.setConfiguration = setConfiguration
-        verify.verifyObject(iwokkel.IPubSubService, self.service)
+        self.resource.configureSet = configureSet
+        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
         return self.handleRequest(xml)
 
 
-    def test_onConfigureSetIgnoreUnknown(self):
+    def test_on_configureSetIgnoreUnknown(self):
         """
         On a node configuration set request unknown fields should be ignored.
         """
@@ -1959 +2038 @@
                      "label": "Deliver payloads with event notifications"}
                 }
 
-        def setConfiguration(requestor, service, nodeIdentifier, options):
-            self.assertEquals(['pubsub#deliver_payloads'], options.keys())
+        def configureSet(request):
+            self.assertEquals(['pubsub#deliver_payloads'],
+                              request.options.keys())
 
-        self.service.getConfigurationOptions = getConfigurationOptions
-        self.service.setConfiguration = setConfiguration
-        verify.verifyObject(iwokkel.IPubSubService, self.service)
+        self.resource.getConfigurationOptions = getConfigurationOptions
+        self.resource.configureSet = configureSet
+        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
         return self.handleRequest(xml)
 
 
-    def test_onConfigureSetBadFormType(self):
+    def test_on_configureSetBadFormType(self):
         """
         On a node configuration set request unknown fields should be ignored.
         """
@@ -1999 +2079 @@
         return d
 
 
-    def test_onItems(self):
+    def test_on_items(self):
         """
         On a items request, return all items for the given node.
         """
@@ -2012 +2092 @@
         </iq>
         """
 
-        def items(requestor, service, nodeIdentifier, maxItems,
-                  itemIdentifiers):
+        def items(request):
             return defer.succeed([pubsub.Item('current')])
 
         def cb(element):
@@ -2026 +2105 @@
             self.assertEqual(NS_PUBSUB, item.uri)
             self.assertEqual('current', item['id'])
 
-        self.service.items = items
+        self.resource.items = items
+        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
         d = self.handleRequest(xml)
         d.addCallback(cb)
         return d
 
 
-    def test_onRetract(self):
+    def test_on_retract(self):
         """
-        A retract request should result in L{PubSubService.retract} being
-        called.
+        A retract request should result in L{PubSubResource.retract}
+        being called.
         """
 
         xml = """
@@ -2050 +2130 @@
         </iq>
         """
 
-        def retract(requestor, service, nodeIdentifier, itemIdentifiers):
+        def retract(request):
             return defer.succeed(None)
 
-        self.service.retract = retract
+        self.resource.retract = retract
+        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
         return self.handleRequest(xml)
 
 
-    def test_onPurge(self):
+    def test_on_purge(self):
         """
-        A purge request should result in L{PubSubService.purge} being
+        A purge request should result in L{PubSubResource.purge} being
         called.
         """
 
@@ -2072 +2153 @@
         </iq>
         """
 
-        def purge(requestor, service, nodeIdentifier):
+        def purge(request):
             return defer.succeed(None)
 
-        self.service.purge = purge
+        self.resource.purge = purge
+        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
         return self.handleRequest(xml)
 
 
-    def test_onDelete(self):
+    def test_on_delete(self):
         """
-        A delete request should result in L{PubSubService.delete} being
+        A delete request should result in L{PubSubResource.delete} being
         called.
         """
 
@@ -2094 +2176 @@
         </iq>
         """
 
-        def delete(requestor, service, nodeIdentifier):
+        def delete(request):
             return defer.succeed(None)
 
-        self.service.delete = delete
+        self.resource.delete = delete
+        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
         return self.handleRequest(xml)
 
 
@@ -2148 +2231 @@
         self.assertEqual(redirectURI, message.event.delete.redirect['uri'])
 
 
-    def test_onSubscriptionsGet(self):
+    def test_on_subscriptionsGet(self):
         """
         Getting subscription options is not supported.
         """
@@ -2175 +2258 @@
         return d
 
 
-    def test_onSubscriptionsSet(self):
+    def test_on_subscriptionsSet(self):
         """
         Setting subscription options is not supported.
         """
@@ -2202 +2285 @@
         return d
 
 
-    def test_onAffiliationsGet(self):
+    def test_on_affiliationsGet(self):
         """
         Getting subscription options is not supported.
         """
@@ -2229 +2312 @@
         return d
 
 
-    def test_onAffiliationsSet(self):
+    def test_on_affiliationsSet(self):
         """
         Setting subscription options is not supported.
         """
@@ -2256 +2339 @@
         return d
 
 
+
+class PubSubServiceWithoutResourceTest(unittest.TestCase, TestableRequestHandlerMixin):
+
+    def setUp(self):
+        self.stub = XmlStreamStub()
+        self.service = pubsub.PubSubService()
+        self.service.send = self.stub.xmlstream.send
+
+
     def test_publish(self):
         """
         Non-overridden L{PubSubService.publish} yields unsupported error.
@@ -2604 +2696 @@
         self.assertFailure(d, error.StanzaError)
         d.addCallback(cb)
         return d
+
+
+
+class PubSubResourceTest(unittest.TestCase):
+
+    def setUp(self):
+        self.resource = pubsub.PubSubResource()
+
+
+    def test_interface(self):
+        """
+        Do instances of L{pubsub.PubSubResource} provide L{iwokkel.IPubSubResource}?
+        """
+        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
+
+
+    def test_getNodes(self):
+        """
+        Default getNodes returns an empty list.
+        """
+        def cb(nodes):
+            self.assertEquals([], nodes)
+
+        d = self.resource.getNodes(JID('user@example.org/home'),
+                                   JID('pubsub.example.org'),
+                                   '')
+        d.addCallback(cb)
+        return d
+
+
+    def test_publish(self):
+        """
+        Non-overridden L{PubSubResource.publish} yields unsupported
+        error.
+        """
+
+        def cb(result):
+            self.assertEquals('feature-not-implemented', result.condition)
+            self.assertEquals('unsupported', result.appCondition.name)
+            self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
+            self.assertEquals('publish', result.appCondition['feature'])
+
+        d = self.resource.publish(pubsub.PubSubRequest())
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d
+
+
+    def test_subscribe(self):
+        """
+        Non-overridden subscriptions yields unsupported error.
+        """
+
+        def cb(result):
+            self.assertEquals('feature-not-implemented', result.condition)
+            self.assertEquals('unsupported', result.appCondition.name)
+            self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
+            self.assertEquals('subscribe', result.appCondition['feature'])
+
+        d = self.resource.subscribe(pubsub.PubSubRequest())
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d
+
+
+    def test_unsubscribe(self):
+        """
+        Non-overridden unsubscribe yields unsupported error.
+        """
+
+        def cb(result):
+            self.assertEquals('feature-not-implemented', result.condition)
+            self.assertEquals('unsupported', result.appCondition.name)
+            self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
+            self.assertEquals('subscribe', result.appCondition['feature'])
+
+        d = self.resource.unsubscribe(pubsub.PubSubRequest())
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d
+
+
+    def test_subscriptions(self):
+        """
+        Non-overridden subscriptions yields unsupported error.
+        """
+
+        def cb(result):
+            self.assertEquals('feature-not-implemented', result.condition)
+            self.assertEquals('unsupported', result.appCondition.name)
+            self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
+            self.assertEquals('retrieve-subscriptions',
+                              result.appCondition['feature'])
+
+        d = self.resource.subscriptions(pubsub.PubSubRequest())
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d
+
+
+    def test_affiliations(self):
+        """
+        Non-overridden affiliations yields unsupported error.
+        """
+
+        def cb(result):
+            self.assertEquals('feature-not-implemented', result.condition)
+            self.assertEquals('unsupported', result.appCondition.name)
+            self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
+            self.assertEquals('retrieve-affiliations',
+                              result.appCondition['feature'])
+
+        d = self.resource.affiliations(pubsub.PubSubRequest())
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d
+
+
+    def test_create(self):
+        """
+        Non-overridden create yields unsupported error.
+        """
+
+        def cb(result):
+            self.assertEquals('feature-not-implemented', result.condition)
+            self.assertEquals('unsupported', result.appCondition.name)
+            self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
+            self.assertEquals('create-nodes', result.appCondition['feature'])
+
+        d = self.resource.create(pubsub.PubSubRequest())
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d
+
+
+    def test_default(self):
+        """
+        Non-overridden default yields unsupported error.
+        """
+
+        def cb(result):
+            self.assertEquals('feature-not-implemented', result.condition)
+            self.assertEquals('unsupported', result.appCondition.name)
+            self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
+            self.assertEquals('retrieve-default',
+                              result.appCondition['feature'])
+
+        d = self.resource.default(pubsub.PubSubRequest())
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d
+
+
+    def test_configureGet(self):
+        """
+        Non-overridden configureGet yields unsupported
+        error.
+        """
+
+        def cb(result):
+            self.assertEquals('feature-not-implemented', result.condition)
+            self.assertEquals('unsupported', result.appCondition.name)
+            self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
+            self.assertEquals('config-node', result.appCondition['feature'])
+
+        d = self.resource.configureGet(pubsub.PubSubRequest())
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d
+
+
+    def test_configureSet(self):
+        """
+        Non-overridden configureSet yields unsupported error.
+        """
+
+        def cb(result):
+            self.assertEquals('feature-not-implemented', result.condition)
+            self.assertEquals('unsupported', result.appCondition.name)
+            self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
+            self.assertEquals('config-node', result.appCondition['feature'])
+
+        d = self.resource.configureSet(pubsub.PubSubRequest())
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d
+
+
+    def test_items(self):
+        """
+        Non-overridden items yields unsupported error.
+        """
+
+        def cb(result):
+            self.assertEquals('feature-not-implemented', result.condition)
+            self.assertEquals('unsupported', result.appCondition.name)
+            self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
+            self.assertEquals('retrieve-items', result.appCondition['feature'])
+
+        d = self.resource.items(pubsub.PubSubRequest())
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d
+
+
+    def test_retract(self):
+        """
+        Non-overridden retract yields unsupported error.
+        """
+
+        def cb(result):
+            self.assertEquals('feature-not-implemented', result.condition)
+            self.assertEquals('unsupported', result.appCondition.name)
+            self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
+            self.assertEquals('retract-items', result.appCondition['feature'])
+
+        d = self.resource.retract(pubsub.PubSubRequest())
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d
+
+
+    def test_purge(self):
+        """
+        Non-overridden purge yields unsupported error.
+        """
+
+        def cb(result):
+            self.assertEquals('feature-not-implemented', result.condition)
+            self.assertEquals('unsupported', result.appCondition.name)
+            self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
+            self.assertEquals('purge-nodes', result.appCondition['feature'])
+
+        d = self.resource.purge(pubsub.PubSubRequest())
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d
+
+
+    def test_delete(self):
+        """
+        Non-overridden delete yields unsupported error.
+        """
+
+        def cb(result):
+            self.assertEquals('feature-not-implemented', result.condition)
+            self.assertEquals('unsupported', result.appCondition.name)
+            self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
+            self.assertEquals('delete-nodes', result.appCondition['feature'])
+
+        d = self.resource.delete(pubsub.PubSubRequest())
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d