Changeset 59:e984452207e0 for wokkel/test

Timestamp:

Apr 22, 2009, 5:04:03 PM (13 years ago)

Author:

Ralph Meijer <ralphm@…>

Branch:

default

Convert:

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

Message:

Provide PubSubResource?, modeled after Twisted Web resources.

Author: ralphm.
Fixes #47.

This should make it rather easy to make publish-subscribe enabled services.

File:

• wokkel/test/test_pubsub.py (modified) (46 diffs)

wokkel/test/test_pubsub.py

@@ -1223 +1223 @@
     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
 
@@ -1261 +1262 @@
         """
         def cb(info):
-            self.assertEqual(2, len(info))
-
-        def getNodeInfo(requestor, target, nodeIdentifier):
-            return defer.succeed(None)
-
-        self.service.getNodeInfo = getNodeInfo
+            discoInfo = disco.DiscoInfo()
+            for item in info:
+                discoInfo.append(item)
+            self.assertIn(('pubsub', 'service'), discoInfo.identities)
+            self.assertIn(disco.NS_DISCO_ITEMS, discoInfo.features)
+
         d = self.service.getDiscoInfo(JID('user@example.org/home'),
                                       JID('pubsub.example.org'), '')
@@ -1283 +1284 @@
             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'), '')
@@ -1308 +1309 @@
             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',
@@ -1314 +1315 @@
             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'), '')
@@ -1321 +1322 @@
 
 
-    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
@@ -1336 +1417 @@
         """
 
-        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.
@@ -1358 +1439 @@
         """
 
-        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'))
 
@@ -1372 +1453 @@
             self.assertEqual('subscribed', subscription['subscription'])
 
-        self.service.subscribe = subscribe
-        verify.verifyObject(iwokkel.IPubSubService, self.service)
-        d = self.handleRequest(xml)
-        d.addCallback(cb)
-        return d
-
-
-    def test_onSubscribeEmptyNode(self):
+        self.resource.subscribe = subscribe
+        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
+        d = self.handleRequest(xml)
+        d.addCallback(cb)
+        return d
+
+
+    def test_on_subscribeEmptyNode(self):
         """
         A successful subscription on root node should return no node attribute.
@@ -1393 +1474 @@
         """
 
-        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'))
 
@@ -1401 +1482 @@
             self.assertFalse(element.subscription.hasAttribute('node'))
 
-        self.service.subscribe = subscribe
-        verify.verifyObject(iwokkel.IPubSubService, self.service)
-        d = self.handleRequest(xml)
-        d.addCallback(cb)
-        return d
-
-
-    def test_onUnsubscribe(self):
+        self.resource.subscribe = subscribe
+        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
+        d = self.handleRequest(xml)
+        d.addCallback(cb)
+        return d
+
+
+    def test_on_unsubscribe(self):
         """
         A successful unsubscription should return an empty response.
@@ -1422 +1503 @@
         """
 
-        def unsubscribe(requestor, service, nodeIdentifier, subscriber):
+        def unsubscribe(request):
             return defer.succeed(None)
 
@@ -1428 +1509 @@
             self.assertIdentical(None, element)
 
-        self.service.unsubscribe = unsubscribe
-        verify.verifyObject(iwokkel.IPubSubService, self.service)
-        d = self.handleRequest(xml)
-        d.addCallback(cb)
-        return d
-
-
-    def test_onOptionsGet(self):
+        self.resource.unsubscribe = unsubscribe
+        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
+        d = self.handleRequest(xml)
+        d.addCallback(cb)
+        return d
+
+
+    def test_on_optionsGet(self):
         """
         Getting subscription options is not supported.
@@ -1460 +1541 @@
 
 
-    def test_onOptionsSet(self):
+    def test_on_optionsSet(self):
         """
         Setting subscription options is not supported.
@@ -1492 +1573 @@
 
 
-    def test_onSubscriptions(self):
+    def test_on_subscriptions(self):
         """
         A subscriptions request should result in
@@ -1507 +1588 @@
         </iq>
         """
+
+        def subscriptions(request):
+            subscription = pubsub.Subscription('test', JID('user@example.org'),
+                                               'subscribed')
+            return defer.succeed([subscription])
 
         def cb(element):
@@ -1521 +1607 @@
             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)
-        d = self.handleRequest(xml)
-        d.addCallback(cb)
-        return d
-
-
-    def test_onAffiliations(self):
+        self.resource.subscriptions = subscriptions
+        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
+        d = self.handleRequest(xml)
+        d.addCallback(cb)
+        return d
+
+
+    def test_on_affiliations(self):
         """
         A subscriptions request should result in
@@ -1549 +1629 @@
         </iq>
         """
+
+        def affiliations(request):
+            affiliation = ('test', 'owner')
+            return defer.succeed([affiliation])
 
         def cb(element):
@@ -1562 +1646 @@
             self.assertEqual('owner', affiliation['affiliation'])
 
-
-        def affiliations(requestor, service):
-            affiliation = ('test', 'owner')
-            return defer.succeed([affiliation])
-
-        self.service.affiliations = affiliations
-        verify.verifyObject(iwokkel.IPubSubService, self.service)
-        d = self.handleRequest(xml)
-        d.addCallback(cb)
-        return d
-
-
-    def test_onCreate(self):
+        self.resource.affiliations = affiliations
+        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
+        d = self.handleRequest(xml)
+        d.addCallback(cb)
+        return d
+
+
+    def test_on_create(self):
         """
         Replies to create node requests don't return the created node.
@@ -1588 +1667 @@
         """
 
-        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)
-        d = self.handleRequest(xml)
-        d.addCallback(cb)
-        return d
-
-
-    def test_onCreateChanged(self):
+        self.resource.create = create
+        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
+        d = self.handleRequest(xml)
+        d.addCallback(cb)
+        return d
+
+
+    def test_on_createChanged(self):
         """
         Replies to create node requests return the created node if changed.
@@ -1615 +1694 @@
         """
 
-        def create(requestor, service, nodeIdentifier):
+        def create(request):
             return defer.succeed(u'myrenamednode')
 
@@ -1625 +1704 @@
                              element.create.getAttribute('node'))
 
-        self.service.create = create
-        verify.verifyObject(iwokkel.IPubSubService, self.service)
-        d = self.handleRequest(xml)
-        d.addCallback(cb)
-        return d
-
-
-    def test_onCreateInstant(self):
+        self.resource.create = create
+        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
+        d = self.handleRequest(xml)
+        d.addCallback(cb)
+        return d
+
+
+    def test_on_createInstant(self):
         """
         Replies to create instant node requests return the created node.
@@ -1646 +1725 @@
         """
 
-        def create(requestor, service, nodeIdentifier):
+        def create(request):
             return defer.succeed(u'random')
 
@@ -1655 +1734 @@
             self.assertEqual(u'random', element.create.getAttribute('node'))
 
-        self.service.create = create
-        verify.verifyObject(iwokkel.IPubSubService, self.service)
-        d = self.handleRequest(xml)
-        d.addCallback(cb)
-        return d
-
-
-    def test_onDefault(self):
+        self.resource.create = create
+        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
+        d = self.handleRequest(xml)
+        d.addCallback(cb)
+        return d
+
+
+    def test_on_default(self):
         """
         A default request should result in
@@ -1687 +1766 @@
                 }
 
-        def getDefaultConfiguration(requestor, service, nodeType):
+        def default(request):
             return defer.succeed({})
 
@@ -1697 +1776 @@
             self.assertEqual(NS_PUBSUB_CONFIG, form.formNamespace)
 
-        self.service.getConfigurationOptions = getConfigurationOptions
-        self.service.getDefaultConfiguration = getDefaultConfiguration
-        verify.verifyObject(iwokkel.IPubSubService, self.service)
-        d = self.handleRequest(xml)
-        d.addCallback(cb)
-        return d
-
-
-    def test_onDefaultCollection(self):
+        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_on_defaultCollection(self):
         """
         Responses to default requests should depend on passed node type.
@@ -1736 +1815 @@
                 }
 
-        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.
         """
 
@@ -1770 +1849 @@
         """
 
-        def getDefaultConfiguration(requestor, service, nodeType):
+        def default(request):
             self.fail("Unexpected call to getConfiguration")
 
@@ -1776 +1855 @@
             self.assertEquals('not-acceptable', result.condition)
 
-        self.service.getDefaultConfiguration = getDefaultConfiguration
-        verify.verifyObject(iwokkel.IPubSubService, self.service)
-        d = self.handleRequest(xml)
-        self.assertFailure(d, error.StanzaError)
-        d.addCallback(cb)
-        return d
-
-
-    def test_onConfigureGet(self):
-        """
-        On a node configuration get request L{PubSubService.getConfiguration}
-        is called and results in a data form with the configuration.
+        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_on_configureGet(self):
+        """
+        On a node configuration get
+        requestL{PubSubResource.configureGet} is called and results in a
+        data form with the configuration.
         """
 
@@ -1812 +1892 @@
                 }
 
-        def getConfiguration(requestor, service, nodeIdentifier):
+        def configureGet(request):
             return defer.succeed({'pubsub#deliver_payloads': '0',
                                   'pubsub#persist_items': '1',
@@ -1846 +1926 @@
             self.assertNotIn('x-myfield', fields)
 
-
-        self.service.getConfigurationOptions = getConfigurationOptions
-        self.service.getConfiguration = getConfiguration
-        verify.verifyObject(iwokkel.IPubSubService, self.service)
-        d = self.handleRequest(xml)
-        d.addCallback(cb)
-        return d
-
-
-    def test_onConfigureSet(self):
+        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_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.
         """
 
@@ -1888 +1967 @@
                 }
 
-        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):
-        """
-        The node configuration is cancelled, L{PubSubService.setConfiguration}
-        not called.
+    def test_on_configureSetCancel(self):
+        """
+        The node configuration is cancelled,
+        L{PubSubResource.configureSet} not called.
         """
 
@@ -1920 +1999 @@
         """
 
-        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.
@@ -1960 +2039 @@
                 }
 
-        def setConfiguration(requestor, service, nodeIdentifier, options):
-            self.assertEquals(['pubsub#deliver_payloads'], options.keys())
-
-        self.service.getConfigurationOptions = getConfigurationOptions
-        self.service.setConfiguration = setConfiguration
-        verify.verifyObject(iwokkel.IPubSubService, self.service)
+        def configureSet(request):
+            self.assertEquals(['pubsub#deliver_payloads'],
+                              request.options.keys())
+
+        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 +2080 @@
 
 
-    def test_onItems(self):
+    def test_on_items(self):
         """
         On a items request, return all items for the given node.
@@ -2013 +2093 @@
         """
 
-        def items(requestor, service, nodeIdentifier, maxItems,
-                  itemIdentifiers):
+        def items(request):
             return defer.succeed([pubsub.Item('current')])
 
@@ -2027 +2106 @@
             self.assertEqual('current', item['id'])
 
-        self.service.items = items
-        d = self.handleRequest(xml)
-        d.addCallback(cb)
-        return d
-
-
-    def test_onRetract(self):
-        """
-        A retract request should result in L{PubSubService.retract} being
-        called.
+        self.resource.items = items
+        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
+        d = self.handleRequest(xml)
+        d.addCallback(cb)
+        return d
+
+
+    def test_on_retract(self):
+        """
+        A retract request should result in L{PubSubResource.retract}
+        being called.
         """
 
@@ -2051 +2131 @@
         """
 
-        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):
-        """
-        A purge request should result in L{PubSubService.purge} being
+    def test_on_purge(self):
+        """
+        A purge request should result in L{PubSubResource.purge} being
         called.
         """
@@ -2073 +2154 @@
         """
 
-        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):
-        """
-        A delete request should result in L{PubSubService.delete} being
+    def test_on_delete(self):
+        """
+        A delete request should result in L{PubSubResource.delete} being
         called.
         """
@@ -2095 +2177 @@
         """
 
-        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)
 
@@ -2149 +2232 @@
 
 
-    def test_onSubscriptionsGet(self):
+    def test_on_subscriptionsGet(self):
         """
         Getting subscription options is not supported.
@@ -2176 +2259 @@
 
 
-    def test_onSubscriptionsSet(self):
+    def test_on_subscriptionsSet(self):
         """
         Setting subscription options is not supported.
@@ -2203 +2286 @@
 
 
-    def test_onAffiliationsGet(self):
+    def test_on_affiliationsGet(self):
         """
         Getting subscription options is not supported.
@@ -2230 +2313 @@
 
 
-    def test_onAffiliationsSet(self):
+    def test_on_affiliationsSet(self):
         """
         Setting subscription options is not supported.
@@ -2255 +2338 @@
         d.addCallback(cb)
         return d
+
+
+
+class PubSubServiceWithoutResourceTest(unittest.TestCase, TestableRequestHandlerMixin):
+
+    def setUp(self):
+        self.stub = XmlStreamStub()
+        self.service = pubsub.PubSubService()
+        self.service.send = self.stub.xmlstream.send
 
 
@@ -2605 +2697 @@
         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