Ignore:
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:
1 edited

Legend:

Unmodified
Added
Removed
  • wokkel/test/test_pubsub.py

    r58 r59  
    12231223    def setUp(self):
    12241224        self.stub = XmlStreamStub()
    1225         self.service = pubsub.PubSubService()
     1225        self.resource = pubsub.PubSubResource()
     1226        self.service = pubsub.PubSubService(self.resource)
    12261227        self.service.send = self.stub.xmlstream.send
    12271228
     
    12611262        """
    12621263        def cb(info):
    1263             self.assertEqual(2, len(info))
    1264 
    1265         def getNodeInfo(requestor, target, nodeIdentifier):
    1266             return defer.succeed(None)
    1267 
    1268         self.service.getNodeInfo = getNodeInfo
     1264            discoInfo = disco.DiscoInfo()
     1265            for item in info:
     1266                discoInfo.append(item)
     1267            self.assertIn(('pubsub', 'service'), discoInfo.identities)
     1268            self.assertIn(disco.NS_DISCO_ITEMS, discoInfo.features)
     1269
    12691270        d = self.service.getDiscoInfo(JID('user@example.org/home'),
    12701271                                      JID('pubsub.example.org'), '')
     
    12831284            self.assertIn(('pubsub', 'collection'), discoInfo.identities)
    12841285
    1285         def getNodeInfo(requestor, target, nodeIdentifier):
     1286        def getInfo(requestor, target, nodeIdentifier):
    12861287            return defer.succeed({'type': 'collection',
    12871288                                  'meta-data': {}})
    12881289
    1289         self.service.getNodeInfo = getNodeInfo
     1290        self.resource.getInfo = getInfo
    12901291        d = self.service.getDiscoInfo(JID('user@example.org/home'),
    12911292                                      JID('pubsub.example.org'), '')
     
    13081309            self.assertIn('pubsub#node_type', form.fields)
    13091310
    1310         def getNodeInfo(requestor, target, nodeIdentifier):
     1311        def getInfo(requestor, target, nodeIdentifier):
    13111312            metaData = [{'var': 'pubsub#persist_items',
    13121313                         'label': 'Persist items to storage',
     
    13141315            return defer.succeed({'type': 'leaf', 'meta-data': metaData})
    13151316
    1316         self.service.getNodeInfo = getNodeInfo
     1317        self.resource.getInfo = getInfo
    13171318        d = self.service.getDiscoInfo(JID('user@example.org/home'),
    13181319                                      JID('pubsub.example.org'), '')
     
    13211322
    13221323
    1323     def test_onPublish(self):
     1324    def test_getDiscoInfoResourceFeatures(self):
     1325        """
     1326        Test getDiscoInfo with the resource features.
     1327        """
     1328        def cb(info):
     1329            discoInfo = disco.DiscoInfo()
     1330            for item in info:
     1331                discoInfo.append(item)
     1332            self.assertIn('http://jabber.org/protocol/pubsub#publish',
     1333                          discoInfo.features)
     1334
     1335        self.resource.features = ['publish']
     1336        d = self.service.getDiscoInfo(JID('user@example.org/home'),
     1337                                      JID('pubsub.example.org'), '')
     1338        d.addCallback(cb)
     1339        return d
     1340
     1341
     1342    def test_getDiscoItemsRoot(self):
     1343        """
     1344        Test getDiscoItems on the root node.
     1345        """
     1346        def getNodes(requestor, service, nodeIdentifier):
     1347            return defer.succeed(['node1', 'node2'])
     1348
     1349        def cb(items):
     1350            self.assertEqual(2, len(items))
     1351            item1, item2 = items
     1352
     1353            self.assertEqual(JID('pubsub.example.org'), item1.entity)
     1354            self.assertEqual('node1', item1.nodeIdentifier)
     1355
     1356            self.assertEqual(JID('pubsub.example.org'), item2.entity)
     1357            self.assertEqual('node2', item2.nodeIdentifier)
     1358
     1359        self.resource.getNodes = getNodes
     1360        d = self.service.getDiscoItems(JID('user@example.org/home'),
     1361                                       JID('pubsub.example.org'),
     1362                                       '')
     1363        d.addCallback(cb)
     1364        return d
     1365
     1366
     1367    def test_getDiscoItemsRootHideNodes(self):
     1368        """
     1369        Test getDiscoItems on the root node.
     1370        """
     1371        def getNodes(requestor, service, nodeIdentifier):
     1372            raise Exception("Unexpected call to getNodes")
     1373
     1374        def cb(items):
     1375            self.assertEqual([], items)
     1376
     1377        self.service.hideNodes = True
     1378        self.resource.getNodes = getNodes
     1379        d = self.service.getDiscoItems(JID('user@example.org/home'),
     1380                                       JID('pubsub.example.org'),
     1381                                       '')
     1382        d.addCallback(cb)
     1383        return d
     1384
     1385
     1386    def test_getDiscoItemsNonRoot(self):
     1387        """
     1388        Test getDiscoItems on a non-root node.
     1389        """
     1390        def getNodes(requestor, service, nodeIdentifier):
     1391            return defer.succeed(['node1', 'node2'])
     1392
     1393        def cb(items):
     1394            self.assertEqual(2, len(items))
     1395
     1396        self.resource.getNodes = getNodes
     1397        d = self.service.getDiscoItems(JID('user@example.org/home'),
     1398                                       JID('pubsub.example.org'),
     1399                                       'test')
     1400        d.addCallback(cb)
     1401        return d
     1402
     1403
     1404    def test_on_publish(self):
    13241405        """
    13251406        A publish request should result in L{PubSubService.publish} being
     
    13361417        """
    13371418
    1338         def publish(requestor, service, nodeIdentifier, items):
     1419        def publish(request):
    13391420            return defer.succeed(None)
    13401421
    1341         self.service.publish = publish
    1342         verify.verifyObject(iwokkel.IPubSubService, self.service)
     1422        self.resource.publish = publish
     1423        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
    13431424        return self.handleRequest(xml)
    13441425
    13451426
    1346     def test_onSubscribe(self):
     1427    def test_on_subscribe(self):
    13471428        """
    13481429        A successful subscription should return the current subscription.
     
    13581439        """
    13591440
    1360         def subscribe(requestor, service, nodeIdentifier, subscriber):
    1361             return defer.succeed(pubsub.Subscription(nodeIdentifier,
    1362                                                      subscriber,
     1441        def subscribe(request):
     1442            return defer.succeed(pubsub.Subscription(request.nodeIdentifier,
     1443                                                     request.subscriber,
    13631444                                                     'subscribed'))
    13641445
     
    13721453            self.assertEqual('subscribed', subscription['subscription'])
    13731454
    1374         self.service.subscribe = subscribe
    1375         verify.verifyObject(iwokkel.IPubSubService, self.service)
    1376         d = self.handleRequest(xml)
    1377         d.addCallback(cb)
    1378         return d
    1379 
    1380 
    1381     def test_onSubscribeEmptyNode(self):
     1455        self.resource.subscribe = subscribe
     1456        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
     1457        d = self.handleRequest(xml)
     1458        d.addCallback(cb)
     1459        return d
     1460
     1461
     1462    def test_on_subscribeEmptyNode(self):
    13821463        """
    13831464        A successful subscription on root node should return no node attribute.
     
    13931474        """
    13941475
    1395         def subscribe(requestor, service, nodeIdentifier, subscriber):
    1396             return defer.succeed(pubsub.Subscription(nodeIdentifier,
    1397                                                      subscriber,
     1476        def subscribe(request):
     1477            return defer.succeed(pubsub.Subscription(request.nodeIdentifier,
     1478                                                     request.subscriber,
    13981479                                                     'subscribed'))
    13991480
     
    14011482            self.assertFalse(element.subscription.hasAttribute('node'))
    14021483
    1403         self.service.subscribe = subscribe
    1404         verify.verifyObject(iwokkel.IPubSubService, self.service)
    1405         d = self.handleRequest(xml)
    1406         d.addCallback(cb)
    1407         return d
    1408 
    1409 
    1410     def test_onUnsubscribe(self):
     1484        self.resource.subscribe = subscribe
     1485        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
     1486        d = self.handleRequest(xml)
     1487        d.addCallback(cb)
     1488        return d
     1489
     1490
     1491    def test_on_unsubscribe(self):
    14111492        """
    14121493        A successful unsubscription should return an empty response.
     
    14221503        """
    14231504
    1424         def unsubscribe(requestor, service, nodeIdentifier, subscriber):
     1505        def unsubscribe(request):
    14251506            return defer.succeed(None)
    14261507
     
    14281509            self.assertIdentical(None, element)
    14291510
    1430         self.service.unsubscribe = unsubscribe
    1431         verify.verifyObject(iwokkel.IPubSubService, self.service)
    1432         d = self.handleRequest(xml)
    1433         d.addCallback(cb)
    1434         return d
    1435 
    1436 
    1437     def test_onOptionsGet(self):
     1511        self.resource.unsubscribe = unsubscribe
     1512        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
     1513        d = self.handleRequest(xml)
     1514        d.addCallback(cb)
     1515        return d
     1516
     1517
     1518    def test_on_optionsGet(self):
    14381519        """
    14391520        Getting subscription options is not supported.
     
    14601541
    14611542
    1462     def test_onOptionsSet(self):
     1543    def test_on_optionsSet(self):
    14631544        """
    14641545        Setting subscription options is not supported.
     
    14921573
    14931574
    1494     def test_onSubscriptions(self):
     1575    def test_on_subscriptions(self):
    14951576        """
    14961577        A subscriptions request should result in
     
    15071588        </iq>
    15081589        """
     1590
     1591        def subscriptions(request):
     1592            subscription = pubsub.Subscription('test', JID('user@example.org'),
     1593                                               'subscribed')
     1594            return defer.succeed([subscription])
    15091595
    15101596        def cb(element):
     
    15211607            self.assertEqual('subscribed', subscription['subscription'])
    15221608
    1523 
    1524         def subscriptions(requestor, service):
    1525             subscription = pubsub.Subscription('test', JID('user@example.org'),
    1526                                                'subscribed')
    1527             return defer.succeed([subscription])
    1528 
    1529         self.service.subscriptions = subscriptions
    1530         verify.verifyObject(iwokkel.IPubSubService, self.service)
    1531         d = self.handleRequest(xml)
    1532         d.addCallback(cb)
    1533         return d
    1534 
    1535 
    1536     def test_onAffiliations(self):
     1609        self.resource.subscriptions = subscriptions
     1610        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
     1611        d = self.handleRequest(xml)
     1612        d.addCallback(cb)
     1613        return d
     1614
     1615
     1616    def test_on_affiliations(self):
    15371617        """
    15381618        A subscriptions request should result in
     
    15491629        </iq>
    15501630        """
     1631
     1632        def affiliations(request):
     1633            affiliation = ('test', 'owner')
     1634            return defer.succeed([affiliation])
    15511635
    15521636        def cb(element):
     
    15621646            self.assertEqual('owner', affiliation['affiliation'])
    15631647
    1564 
    1565         def affiliations(requestor, service):
    1566             affiliation = ('test', 'owner')
    1567             return defer.succeed([affiliation])
    1568 
    1569         self.service.affiliations = affiliations
    1570         verify.verifyObject(iwokkel.IPubSubService, self.service)
    1571         d = self.handleRequest(xml)
    1572         d.addCallback(cb)
    1573         return d
    1574 
    1575 
    1576     def test_onCreate(self):
     1648        self.resource.affiliations = affiliations
     1649        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
     1650        d = self.handleRequest(xml)
     1651        d.addCallback(cb)
     1652        return d
     1653
     1654
     1655    def test_on_create(self):
    15771656        """
    15781657        Replies to create node requests don't return the created node.
     
    15881667        """
    15891668
    1590         def create(requestor, service, nodeIdentifier):
    1591             return defer.succeed(nodeIdentifier)
     1669        def create(request):
     1670            return defer.succeed(request.nodeIdentifier)
    15921671
    15931672        def cb(element):
    15941673            self.assertIdentical(None, element)
    15951674
    1596         self.service.create = create
    1597         verify.verifyObject(iwokkel.IPubSubService, self.service)
    1598         d = self.handleRequest(xml)
    1599         d.addCallback(cb)
    1600         return d
    1601 
    1602 
    1603     def test_onCreateChanged(self):
     1675        self.resource.create = create
     1676        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
     1677        d = self.handleRequest(xml)
     1678        d.addCallback(cb)
     1679        return d
     1680
     1681
     1682    def test_on_createChanged(self):
    16041683        """
    16051684        Replies to create node requests return the created node if changed.
     
    16151694        """
    16161695
    1617         def create(requestor, service, nodeIdentifier):
     1696        def create(request):
    16181697            return defer.succeed(u'myrenamednode')
    16191698
     
    16251704                             element.create.getAttribute('node'))
    16261705
    1627         self.service.create = create
    1628         verify.verifyObject(iwokkel.IPubSubService, self.service)
    1629         d = self.handleRequest(xml)
    1630         d.addCallback(cb)
    1631         return d
    1632 
    1633 
    1634     def test_onCreateInstant(self):
     1706        self.resource.create = create
     1707        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
     1708        d = self.handleRequest(xml)
     1709        d.addCallback(cb)
     1710        return d
     1711
     1712
     1713    def test_on_createInstant(self):
    16351714        """
    16361715        Replies to create instant node requests return the created node.
     
    16461725        """
    16471726
    1648         def create(requestor, service, nodeIdentifier):
     1727        def create(request):
    16491728            return defer.succeed(u'random')
    16501729
     
    16551734            self.assertEqual(u'random', element.create.getAttribute('node'))
    16561735
    1657         self.service.create = create
    1658         verify.verifyObject(iwokkel.IPubSubService, self.service)
    1659         d = self.handleRequest(xml)
    1660         d.addCallback(cb)
    1661         return d
    1662 
    1663 
    1664     def test_onDefault(self):
     1736        self.resource.create = create
     1737        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
     1738        d = self.handleRequest(xml)
     1739        d.addCallback(cb)
     1740        return d
     1741
     1742
     1743    def test_on_default(self):
    16651744        """
    16661745        A default request should result in
     
    16871766                }
    16881767
    1689         def getDefaultConfiguration(requestor, service, nodeType):
     1768        def default(request):
    16901769            return defer.succeed({})
    16911770
     
    16971776            self.assertEqual(NS_PUBSUB_CONFIG, form.formNamespace)
    16981777
    1699         self.service.getConfigurationOptions = getConfigurationOptions
    1700         self.service.getDefaultConfiguration = getDefaultConfiguration
    1701         verify.verifyObject(iwokkel.IPubSubService, self.service)
    1702         d = self.handleRequest(xml)
    1703         d.addCallback(cb)
    1704         return d
    1705 
    1706 
    1707     def test_onDefaultCollection(self):
     1778        self.resource.getConfigurationOptions = getConfigurationOptions
     1779        self.resource.default = default
     1780        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
     1781        d = self.handleRequest(xml)
     1782        d.addCallback(cb)
     1783        return d
     1784
     1785
     1786    def test_on_defaultCollection(self):
    17081787        """
    17091788        Responses to default requests should depend on passed node type.
     
    17361815                }
    17371816
    1738         def getDefaultConfiguration(requestor, service, nodeType):
     1817        def default(request):
    17391818            return defer.succeed({})
    17401819
    1741         self.service.getConfigurationOptions = getConfigurationOptions
    1742         self.service.getDefaultConfiguration = getDefaultConfiguration
    1743         verify.verifyObject(iwokkel.IPubSubService, self.service)
     1820        self.resource.getConfigurationOptions = getConfigurationOptions
     1821        self.resource.default = default
     1822        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
    17441823        return self.handleRequest(xml)
    17451824
    17461825
    1747     def test_onDefaultUnknownNodeType(self):
     1826    def test_on_defaultUnknownNodeType(self):
    17481827        """
    17491828        A default request should result in
    1750         L{PubSubService.getDefaultConfiguration} being called.
     1829        L{PubSubResource.default} being called.
    17511830        """
    17521831
     
    17701849        """
    17711850
    1772         def getDefaultConfiguration(requestor, service, nodeType):
     1851        def default(request):
    17731852            self.fail("Unexpected call to getConfiguration")
    17741853
     
    17761855            self.assertEquals('not-acceptable', result.condition)
    17771856
    1778         self.service.getDefaultConfiguration = getDefaultConfiguration
    1779         verify.verifyObject(iwokkel.IPubSubService, self.service)
    1780         d = self.handleRequest(xml)
    1781         self.assertFailure(d, error.StanzaError)
    1782         d.addCallback(cb)
    1783         return d
    1784 
    1785 
    1786     def test_onConfigureGet(self):
    1787         """
    1788         On a node configuration get request L{PubSubService.getConfiguration}
    1789         is called and results in a data form with the configuration.
     1857        self.resource.default = default
     1858        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
     1859        d = self.handleRequest(xml)
     1860        self.assertFailure(d, error.StanzaError)
     1861        d.addCallback(cb)
     1862        return d
     1863
     1864
     1865    def test_on_configureGet(self):
     1866        """
     1867        On a node configuration get
     1868        requestL{PubSubResource.configureGet} is called and results in a
     1869        data form with the configuration.
    17901870        """
    17911871
     
    18121892                }
    18131893
    1814         def getConfiguration(requestor, service, nodeIdentifier):
     1894        def configureGet(request):
    18151895            return defer.succeed({'pubsub#deliver_payloads': '0',
    18161896                                  'pubsub#persist_items': '1',
     
    18461926            self.assertNotIn('x-myfield', fields)
    18471927
    1848 
    1849         self.service.getConfigurationOptions = getConfigurationOptions
    1850         self.service.getConfiguration = getConfiguration
    1851         verify.verifyObject(iwokkel.IPubSubService, self.service)
    1852         d = self.handleRequest(xml)
    1853         d.addCallback(cb)
    1854         return d
    1855 
    1856 
    1857     def test_onConfigureSet(self):
     1928        self.resource.getConfigurationOptions = getConfigurationOptions
     1929        self.resource.configureGet = configureGet
     1930        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
     1931        d = self.handleRequest(xml)
     1932        d.addCallback(cb)
     1933        return d
     1934
     1935
     1936    def test_on_configureSet(self):
    18581937        """
    18591938        On a node configuration set request the Data Form is parsed and
    1860         L{PubSubService.setConfiguration} is called with the passed options.
     1939        L{PubSubResource.configureSet} is called with the passed options.
    18611940        """
    18621941
     
    18881967                }
    18891968
    1890         def setConfiguration(requestor, service, nodeIdentifier, options):
     1969        def configureSet(request):
    18911970            self.assertEqual({'pubsub#deliver_payloads': False,
    1892                               'pubsub#persist_items': True}, options)
     1971                              'pubsub#persist_items': True}, request.options)
    18931972            return defer.succeed(None)
    18941973
    1895         self.service.getConfigurationOptions = getConfigurationOptions
    1896         self.service.setConfiguration = setConfiguration
    1897         verify.verifyObject(iwokkel.IPubSubService, self.service)
     1974        self.resource.getConfigurationOptions = getConfigurationOptions
     1975        self.resource.configureSet = configureSet
     1976        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
    18981977        return self.handleRequest(xml)
    18991978
    19001979
    1901     def test_onConfigureSetCancel(self):
    1902         """
    1903         The node configuration is cancelled, L{PubSubService.setConfiguration}
    1904         not called.
     1980    def test_on_configureSetCancel(self):
     1981        """
     1982        The node configuration is cancelled,
     1983        L{PubSubResource.configureSet} not called.
    19051984        """
    19061985
     
    19201999        """
    19212000
    1922         def setConfiguration(requestor, service, nodeIdentifier, options):
     2001        def configureSet(request):
    19232002            self.fail("Unexpected call to setConfiguration")
    19242003
    1925         self.service.setConfiguration = setConfiguration
    1926         verify.verifyObject(iwokkel.IPubSubService, self.service)
     2004        self.resource.configureSet = configureSet
     2005        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
    19272006        return self.handleRequest(xml)
    19282007
    19292008
    1930     def test_onConfigureSetIgnoreUnknown(self):
     2009    def test_on_configureSetIgnoreUnknown(self):
    19312010        """
    19322011        On a node configuration set request unknown fields should be ignored.
     
    19602039                }
    19612040
    1962         def setConfiguration(requestor, service, nodeIdentifier, options):
    1963             self.assertEquals(['pubsub#deliver_payloads'], options.keys())
    1964 
    1965         self.service.getConfigurationOptions = getConfigurationOptions
    1966         self.service.setConfiguration = setConfiguration
    1967         verify.verifyObject(iwokkel.IPubSubService, self.service)
     2041        def configureSet(request):
     2042            self.assertEquals(['pubsub#deliver_payloads'],
     2043                              request.options.keys())
     2044
     2045        self.resource.getConfigurationOptions = getConfigurationOptions
     2046        self.resource.configureSet = configureSet
     2047        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
    19682048        return self.handleRequest(xml)
    19692049
    19702050
    1971     def test_onConfigureSetBadFormType(self):
     2051    def test_on_configureSetBadFormType(self):
    19722052        """
    19732053        On a node configuration set request unknown fields should be ignored.
     
    20002080
    20012081
    2002     def test_onItems(self):
     2082    def test_on_items(self):
    20032083        """
    20042084        On a items request, return all items for the given node.
     
    20132093        """
    20142094
    2015         def items(requestor, service, nodeIdentifier, maxItems,
    2016                   itemIdentifiers):
     2095        def items(request):
    20172096            return defer.succeed([pubsub.Item('current')])
    20182097
     
    20272106            self.assertEqual('current', item['id'])
    20282107
    2029         self.service.items = items
    2030         d = self.handleRequest(xml)
    2031         d.addCallback(cb)
    2032         return d
    2033 
    2034 
    2035     def test_onRetract(self):
    2036         """
    2037         A retract request should result in L{PubSubService.retract} being
    2038         called.
     2108        self.resource.items = items
     2109        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
     2110        d = self.handleRequest(xml)
     2111        d.addCallback(cb)
     2112        return d
     2113
     2114
     2115    def test_on_retract(self):
     2116        """
     2117        A retract request should result in L{PubSubResource.retract}
     2118        being called.
    20392119        """
    20402120
     
    20512131        """
    20522132
    2053         def retract(requestor, service, nodeIdentifier, itemIdentifiers):
     2133        def retract(request):
    20542134            return defer.succeed(None)
    20552135
    2056         self.service.retract = retract
     2136        self.resource.retract = retract
     2137        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
    20572138        return self.handleRequest(xml)
    20582139
    20592140
    2060     def test_onPurge(self):
    2061         """
    2062         A purge request should result in L{PubSubService.purge} being
     2141    def test_on_purge(self):
     2142        """
     2143        A purge request should result in L{PubSubResource.purge} being
    20632144        called.
    20642145        """
     
    20732154        """
    20742155
    2075         def purge(requestor, service, nodeIdentifier):
     2156        def purge(request):
    20762157            return defer.succeed(None)
    20772158
    2078         self.service.purge = purge
     2159        self.resource.purge = purge
     2160        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
    20792161        return self.handleRequest(xml)
    20802162
    20812163
    2082     def test_onDelete(self):
    2083         """
    2084         A delete request should result in L{PubSubService.delete} being
     2164    def test_on_delete(self):
     2165        """
     2166        A delete request should result in L{PubSubResource.delete} being
    20852167        called.
    20862168        """
     
    20952177        """
    20962178
    2097         def delete(requestor, service, nodeIdentifier):
     2179        def delete(request):
    20982180            return defer.succeed(None)
    20992181
    2100         self.service.delete = delete
     2182        self.resource.delete = delete
     2183        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
    21012184        return self.handleRequest(xml)
    21022185
     
    21492232
    21502233
    2151     def test_onSubscriptionsGet(self):
     2234    def test_on_subscriptionsGet(self):
    21522235        """
    21532236        Getting subscription options is not supported.
     
    21762259
    21772260
    2178     def test_onSubscriptionsSet(self):
     2261    def test_on_subscriptionsSet(self):
    21792262        """
    21802263        Setting subscription options is not supported.
     
    22032286
    22042287
    2205     def test_onAffiliationsGet(self):
     2288    def test_on_affiliationsGet(self):
    22062289        """
    22072290        Getting subscription options is not supported.
     
    22302313
    22312314
    2232     def test_onAffiliationsSet(self):
     2315    def test_on_affiliationsSet(self):
    22332316        """
    22342317        Setting subscription options is not supported.
     
    22552338        d.addCallback(cb)
    22562339        return d
     2340
     2341
     2342
     2343class PubSubServiceWithoutResourceTest(unittest.TestCase, TestableRequestHandlerMixin):
     2344
     2345    def setUp(self):
     2346        self.stub = XmlStreamStub()
     2347        self.service = pubsub.PubSubService()
     2348        self.service.send = self.stub.xmlstream.send
    22572349
    22582350
     
    26052697        d.addCallback(cb)
    26062698        return d
     2699
     2700
     2701
     2702class PubSubResourceTest(unittest.TestCase):
     2703
     2704    def setUp(self):
     2705        self.resource = pubsub.PubSubResource()
     2706
     2707
     2708    def test_interface(self):
     2709        """
     2710        Do instances of L{pubsub.PubSubResource} provide L{iwokkel.IPubSubResource}?
     2711        """
     2712        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
     2713
     2714
     2715    def test_getNodes(self):
     2716        """
     2717        Default getNodes returns an empty list.
     2718        """
     2719        def cb(nodes):
     2720            self.assertEquals([], nodes)
     2721
     2722        d = self.resource.getNodes(JID('user@example.org/home'),
     2723                                   JID('pubsub.example.org'),
     2724                                   '')
     2725        d.addCallback(cb)
     2726        return d
     2727
     2728
     2729    def test_publish(self):
     2730        """
     2731        Non-overridden L{PubSubResource.publish} yields unsupported
     2732        error.
     2733        """
     2734
     2735        def cb(result):
     2736            self.assertEquals('feature-not-implemented', result.condition)
     2737            self.assertEquals('unsupported', result.appCondition.name)
     2738            self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
     2739            self.assertEquals('publish', result.appCondition['feature'])
     2740
     2741        d = self.resource.publish(pubsub.PubSubRequest())
     2742        self.assertFailure(d, error.StanzaError)
     2743        d.addCallback(cb)
     2744        return d
     2745
     2746
     2747    def test_subscribe(self):
     2748        """
     2749        Non-overridden subscriptions yields unsupported error.
     2750        """
     2751
     2752        def cb(result):
     2753            self.assertEquals('feature-not-implemented', result.condition)
     2754            self.assertEquals('unsupported', result.appCondition.name)
     2755            self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
     2756            self.assertEquals('subscribe', result.appCondition['feature'])
     2757
     2758        d = self.resource.subscribe(pubsub.PubSubRequest())
     2759        self.assertFailure(d, error.StanzaError)
     2760        d.addCallback(cb)
     2761        return d
     2762
     2763
     2764    def test_unsubscribe(self):
     2765        """
     2766        Non-overridden unsubscribe yields unsupported error.
     2767        """
     2768
     2769        def cb(result):
     2770            self.assertEquals('feature-not-implemented', result.condition)
     2771            self.assertEquals('unsupported', result.appCondition.name)
     2772            self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
     2773            self.assertEquals('subscribe', result.appCondition['feature'])
     2774
     2775        d = self.resource.unsubscribe(pubsub.PubSubRequest())
     2776        self.assertFailure(d, error.StanzaError)
     2777        d.addCallback(cb)
     2778        return d
     2779
     2780
     2781    def test_subscriptions(self):
     2782        """
     2783        Non-overridden subscriptions yields unsupported error.
     2784        """
     2785
     2786        def cb(result):
     2787            self.assertEquals('feature-not-implemented', result.condition)
     2788            self.assertEquals('unsupported', result.appCondition.name)
     2789            self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
     2790            self.assertEquals('retrieve-subscriptions',
     2791                              result.appCondition['feature'])
     2792
     2793        d = self.resource.subscriptions(pubsub.PubSubRequest())
     2794        self.assertFailure(d, error.StanzaError)
     2795        d.addCallback(cb)
     2796        return d
     2797
     2798
     2799    def test_affiliations(self):
     2800        """
     2801        Non-overridden affiliations yields unsupported error.
     2802        """
     2803
     2804        def cb(result):
     2805            self.assertEquals('feature-not-implemented', result.condition)
     2806            self.assertEquals('unsupported', result.appCondition.name)
     2807            self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
     2808            self.assertEquals('retrieve-affiliations',
     2809                              result.appCondition['feature'])
     2810
     2811        d = self.resource.affiliations(pubsub.PubSubRequest())
     2812        self.assertFailure(d, error.StanzaError)
     2813        d.addCallback(cb)
     2814        return d
     2815
     2816
     2817    def test_create(self):
     2818        """
     2819        Non-overridden create yields unsupported error.
     2820        """
     2821
     2822        def cb(result):
     2823            self.assertEquals('feature-not-implemented', result.condition)
     2824            self.assertEquals('unsupported', result.appCondition.name)
     2825            self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
     2826            self.assertEquals('create-nodes', result.appCondition['feature'])
     2827
     2828        d = self.resource.create(pubsub.PubSubRequest())
     2829        self.assertFailure(d, error.StanzaError)
     2830        d.addCallback(cb)
     2831        return d
     2832
     2833
     2834    def test_default(self):
     2835        """
     2836        Non-overridden default yields unsupported error.
     2837        """
     2838
     2839        def cb(result):
     2840            self.assertEquals('feature-not-implemented', result.condition)
     2841            self.assertEquals('unsupported', result.appCondition.name)
     2842            self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
     2843            self.assertEquals('retrieve-default',
     2844                              result.appCondition['feature'])
     2845
     2846        d = self.resource.default(pubsub.PubSubRequest())
     2847        self.assertFailure(d, error.StanzaError)
     2848        d.addCallback(cb)
     2849        return d
     2850
     2851
     2852    def test_configureGet(self):
     2853        """
     2854        Non-overridden configureGet yields unsupported
     2855        error.
     2856        """
     2857
     2858        def cb(result):
     2859            self.assertEquals('feature-not-implemented', result.condition)
     2860            self.assertEquals('unsupported', result.appCondition.name)
     2861            self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
     2862            self.assertEquals('config-node', result.appCondition['feature'])
     2863
     2864        d = self.resource.configureGet(pubsub.PubSubRequest())
     2865        self.assertFailure(d, error.StanzaError)
     2866        d.addCallback(cb)
     2867        return d
     2868
     2869
     2870    def test_configureSet(self):
     2871        """
     2872        Non-overridden configureSet yields unsupported error.
     2873        """
     2874
     2875        def cb(result):
     2876            self.assertEquals('feature-not-implemented', result.condition)
     2877            self.assertEquals('unsupported', result.appCondition.name)
     2878            self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
     2879            self.assertEquals('config-node', result.appCondition['feature'])
     2880
     2881        d = self.resource.configureSet(pubsub.PubSubRequest())
     2882        self.assertFailure(d, error.StanzaError)
     2883        d.addCallback(cb)
     2884        return d
     2885
     2886
     2887    def test_items(self):
     2888        """
     2889        Non-overridden items yields unsupported error.
     2890        """
     2891
     2892        def cb(result):
     2893            self.assertEquals('feature-not-implemented', result.condition)
     2894            self.assertEquals('unsupported', result.appCondition.name)
     2895            self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
     2896            self.assertEquals('retrieve-items', result.appCondition['feature'])
     2897
     2898        d = self.resource.items(pubsub.PubSubRequest())
     2899        self.assertFailure(d, error.StanzaError)
     2900        d.addCallback(cb)
     2901        return d
     2902
     2903
     2904    def test_retract(self):
     2905        """
     2906        Non-overridden retract yields unsupported error.
     2907        """
     2908
     2909        def cb(result):
     2910            self.assertEquals('feature-not-implemented', result.condition)
     2911            self.assertEquals('unsupported', result.appCondition.name)
     2912            self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
     2913            self.assertEquals('retract-items', result.appCondition['feature'])
     2914
     2915        d = self.resource.retract(pubsub.PubSubRequest())
     2916        self.assertFailure(d, error.StanzaError)
     2917        d.addCallback(cb)
     2918        return d
     2919
     2920
     2921    def test_purge(self):
     2922        """
     2923        Non-overridden purge yields unsupported error.
     2924        """
     2925
     2926        def cb(result):
     2927            self.assertEquals('feature-not-implemented', result.condition)
     2928            self.assertEquals('unsupported', result.appCondition.name)
     2929            self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
     2930            self.assertEquals('purge-nodes', result.appCondition['feature'])
     2931
     2932        d = self.resource.purge(pubsub.PubSubRequest())
     2933        self.assertFailure(d, error.StanzaError)
     2934        d.addCallback(cb)
     2935        return d
     2936
     2937
     2938    def test_delete(self):
     2939        """
     2940        Non-overridden delete yields unsupported error.
     2941        """
     2942
     2943        def cb(result):
     2944            self.assertEquals('feature-not-implemented', result.condition)
     2945            self.assertEquals('unsupported', result.appCondition.name)
     2946            self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
     2947            self.assertEquals('delete-nodes', result.appCondition['feature'])
     2948
     2949        d = self.resource.delete(pubsub.PubSubRequest())
     2950        self.assertFailure(d, error.StanzaError)
     2951        d.addCallback(cb)
     2952        return d
Note: See TracChangeset for help on using the changeset viewer.