Ignore:
Timestamp:
Jan 5, 2010, 2:55:40 PM (12 years ago)
Author:
Ralph Meijer <ralphm@…>
Branch:
default
Message:

Add support for pubsub subscription identifiers

File:
1 edited

Legend:

Unmodified
Added
Removed
  • wokkel/test/test_pubsub.py

    r83 r84  
    4242
    4343    return d, func
     44
     45
     46class SubscriptionTest(unittest.TestCase):
     47    """
     48    Tests for L{pubsub.Subscription}.
     49    """
     50
     51    def test_fromElement(self):
     52        """
     53        fromElement parses a subscription from XML DOM.
     54        """
     55        xml = """
     56        <subscription node='test' jid='user@example.org/Home'
     57                      subscription='pending'/>
     58        """
     59        subscription = pubsub.Subscription.fromElement(parseXml(xml))
     60        self.assertEqual('test', subscription.nodeIdentifier)
     61        self.assertEqual(JID('user@example.org/Home'), subscription.subscriber)
     62        self.assertEqual('pending', subscription.state)
     63        self.assertIdentical(None, subscription.subscriptionIdentifier)
     64
     65
     66    def test_fromElementWithSubscriptionIdentifier(self):
     67        """
     68        A subscription identifier in the subscription should be parsed, too.
     69        """
     70        xml = """
     71        <subscription node='test' jid='user@example.org/Home' subid='1234'
     72                      subscription='pending'/>
     73        """
     74        subscription = pubsub.Subscription.fromElement(parseXml(xml))
     75        self.assertEqual('1234', subscription.subscriptionIdentifier)
     76
     77
     78    def test_toElement(self):
     79        """
     80        Rendering a Subscription should yield the proper attributes.
     81        """
     82        subscription = pubsub.Subscription('test',
     83                                           JID('user@example.org/Home'),
     84                                           'pending')
     85        element = subscription.toElement()
     86        self.assertEqual('subscription', element.name)
     87        self.assertEqual(None, element.uri)
     88        self.assertEqual('test', element.getAttribute('node'))
     89        self.assertEqual('user@example.org/Home', element.getAttribute('jid'))
     90        self.assertEqual('pending', element.getAttribute('subscription'))
     91        self.assertFalse(element.hasAttribute('subid'))
     92
     93
     94    def test_toElementEmptyNodeIdentifier(self):
     95        """
     96        The empty node identifier should not yield a node attribute.
     97        """
     98        subscription = pubsub.Subscription('',
     99                                           JID('user@example.org/Home'),
     100                                           'pending')
     101        element = subscription.toElement()
     102        self.assertFalse(element.hasAttribute('node'))
     103
     104
     105    def test_toElementWithSubscriptionIdentifier(self):
     106        """
     107        The subscription identifier, if set, is in the subid attribute.
     108        """
     109        subscription = pubsub.Subscription('test',
     110                                           JID('user@example.org/Home'),
     111                                           'pending',
     112                                           subscriptionIdentifier='1234')
     113        element = subscription.toElement()
     114        self.assertEqual('1234', element.getAttribute('subid'))
     115
    44116
    45117
     
    444516
    445517
     518    def test_subscribeReturnsSubscription(self):
     519        """
     520        A successful subscription should return a Subscription instance.
     521        """
     522        def cb(subscription):
     523            self.assertEqual(JID('user@example.org'), subscription.subscriber)
     524
     525        d = self.protocol.subscribe(JID('pubsub.example.org'), 'test',
     526                                      JID('user@example.org'))
     527        d.addCallback(cb)
     528
     529        iq = self.stub.output[-1]
     530
     531        response = toResponse(iq, 'result')
     532        pubsub = response.addElement((NS_PUBSUB, 'pubsub'))
     533        subscription = pubsub.addElement('subscription')
     534        subscription['node'] = 'test'
     535        subscription['jid'] = 'user@example.org'
     536        subscription['subscription'] = 'subscribed'
     537        self.stub.send(response)
     538        return d
     539
     540
    446541    def test_subscribePending(self):
    447542        """
     
    534629        subscription['jid'] = 'user@example.org'
    535630        subscription['subscription'] = 'subscribed'
     631        self.stub.send(response)
     632        return d
     633
     634
     635    def test_subscribeReturningSubscriptionIdentifier(self):
     636        """
     637        Test sending subscription request with subscription identifier.
     638        """
     639        def cb(subscription):
     640            self.assertEqual('1234', subscription.subscriptionIdentifier)
     641
     642        d = self.protocol.subscribe(JID('pubsub.example.org'), 'test',
     643                                      JID('user@example.org'))
     644        d.addCallback(cb)
     645
     646        iq = self.stub.output[-1]
     647
     648        response = toResponse(iq, 'result')
     649        pubsub = response.addElement((NS_PUBSUB, 'pubsub'))
     650        subscription = pubsub.addElement('subscription')
     651        subscription['node'] = 'test'
     652        subscription['jid'] = 'user@example.org'
     653        subscription['subscription'] = 'subscribed'
     654        subscription['subid'] = '1234'
    536655        self.stub.send(response)
    537656        return d
     
    575694
    576695
     696    def test_unsubscribeWithSubscriptionIdentifier(self):
     697        """
     698        Test sending unsubscription request with subscription identifier.
     699        """
     700        d = self.protocol.unsubscribe(JID('pubsub.example.org'), 'test',
     701                                      JID('user@example.org'),
     702                                      subscriptionIdentifier='1234')
     703
     704        iq = self.stub.output[-1]
     705        child = iq.pubsub.unsubscribe
     706        self.assertEquals('1234', child['subid'])
     707
     708        self.stub.send(toResponse(iq, 'result'))
     709        return d
     710
     711
    577712    def test_items(self):
    578713        """
     
    641776
    642777
     778    def test_itemsWithSubscriptionIdentifier(self):
     779        """
     780        Test sending items request with a subscription identifier.
     781        """
     782
     783        d = self.protocol.items(JID('pubsub.example.org'), 'test',
     784                               subscriptionIdentifier='1234')
     785
     786        iq = self.stub.output[-1]
     787        child = iq.pubsub.items
     788        self.assertEquals('1234', child['subid'])
     789
     790        response = toResponse(iq, 'result')
     791        items = response.addElement((NS_PUBSUB, 'pubsub')).addElement('items')
     792        items['node'] = 'test'
     793
     794        self.stub.send(response)
     795        return d
     796
     797
    643798    def test_itemsWithSender(self):
    644799        """
     
    701856
    702857
     858    def test_getOptionsWithSubscriptionIdentifier(self):
     859        """
     860        Getting options with a subid should have the subid in the request.
     861        """
     862
     863        d = self.protocol.getOptions(JID('pubsub.example.org'), 'test',
     864                                     JID('user@example.org'),
     865                                     sender=JID('user@example.org'),
     866                                     subscriptionIdentifier='1234')
     867
     868        iq = self.stub.output[-1]
     869        child = iq.pubsub.options
     870        self.assertEqual('1234', child['subid'])
     871
     872        # Send response
     873        form = data_form.Form('form', formNamespace=NS_PUBSUB_SUBSCRIBE_OPTIONS)
     874        form.addField(data_form.Field('boolean', var='pubsub#deliver',
     875                                                 label='Enable delivery?',
     876                                                 value=True))
     877        response = toResponse(iq, 'result')
     878        response.addElement((NS_PUBSUB, 'pubsub'))
     879        response.pubsub.addElement('options')
     880        response.pubsub.options.addChild(form.toElement())
     881        self.stub.send(response)
     882
     883        return d
     884
     885
    703886    def test_setOptions(self):
    704887        """
     
    722905        child = children[0]
    723906        self.assertEqual('test', child['node'])
     907
     908        form = data_form.findForm(child, NS_PUBSUB_SUBSCRIBE_OPTIONS)
     909        self.assertEqual('submit', form.formType)
     910        form.typeCheck({'pubsub#deliver': {'type': 'boolean'}})
     911        self.assertEqual(options, form.getValues())
     912
     913        response = toResponse(iq, 'result')
     914        self.stub.send(response)
     915
     916        return d
     917
     918
     919    def test_setOptionsWithSubscriptionIdentifier(self):
     920        """
     921        setOptions should send out a options-set request with subid.
     922        """
     923        options = {'pubsub#deliver': False}
     924
     925        d = self.protocol.setOptions(JID('pubsub.example.org'), 'test',
     926                                     JID('user@example.org'),
     927                                     options,
     928                                     subscriptionIdentifier='1234',
     929                                     sender=JID('user@example.org'))
     930
     931        iq = self.stub.output[-1]
     932        child = iq.pubsub.options
     933        self.assertEqual('1234', child['subid'])
    724934
    725935        form = data_form.findForm(child, NS_PUBSUB_SUBSCRIBE_OPTIONS)
     
    10041214
    10051215
     1216    def test_fromElementUnsubscribeWithSubscriptionIdentifier(self):
     1217        """
     1218        Test parsing an unsubscription request with subscription identifier.
     1219        """
     1220
     1221        xml = """
     1222        <iq type='set' to='pubsub.example.org'
     1223                       from='user@example.org'>
     1224          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
     1225            <unsubscribe node='test' jid='user@example.org/Home'
     1226                         subid='1234'/>
     1227          </pubsub>
     1228        </iq>
     1229        """
     1230
     1231        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
     1232        self.assertEqual('1234', request.subscriptionIdentifier)
     1233
     1234
    10061235    def test_fromElementUnsubscribeNoJID(self):
    10071236        """
     
    10401269        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
    10411270        self.assertEqual('optionsGet', request.verb)
     1271        self.assertEqual(JID('user@example.org'), request.sender)
     1272        self.assertEqual(JID('pubsub.example.org'), request.recipient)
     1273        self.assertEqual('test', request.nodeIdentifier)
     1274        self.assertEqual(JID('user@example.org/Home'), request.subscriber)
     1275
     1276
     1277    def test_fromElementOptionsGetWithSubscriptionIdentifier(self):
     1278        """
     1279        Test parsing a request for getting subscription options with subid.
     1280        """
     1281
     1282        xml = """
     1283        <iq type='get' to='pubsub.example.org'
     1284                       from='user@example.org'>
     1285          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
     1286            <options node='test' jid='user@example.org/Home'
     1287                     subid='1234'/>
     1288          </pubsub>
     1289        </iq>
     1290        """
     1291
     1292        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
     1293        self.assertEqual('1234', request.subscriptionIdentifier)
    10421294
    10431295
     
    10701322        self.assertEqual(JID('user@example.org/Home'), request.subscriber)
    10711323        self.assertEqual({'pubsub#deliver': '1'}, request.options.getValues())
     1324
     1325
     1326    def test_fromElementOptionsSetWithSubscriptionIdentifier(self):
     1327        """
     1328        Test parsing a request for setting subscription options with subid.
     1329        """
     1330
     1331        xml = """
     1332        <iq type='set' to='pubsub.example.org'
     1333                       from='user@example.org'>
     1334          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
     1335            <options node='test' jid='user@example.org/Home'
     1336                     subid='1234'>
     1337              <x xmlns='jabber:x:data' type='submit'>
     1338                <field var='FORM_TYPE' type='hidden'>
     1339                  <value>http://jabber.org/protocol/pubsub#subscribe_options</value>
     1340                </field>
     1341                <field var='pubsub#deliver'><value>1</value></field>
     1342              </x>
     1343            </options>
     1344          </pubsub>
     1345        </iq>
     1346        """
     1347
     1348        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
     1349        self.assertEqual('1234', request.subscriptionIdentifier)
    10721350
    10731351
     
    15151793        self.assertEqual('test', request.nodeIdentifier)
    15161794        self.assertIdentical(None, request.maxItems)
     1795        self.assertIdentical(None, request.subscriptionIdentifier)
    15171796        self.assertEqual([], request.itemIdentifiers)
     1797
     1798
     1799    def test_fromElementItemsSubscriptionIdentifier(self):
     1800        """
     1801        Test parsing an items request with subscription identifier.
     1802        """
     1803        xml = """
     1804        <iq type='get' to='pubsub.example.org'
     1805                       from='user@example.org'>
     1806          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
     1807            <items node='test' subid='1234'/>
     1808          </pubsub>
     1809        </iq>
     1810        """
     1811
     1812        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
     1813        self.assertEqual('1234', request.subscriptionIdentifier)
    15181814
    15191815
     
    18182114            self.assertEqual(NS_PUBSUB, element.uri)
    18192115            subscription = element.subscription
    1820             self.assertEqual(NS_PUBSUB, subscription.uri)
     2116            self.assertIn(subscription.uri, (None, NS_PUBSUB))
    18212117            self.assertEqual('test', subscription['node'])
    18222118            self.assertEqual('user@example.org/Home', subscription['jid'])
     
    18592155
    18602156
     2157    def test_on_subscribeSubscriptionIdentifier(self):
     2158        """
     2159        If a subscription returns a subid, this should be available.
     2160        """
     2161
     2162        xml = """
     2163        <iq type='set' to='pubsub.example.org'
     2164                       from='user@example.org'>
     2165          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
     2166            <subscribe node='test' jid='user@example.org/Home'/>
     2167          </pubsub>
     2168        </iq>
     2169        """
     2170
     2171        def subscribe(request):
     2172            subscription = pubsub.Subscription(request.nodeIdentifier,
     2173                                               request.subscriber,
     2174                                               'subscribed',
     2175                                               subscriptionIdentifier='1234')
     2176            return defer.succeed(subscription)
     2177
     2178        def cb(element):
     2179            self.assertEqual('1234', element.subscription.getAttribute('subid'))
     2180
     2181        self.resource.subscribe = subscribe
     2182        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
     2183        d = self.handleRequest(xml)
     2184        d.addCallback(cb)
     2185        return d
     2186
     2187
    18612188    def test_on_unsubscribe(self):
    18622189        """
     
    18742201
    18752202        def unsubscribe(request):
     2203            return defer.succeed(None)
     2204
     2205        def cb(element):
     2206            self.assertIdentical(None, element)
     2207
     2208        self.resource.unsubscribe = unsubscribe
     2209        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
     2210        d = self.handleRequest(xml)
     2211        d.addCallback(cb)
     2212        return d
     2213
     2214
     2215    def test_on_unsubscribe(self):
     2216        """
     2217        A successful unsubscription with subid should return an empty response.
     2218        """
     2219
     2220        xml = """
     2221        <iq type='set' to='pubsub.example.org'
     2222                       from='user@example.org'>
     2223          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
     2224            <unsubscribe node='test' jid='user@example.org/Home' subid='1234'/>
     2225          </pubsub>
     2226        </iq>
     2227        """
     2228
     2229        def unsubscribe(request):
     2230            self.assertEqual('1234', request.subscriptionIdentifier)
    18762231            return defer.succeed(None)
    18772232
     
    19722327            subscription = children[0]
    19732328            self.assertEqual('subscription', subscription.name)
    1974             self.assertEqual(NS_PUBSUB, subscription.uri)
     2329            self.assertIn(subscription.uri, (None, NS_PUBSUB))
    19752330            self.assertEqual('user@example.org', subscription['jid'])
    19762331            self.assertEqual('test', subscription['node'])
    19772332            self.assertEqual('subscribed', subscription['subscription'])
     2333
     2334        self.resource.subscriptions = subscriptions
     2335        verify.verifyObject(iwokkel.IPubSubResource, self.resource)
     2336        d = self.handleRequest(xml)
     2337        d.addCallback(cb)
     2338        return d
     2339
     2340
     2341    def test_on_subscriptionsWithSubscriptionIdentifier(self):
     2342        """
     2343        A subscriptions request response should include subids, if set.
     2344        """
     2345
     2346        xml = """
     2347        <iq type='get' to='pubsub.example.org'
     2348                       from='user@example.org'>
     2349          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
     2350            <subscriptions/>
     2351          </pubsub>
     2352        </iq>
     2353        """
     2354
     2355        def subscriptions(request):
     2356            subscription = pubsub.Subscription('test', JID('user@example.org'),
     2357                                               'subscribed',
     2358                                               subscriptionIdentifier='1234')
     2359            return defer.succeed([subscription])
     2360
     2361        def cb(element):
     2362            subscription = element.subscriptions.subscription
     2363            self.assertEqual('1234', subscription['subid'])
    19782364
    19792365        self.resource.subscriptions = subscriptions
Note: See TracChangeset for help on using the changeset viewer.