source: ralphm-patches/pubsub_resource.patch @ 12:fc40892815eb

wokkel/iwokkel.py

@@ -297 +297 @@
         """
 
 
-    def publish(request):
+class IPubSubResource(Interface):
+
+    def locateResource(request):
         """
-        Called when a publish request has been received.
+        Locate a resource that will handle the request.
 
         @param request: The publish-subscribe request.
         @type request: L{wokkel.pubsub.PubSubRequest}
-        @return: deferred that fires on success.
+        """
+
+
+    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 subscribe(request):
+    def getNodes(requestor, service, nodeIdentifier):
         """
-        Called when a subscribe request has been received.
+        Get all nodes contained by this node.
 
-        @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.
+        @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}
         """
 
@@ -406 +377 @@
         """
 
 
-    def getDefaultConfiguration(request):
+    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.
 
@@ -420 +464 @@
         """
 
 
-    def getConfiguration(request):
+    def configureGet(request):
         """
         Called when a node configuration retrieval request has been received.
 
@@ -433 +477 @@
         """
 
 
-    def setConfiguration(request):
+    def configureSet(request):
         """
         Called when a node configuration change request has been received.
 

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',
             }
 
+    hideNodes = False
 
-    def __init__(self):
-        self.discoIdentity = {'category': 'pubsub',
-                              'type': 'generic',
-                              'name': 'Generic Publish-Subscribe Service'}
-
-        self.pubSubFeatures = []
+    def __init__(self, resource):
+        self.resource = resource
 
 
     def connectionMade(self):
@@ -820 +823 @@
 
 
     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 +845 @@
 
                 info.append(form)
 
-        d = self.getNodeInfo(requestor, target, nodeIdentifier or '')
-        d.addCallback(toInfo)
-        d.addBoth(lambda result: info)
+            return info
+
+        info = []
+
+        request = PubSubRequest('discoInfo')
+        resource = self.resource.locateResource(request)
+
+        if not nodeIdentifier:
+            info.append(resource.discoIdentity)
+            info.append(disco.DiscoFeature(disco.NS_DISCO_ITEMS))
+            info.extend([disco.DiscoFeature("%s#%s" % (NS_PUBSUB, feature))
+                         for feature in resource.features])
+
+        d = resource.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:
+        request = PubSubRequest('discoInfo')
+        resource = self.resource.locateResource(request)
+
+        if self.hideNodes:
             return defer.succeed([])
 
-        d = self.getNodes(requestor, target)
+        d = resource.getNodes(requestor, target, nodeIdentifier)
         d.addCallback(lambda nodes: [disco.DiscoItem(target, node)
                                      for node in nodes])
         return d
@@ -870 +879 @@
 
     def _onPubSubRequest(self, iq):
         request = PubSubRequest.fromElement(iq)
-        handler = getattr(self, '_on_%s' % request.verb)
-        return handler(request)
+        resource = self.resource.locateResource(request)
 
+        # 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)
 
-    def _on_publish(self, request):
-        return self.publish(request)
+        # Process the request itself, 
+        try:
+            handler = getattr(resource, request.verb)
+        except AttributeError:
+            # fix lookup feature
+            text = "Request verb: %s" % request.verb
+            return defer.fail(Unsupported('', text))
 
+        d = handler(request)
 
-    def _on_subscribe(self, request):
+        # 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)
 
-        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
-
-        d = self.subscribe(request)
-        d.addCallback(toResponse)
         return d
 
 
-    def _on_unsubscribe(self, request):
-        return self.unsubscribe(request)
+    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)
-        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)
-        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)
-        d.addCallback(toResponse)
-        return d
+        else:
+            return None
 
 
     def _makeFields(self, options, values):
@@ -973 +971 @@
         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,
@@ -983 +981 @@
         return form
 
 
-    def _checkConfiguration(self, values):
-        options = self.getConfigurationOptions()
+    def _checkConfiguration(self, resource, values):
+        options = resource.getConfigurationOptions()
         processedValues = {}
 
         for key, value in values.iteritems():
@@ -1008 +1006 @@
         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)
-        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)
-        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)
+            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)
-        d.addCallback(toResponse)
-        return d
-
-
-    def _on_retract(self, request):
-        return self.retract(request)
-
-
-    def _on_purge(self, request):
-        return self.purge(request)
-
-
-    def _on_delete(self, request):
-        return self.delete(request)
-
-
-    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):
@@ -1118 +1075 @@
 
         return message
 
+    # public methods
+
     def notifyPublish(self, service, nodeIdentifier, notifications):
         for subscriber, subscriptions, items in notifications:
             message = self._createNotification('items', service,
@@ -1139 +1098 @@
             self.send(message)
 
 
-    def getNodeInfo(self, requestor, service, nodeIdentifier):
-        return None
 
+class PubSubResource(object):
 
-    def getNodes(self, requestor, service):
-        return []
+    implements(IPubSubResource)
 
+    features = []
+    discoIdentity = disco.DiscoIdentity('pubsub',
+                                        'service',
+                                        'Publish-Subscribe Service')
 
-    def publish(self, request):
-        raise Unsupported('publish')
 
+    def locateResource(self, request):
+        return self
 
-    def subscribe(self, request):
-        raise Unsupported('subscribe')
 
+    def getInfo(self, requestor, service, nodeIdentifier):
+        return defer.succeed(None)
 
-    def unsubscribe(self, request):
-        raise Unsupported('subscribe')
 
-
-    def subscriptions(self, request):
-        raise Unsupported('retrieve-subscriptions')
-
-
-    def affiliations(self, request):
-        raise Unsupported('retrieve-affiliations')
-
-
-    def create(self, request):
-        raise Unsupported('create-nodes')
+    def getNodes(self, requestor, service, nodeIdentifier):
+        return defer.succeed([])
 
 
     def getConfigurationOptions(self):
         return {}
 
 
-    def getDefaultConfiguration(self, request):
-        raise Unsupported('retrieve-default')
+    def publish(self, request):
+        return defer.fail(Unsupported('publish'))
 
 
-    def getConfiguration(self, request):
-        raise Unsupported('config-node')
+    def subscribe(self, request):
+        return defer.fail(Unsupported('subscribe'))
 
 
-    def setConfiguration(self, request):
-        raise Unsupported('config-node')
+    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):
-        raise Unsupported('retrieve-items')
+        return defer.fail(Unsupported('retrieve-items'))
 
 
     def retract(self, request):
-        raise Unsupported('retract-items')
+        return defer.fail(Unsupported('retract-items'))
 
 
     def purge(self, request):
-        raise Unsupported('purge-nodes')
+        return defer.fail(Unsupported('purge-nodes'))
 
 
     def delete(self, request):
-        raise Unsupported('delete-nodes')
+        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.
@@ -1338 +1419 @@
         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.
         """
@@ -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.
         """
@@ -1400 +1481 @@
         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.
         """
@@ -1427 +1508 @@
         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(request):
-            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(request):
-            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.
         """
@@ -1593 +1672 @@
         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.
         """
@@ -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.
         """
@@ -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(request):
+        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(request):
+        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(request):
+        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(request):
+        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(request):
+        def configureSet(request):
             self.assertEqual({'pubsub#deliver_payloads': False,
                               '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(request):
+        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(request):
+        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.
         """
@@ -2000 +2079 @@
         return d
 
 
-    def test_onItems(self):
+    def test_on_items(self):
         """
         On a items request, return all items for the given node.
         """
@@ -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 = """
@@ -2053 +2133 @@
         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.
         """
 
@@ -2075 +2156 @@
         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.
         """
 
@@ -2097 +2179 @@
         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 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{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>
+        Non-overridden L{PubSubResource.publish} yields unsupported
+        error.
         """
 
         def cb(result):
@@ -2276 +2379 @@
             self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
             self.assertEquals('publish', result.appCondition['feature'])
 
-        d = self.handleRequest(xml)
+        d = self.resource.publish(pubsub.PubSubRequest())
         self.assertFailure(d, error.StanzaError)
         d.addCallback(cb)
         return d
@@ -2284 +2387 @@
 
     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>
+        Non-overridden subscriptions yields unsupported error.
         """
 
         def cb(result):
@@ -2302 +2396 @@
             self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
             self.assertEquals('subscribe', result.appCondition['feature'])
 
-        d = self.handleRequest(xml)
+        d = self.resource.subscribe(pubsub.PubSubRequest())
         self.assertFailure(d, error.StanzaError)
         d.addCallback(cb)
         return d
@@ -2310 +2404 @@
 
     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>
+        Non-overridden unsubscribe yields unsupported error.
         """
 
         def cb(result):
@@ -2328 +2413 @@
             self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
             self.assertEquals('subscribe', result.appCondition['feature'])
 
-        d = self.handleRequest(xml)
+        d = self.resource.unsubscribe(pubsub.PubSubRequest())
         self.assertFailure(d, error.StanzaError)
         d.addCallback(cb)
         return d
@@ -2336 +2421 @@
 
     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>
+        Non-overridden subscriptions yields unsupported error.
         """
 
         def cb(result):
@@ -2355 +2431 @@
             self.assertEquals('retrieve-subscriptions',
                               result.appCondition['feature'])
 
-        d = self.handleRequest(xml)
+        d = self.resource.subscriptions(pubsub.PubSubRequest())
         self.assertFailure(d, error.StanzaError)
         d.addCallback(cb)
         return d
@@ -2363 +2439 @@
 
     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>
+        Non-overridden affiliations yields unsupported error.
         """
 
         def cb(result):
@@ -2382 +2449 @@
             self.assertEquals('retrieve-affiliations',
                               result.appCondition['feature'])
 
-        d = self.handleRequest(xml)
+        d = self.resource.affiliations(pubsub.PubSubRequest())
         self.assertFailure(d, error.StanzaError)
         d.addCallback(cb)
         return d
@@ -2390 +2457 @@
 
     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>
+        Non-overridden create yields unsupported error.
         """
 
         def cb(result):
@@ -2408 +2466 @@
             self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
             self.assertEquals('create-nodes', result.appCondition['feature'])
 
-        d = self.handleRequest(xml)
+        d = self.resource.create(pubsub.PubSubRequest())
         self.assertFailure(d, error.StanzaError)
         d.addCallback(cb)
         return d
 
 
-    def test_getDefaultConfiguration(self):
+    def test_default(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>
+        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'])
+            self.assertEquals('retrieve-default',
+                              result.appCondition['feature'])
 
-        d = self.handleRequest(xml)
+        d = self.resource.default(pubsub.PubSubRequest())
         self.assertFailure(d, error.StanzaError)
         d.addCallback(cb)
         return d
 
 
-    def test_getConfiguration(self):
+    def test_configureGet(self):
         """
-        Non-overridden L{PubSubService.getConfiguration} yields unsupported
+        Non-overridden configureGet 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)
+        d = self.resource.configureGet(pubsub.PubSubRequest())
         self.assertFailure(d, error.StanzaError)
         d.addCallback(cb)
         return d
 
 
-    def test_setConfiguration(self):
+    def test_configureSet(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>
+        Non-overridden configureSet yields unsupported error.
         """
 
         def cb(result):
@@ -2497 +2519 @@
             self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
             self.assertEquals('config-node', result.appCondition['feature'])
 
-        d = self.handleRequest(xml)
+        d = self.resource.configureSet(pubsub.PubSubRequest())
         self.assertFailure(d, error.StanzaError)
         d.addCallback(cb)
         return d
@@ -2505 +2527 @@
 
     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>
+        Non-overridden items yields unsupported error.
         """
 
         def cb(result):
@@ -2522 +2536 @@
             self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
             self.assertEquals('retrieve-items', result.appCondition['feature'])
 
-        d = self.handleRequest(xml)
+        d = self.resource.items(pubsub.PubSubRequest())
         self.assertFailure(d, error.StanzaError)
         d.addCallback(cb)
         return d
@@ -2530 +2544 @@
 
     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>
+        Non-overridden retract yields unsupported error.
         """
 
         def cb(result):
@@ -2550 +2553 @@
             self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
             self.assertEquals('retract-items', result.appCondition['feature'])
 
-        d = self.handleRequest(xml)
+        d = self.resource.retract(pubsub.PubSubRequest())
         self.assertFailure(d, error.StanzaError)
         d.addCallback(cb)
         return d
@@ -2558 +2561 @@
 
     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>
+        Non-overridden purge yields unsupported error.
         """
 
         def cb(result):
@@ -2575 +2570 @@
             self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
             self.assertEquals('purge-nodes', result.appCondition['feature'])
 
-        d = self.handleRequest(xml)
+        d = self.resource.purge(pubsub.PubSubRequest())
         self.assertFailure(d, error.StanzaError)
         d.addCallback(cb)
         return d
@@ -2583 +2578 @@
 
     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>
+        Non-overridden delete yields unsupported error.
         """
 
         def cb(result):
@@ -2600 +2587 @@
             self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
             self.assertEquals('delete-nodes', result.appCondition['feature'])
 
-        d = self.handleRequest(xml)
+        d = self.resource.delete(pubsub.PubSubRequest())
         self.assertFailure(d, error.StanzaError)
         d.addCallback(cb)
         return d