source: wokkel/test/test_pubsub.py @ 30:68535ae85c8d

Last change on this file since 30:68535ae85c8d was 30:68535ae85c8d, checked in by Ralph Meijer <ralphm@…>, 13 years ago

Add support for pubsub collections.

File size: 30.6 KB
Line 
1# Copyright (c) 2003-2008 Ralph Meijer
2# See LICENSE for details.
3
4"""
5Tests for L{wokkel.pubsub}
6"""
7
8from zope.interface import verify
9
10from twisted.trial import unittest
11from twisted.internet import defer
12from twisted.words.xish import domish, xpath
13from twisted.words.protocols.jabber import error
14from twisted.words.protocols.jabber.jid import JID
15
16from wokkel import data_form, iwokkel, pubsub, shim
17from wokkel.generic import parseXml
18from wokkel.test.helpers import XmlStreamStub
19
20try:
21    from twisted.words.protocols.jabber.xmlstream import toResponse
22except ImportError:
23    from wokkel.compat import toResponse
24
25NS_PUBSUB = 'http://jabber.org/protocol/pubsub'
26NS_PUBSUB_CONFIG = 'http://jabber.org/protocol/pubsub#node_config'
27NS_PUBSUB_ERRORS = 'http://jabber.org/protocol/pubsub#errors'
28NS_PUBSUB_EVENT = 'http://jabber.org/protocol/pubsub#event'
29NS_PUBSUB_OWNER = 'http://jabber.org/protocol/pubsub#owner'
30
31def calledAsync(fn):
32    """
33    Function wrapper that fires a deferred upon calling the given function.
34    """
35    d = defer.Deferred()
36
37    def func(*args, **kwargs):
38        try:
39            result = fn(*args, **kwargs)
40        except:
41            d.errback()
42        else:
43            d.callback(result)
44
45    return d, func
46
47
48class PubSubClientTest(unittest.TestCase):
49    timeout = 2
50
51    def setUp(self):
52        self.stub = XmlStreamStub()
53        self.protocol = pubsub.PubSubClient()
54        self.protocol.xmlstream = self.stub.xmlstream
55        self.protocol.connectionInitialized()
56
57
58    def test_interface(self):
59        """
60        Do instances of L{pubsub.PubSubClient} provide L{iwokkel.IPubSubClient}?
61        """
62        verify.verifyObject(iwokkel.IPubSubClient, self.protocol)
63
64
65    def test_eventItems(self):
66        """
67        Test receiving an items event resulting in a call to itemsReceived.
68        """
69        message = domish.Element((None, 'message'))
70        message['from'] = 'pubsub.example.org'
71        message['to'] = 'user@example.org/home'
72        event = message.addElement((NS_PUBSUB_EVENT, 'event'))
73        items = event.addElement('items')
74        items['node'] = 'test'
75        item1 = items.addElement('item')
76        item1['id'] = 'item1'
77        item2 = items.addElement('retract')
78        item2['id'] = 'item2'
79        item3 = items.addElement('item')
80        item3['id'] = 'item3'
81
82        def itemsReceived(event):
83            self.assertEquals(JID('user@example.org/home'), event.recipient)
84            self.assertEquals(JID('pubsub.example.org'), event.sender)
85            self.assertEquals('test', event.nodeIdentifier)
86            self.assertEquals([item1, item2, item3], event.items)
87
88        d, self.protocol.itemsReceived = calledAsync(itemsReceived)
89        self.stub.send(message)
90        return d
91
92
93    def test_eventItemsCollection(self):
94        """
95        Test receiving an items event resulting in a call to itemsReceived.
96        """
97        message = domish.Element((None, 'message'))
98        message['from'] = 'pubsub.example.org'
99        message['to'] = 'user@example.org/home'
100        event = message.addElement((NS_PUBSUB_EVENT, 'event'))
101        items = event.addElement('items')
102        items['node'] = 'test'
103
104        headers = shim.Headers([('Collection', 'collection')])
105        message.addChild(headers)
106
107        def itemsReceived(event):
108            self.assertEquals(JID('user@example.org/home'), event.recipient)
109            self.assertEquals(JID('pubsub.example.org'), event.sender)
110            self.assertEquals('test', event.nodeIdentifier)
111            self.assertEquals({'Collection': ['collection']}, event.headers)
112
113        d, self.protocol.itemsReceived = calledAsync(itemsReceived)
114        self.stub.send(message)
115        return d
116
117
118    def test_event_delete(self):
119        """
120        Test receiving a delete event resulting in a call to deleteReceived.
121        """
122        message = domish.Element((None, 'message'))
123        message['from'] = 'pubsub.example.org'
124        message['to'] = 'user@example.org/home'
125        event = message.addElement((NS_PUBSUB_EVENT, 'event'))
126        items = event.addElement('delete')
127        items['node'] = 'test'
128
129        def deleteReceived(event):
130            self.assertEquals(JID('user@example.org/home'), event.recipient)
131            self.assertEquals(JID('pubsub.example.org'), event.sender)
132            self.assertEquals('test', event.nodeIdentifier)
133
134        d, self.protocol.deleteReceived = calledAsync(deleteReceived)
135        self.stub.send(message)
136        return d
137
138
139    def test_event_purge(self):
140        """
141        Test receiving a purge event resulting in a call to purgeReceived.
142        """
143        message = domish.Element((None, 'message'))
144        message['from'] = 'pubsub.example.org'
145        message['to'] = 'user@example.org/home'
146        event = message.addElement((NS_PUBSUB_EVENT, 'event'))
147        items = event.addElement('purge')
148        items['node'] = 'test'
149
150        def purgeReceived(event):
151            self.assertEquals(JID('user@example.org/home'), event.recipient)
152            self.assertEquals(JID('pubsub.example.org'), event.sender)
153            self.assertEquals('test', event.nodeIdentifier)
154
155        d, self.protocol.purgeReceived = calledAsync(purgeReceived)
156        self.stub.send(message)
157        return d
158
159
160    def test_createNode(self):
161        """
162        Test sending create request.
163        """
164
165        def cb(nodeIdentifier):
166            self.assertEquals('test', nodeIdentifier)
167
168        d = self.protocol.createNode(JID('pubsub.example.org'), 'test')
169        d.addCallback(cb)
170
171        iq = self.stub.output[-1]
172        self.assertEquals('pubsub.example.org', iq.getAttribute('to'))
173        self.assertEquals('set', iq.getAttribute('type'))
174        self.assertEquals('pubsub', iq.pubsub.name)
175        self.assertEquals(NS_PUBSUB, iq.pubsub.uri)
176        children = list(domish.generateElementsQNamed(iq.pubsub.children,
177                                                      'create', NS_PUBSUB))
178        self.assertEquals(1, len(children))
179        child = children[0]
180        self.assertEquals('test', child['node'])
181
182        response = toResponse(iq, 'result')
183        self.stub.send(response)
184        return d
185
186
187    def test_createNodeInstant(self):
188        """
189        Test sending create request resulting in an instant node.
190        """
191
192        def cb(nodeIdentifier):
193            self.assertEquals('test', nodeIdentifier)
194
195        d = self.protocol.createNode(JID('pubsub.example.org'))
196        d.addCallback(cb)
197
198        iq = self.stub.output[-1]
199        children = list(domish.generateElementsQNamed(iq.pubsub.children,
200                                                      'create', NS_PUBSUB))
201        child = children[0]
202        self.assertFalse(child.hasAttribute('node'))
203
204        response = toResponse(iq, 'result')
205        command = response.addElement((NS_PUBSUB, 'pubsub'))
206        create = command.addElement('create')
207        create['node'] = 'test'
208        self.stub.send(response)
209        return d
210
211
212    def test_createNodeRenamed(self):
213        """
214        Test sending create request resulting in renamed node.
215        """
216
217        def cb(nodeIdentifier):
218            self.assertEquals('test2', nodeIdentifier)
219
220        d = self.protocol.createNode(JID('pubsub.example.org'), 'test')
221        d.addCallback(cb)
222
223        iq = self.stub.output[-1]
224        children = list(domish.generateElementsQNamed(iq.pubsub.children,
225                                                      'create', NS_PUBSUB))
226        child = children[0]
227        self.assertEquals('test', child['node'])
228
229        response = toResponse(iq, 'result')
230        command = response.addElement((NS_PUBSUB, 'pubsub'))
231        create = command.addElement('create')
232        create['node'] = 'test2'
233        self.stub.send(response)
234        return d
235
236
237    def test_deleteNode(self):
238        """
239        Test sending delete request.
240        """
241
242        d = self.protocol.deleteNode(JID('pubsub.example.org'), 'test')
243
244        iq = self.stub.output[-1]
245        self.assertEquals('pubsub.example.org', iq.getAttribute('to'))
246        self.assertEquals('set', iq.getAttribute('type'))
247        self.assertEquals('pubsub', iq.pubsub.name)
248        self.assertEquals(NS_PUBSUB, iq.pubsub.uri)
249        children = list(domish.generateElementsQNamed(iq.pubsub.children,
250                                                      'delete', NS_PUBSUB))
251        self.assertEquals(1, len(children))
252        child = children[0]
253        self.assertEquals('test', child['node'])
254
255        response = toResponse(iq, 'result')
256        self.stub.send(response)
257        return d
258
259
260    def test_publish(self):
261        """
262        Test sending publish request.
263        """
264
265        item = pubsub.Item()
266        d = self.protocol.publish(JID('pubsub.example.org'), 'test', [item])
267
268        iq = self.stub.output[-1]
269        self.assertEquals('pubsub.example.org', iq.getAttribute('to'))
270        self.assertEquals('set', iq.getAttribute('type'))
271        self.assertEquals('pubsub', iq.pubsub.name)
272        self.assertEquals(NS_PUBSUB, iq.pubsub.uri)
273        children = list(domish.generateElementsQNamed(iq.pubsub.children,
274                                                      'publish', NS_PUBSUB))
275        self.assertEquals(1, len(children))
276        child = children[0]
277        self.assertEquals('test', child['node'])
278        items = list(domish.generateElementsQNamed(child.children,
279                                                   'item', NS_PUBSUB))
280        self.assertEquals(1, len(items))
281        self.assertIdentical(item, items[0])
282
283        response = toResponse(iq, 'result')
284        self.stub.send(response)
285        return d
286
287
288    def test_publishNoItems(self):
289        """
290        Test sending publish request without items.
291        """
292
293        d = self.protocol.publish(JID('pubsub.example.org'), 'test')
294
295        iq = self.stub.output[-1]
296        self.assertEquals('pubsub.example.org', iq.getAttribute('to'))
297        self.assertEquals('set', iq.getAttribute('type'))
298        self.assertEquals('pubsub', iq.pubsub.name)
299        self.assertEquals(NS_PUBSUB, iq.pubsub.uri)
300        children = list(domish.generateElementsQNamed(iq.pubsub.children,
301                                                      'publish', NS_PUBSUB))
302        self.assertEquals(1, len(children))
303        child = children[0]
304        self.assertEquals('test', child['node'])
305
306        response = toResponse(iq, 'result')
307        self.stub.send(response)
308        return d
309
310
311    def test_subscribe(self):
312        """
313        Test sending subscription request.
314        """
315        d = self.protocol.subscribe(JID('pubsub.example.org'), 'test',
316                                      JID('user@example.org'))
317
318        iq = self.stub.output[-1]
319        self.assertEquals('pubsub.example.org', iq.getAttribute('to'))
320        self.assertEquals('set', iq.getAttribute('type'))
321        self.assertEquals('pubsub', iq.pubsub.name)
322        self.assertEquals(NS_PUBSUB, iq.pubsub.uri)
323        children = list(domish.generateElementsQNamed(iq.pubsub.children,
324                                                      'subscribe', NS_PUBSUB))
325        self.assertEquals(1, len(children))
326        child = children[0]
327        self.assertEquals('test', child['node'])
328        self.assertEquals('user@example.org', child['jid'])
329
330        response = toResponse(iq, 'result')
331        pubsub = response.addElement((NS_PUBSUB, 'pubsub'))
332        subscription = pubsub.addElement('subscription')
333        subscription['node'] = 'test'
334        subscription['jid'] = 'user@example.org'
335        subscription['subscription'] = 'subscribed'
336        self.stub.send(response)
337        return d
338
339
340    def test_subscribePending(self):
341        """
342        Test sending subscription request that results in a pending
343        subscription.
344        """
345        d = self.protocol.subscribe(JID('pubsub.example.org'), 'test',
346                                      JID('user@example.org'))
347
348        iq = self.stub.output[-1]
349        response = toResponse(iq, 'result')
350        command = response.addElement((NS_PUBSUB, 'pubsub'))
351        subscription = command.addElement('subscription')
352        subscription['node'] = 'test'
353        subscription['jid'] = 'user@example.org'
354        subscription['subscription'] = 'pending'
355        self.stub.send(response)
356        self.assertFailure(d, pubsub.SubscriptionPending)
357        return d
358
359
360    def test_subscribeUnconfigured(self):
361        """
362        Test sending subscription request that results in an unconfigured
363        subscription.
364        """
365        d = self.protocol.subscribe(JID('pubsub.example.org'), 'test',
366                                      JID('user@example.org'))
367
368        iq = self.stub.output[-1]
369        response = toResponse(iq, 'result')
370        command = response.addElement((NS_PUBSUB, 'pubsub'))
371        subscription = command.addElement('subscription')
372        subscription['node'] = 'test'
373        subscription['jid'] = 'user@example.org'
374        subscription['subscription'] = 'unconfigured'
375        self.stub.send(response)
376        self.assertFailure(d, pubsub.SubscriptionUnconfigured)
377        return d
378
379
380    def test_unsubscribe(self):
381        """
382        Test sending unsubscription request.
383        """
384        d = self.protocol.unsubscribe(JID('pubsub.example.org'), 'test',
385                                      JID('user@example.org'))
386
387        iq = self.stub.output[-1]
388        self.assertEquals('pubsub.example.org', iq.getAttribute('to'))
389        self.assertEquals('set', iq.getAttribute('type'))
390        self.assertEquals('pubsub', iq.pubsub.name)
391        self.assertEquals(NS_PUBSUB, iq.pubsub.uri)
392        children = list(domish.generateElementsQNamed(iq.pubsub.children,
393                                                      'unsubscribe', NS_PUBSUB))
394        self.assertEquals(1, len(children))
395        child = children[0]
396        self.assertEquals('test', child['node'])
397        self.assertEquals('user@example.org', child['jid'])
398
399        self.stub.send(toResponse(iq, 'result'))
400        return d
401
402
403    def test_items(self):
404        """
405        Test sending items request.
406        """
407        def cb(items):
408            self.assertEquals([], items)
409
410        d = self.protocol.items(JID('pubsub.example.org'), 'test')
411        d.addCallback(cb)
412
413        iq = self.stub.output[-1]
414        self.assertEquals('pubsub.example.org', iq.getAttribute('to'))
415        self.assertEquals('get', iq.getAttribute('type'))
416        self.assertEquals('pubsub', iq.pubsub.name)
417        self.assertEquals(NS_PUBSUB, iq.pubsub.uri)
418        children = list(domish.generateElementsQNamed(iq.pubsub.children,
419                                                      'items', NS_PUBSUB))
420        self.assertEquals(1, len(children))
421        child = children[0]
422        self.assertEquals('test', child['node'])
423
424        response = toResponse(iq, 'result')
425        items = response.addElement((NS_PUBSUB, 'pubsub')).addElement('items')
426        items['node'] = 'test'
427
428        self.stub.send(response)
429
430        return d
431
432
433    def test_itemsMaxItems(self):
434        """
435        Test sending items request, with limit on the number of items.
436        """
437        def cb(items):
438            self.assertEquals(2, len(items))
439            self.assertEquals([item1, item2], items)
440
441        d = self.protocol.items(JID('pubsub.example.org'), 'test', maxItems=2)
442        d.addCallback(cb)
443
444        iq = self.stub.output[-1]
445        self.assertEquals('pubsub.example.org', iq.getAttribute('to'))
446        self.assertEquals('get', iq.getAttribute('type'))
447        self.assertEquals('pubsub', iq.pubsub.name)
448        self.assertEquals(NS_PUBSUB, iq.pubsub.uri)
449        children = list(domish.generateElementsQNamed(iq.pubsub.children,
450                                                      'items', NS_PUBSUB))
451        self.assertEquals(1, len(children))
452        child = children[0]
453        self.assertEquals('test', child['node'])
454        self.assertEquals('2', child['max_items'])
455
456        response = toResponse(iq, 'result')
457        items = response.addElement((NS_PUBSUB, 'pubsub')).addElement('items')
458        items['node'] = 'test'
459        item1 = items.addElement('item')
460        item1['id'] = 'item1'
461        item2 = items.addElement('item')
462        item2['id'] = 'item2'
463
464        self.stub.send(response)
465
466        return d
467
468
469
470class PubSubServiceTest(unittest.TestCase):
471    """
472    Tests for L{pubsub.PubSubService}.
473    """
474
475    def setUp(self):
476        self.service = pubsub.PubSubService()
477
478    def handleRequest(self, xml):
479        """
480        Find a handler and call it directly
481        """
482        handler = None
483        iq = parseXml(xml)
484        for queryString, method in self.service.iqHandlers.iteritems():
485            if xpath.internQuery(queryString).matches(iq):
486                handler = getattr(self.service, method)
487
488        if handler:
489            d = defer.maybeDeferred(handler, iq)
490        else:
491            d = defer.fail(NotImplementedError())
492
493        return d
494
495
496    def test_interface(self):
497        """
498        Do instances of L{pubsub.PubSubService} provide L{iwokkel.IPubSubService}?
499        """
500        verify.verifyObject(iwokkel.IPubSubService, self.service)
501
502
503    def test_onPublishNoNode(self):
504        """
505        The root node is always a collection, publishing is a bad request.
506        """
507        xml = """
508        <iq type='set' to='pubsub.example.org'
509                       from='user@example.org'>
510          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
511            <publish/>
512          </pubsub>
513        </iq>
514        """
515
516        def cb(result):
517            self.assertEquals('bad-request', result.condition)
518
519        d = self.handleRequest(xml)
520        self.assertFailure(d, error.StanzaError)
521        d.addCallback(cb)
522        return d
523
524
525    def test_onPublish(self):
526        """
527        A publish request should result in L{PubSubService.publish} being
528        called.
529        """
530
531        xml = """
532        <iq type='set' to='pubsub.example.org'
533                       from='user@example.org'>
534          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
535            <publish node='test'/>
536          </pubsub>
537        </iq>
538        """
539
540        def publish(requestor, service, nodeIdentifier, items):
541            self.assertEqual(JID('user@example.org'), requestor)
542            self.assertEqual(JID('pubsub.example.org'), service)
543            self.assertEqual('test', nodeIdentifier)
544            self.assertEqual([], items)
545            return defer.succeed(None)
546
547        self.service.publish = publish
548        return self.handleRequest(xml)
549
550
551    def test_onOptionsGet(self):
552        """
553        Subscription options are not supported.
554        """
555
556        xml = """
557        <iq type='get' to='pubsub.example.org'
558                       from='user@example.org'>
559          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
560            <options/>
561          </pubsub>
562        </iq>
563        """
564
565        def cb(result):
566            self.assertEquals('feature-not-implemented', result.condition)
567            self.assertEquals('unsupported', result.appCondition.name)
568            self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
569
570        d = self.handleRequest(xml)
571        self.assertFailure(d, error.StanzaError)
572        d.addCallback(cb)
573        return d
574
575
576    def test_onDefault(self):
577        """
578        A default request should result in
579        L{PubSubService.getDefaultConfiguration} being called.
580        """
581
582        xml = """
583        <iq type='get' to='pubsub.example.org'
584                       from='user@example.org'>
585          <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'>
586            <default/>
587          </pubsub>
588        </iq>
589        """
590
591        def getConfigurationOptions():
592            return {
593                "pubsub#persist_items":
594                    {"type": "boolean",
595                     "label": "Persist items to storage"},
596                "pubsub#deliver_payloads":
597                    {"type": "boolean",
598                     "label": "Deliver payloads with event notifications"}
599                }
600
601        def getDefaultConfiguration(requestor, service, nodeType):
602            self.assertEqual(JID('user@example.org'), requestor)
603            self.assertEqual(JID('pubsub.example.org'), service)
604            self.assertEqual('leaf', nodeType)
605            return defer.succeed({})
606
607        def cb(element):
608            self.assertEqual('pubsub', element.name)
609            self.assertEqual(NS_PUBSUB_OWNER, element.uri)
610            self.assertEqual(NS_PUBSUB_OWNER, element.default.uri)
611            form = data_form.Form.fromElement(element.default.x)
612            self.assertEqual(NS_PUBSUB_CONFIG, form.formNamespace)
613
614        self.service.getConfigurationOptions = getConfigurationOptions
615        self.service.getDefaultConfiguration = getDefaultConfiguration
616        d = self.handleRequest(xml)
617        d.addCallback(cb)
618        return d
619
620
621    def test_onConfigureGet(self):
622        """
623        On a node configuration get request L{PubSubService.getConfiguration}
624        is called and results in a data form with the configuration.
625        """
626
627        xml = """
628        <iq type='get' to='pubsub.example.org'
629                       from='user@example.org'>
630          <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'>
631            <configure node='test'/>
632          </pubsub>
633        </iq>
634        """
635
636        def getConfigurationOptions():
637            return {
638                "pubsub#persist_items":
639                    {"type": "boolean",
640                     "label": "Persist items to storage"},
641                "pubsub#deliver_payloads":
642                    {"type": "boolean",
643                     "label": "Deliver payloads with event notifications"}
644                }
645
646        def getConfiguration(requestor, service, nodeIdentifier):
647            self.assertEqual(JID('user@example.org'), requestor)
648            self.assertEqual(JID('pubsub.example.org'), service)
649            self.assertEqual('test', nodeIdentifier)
650
651            return defer.succeed({'pubsub#deliver_payloads': '0',
652                                  'pubsub#persist_items': '1'})
653
654        def cb(element):
655            self.assertEqual('pubsub', element.name)
656            self.assertEqual(NS_PUBSUB_OWNER, element.uri)
657            self.assertEqual(NS_PUBSUB_OWNER, element.configure.uri)
658            form = data_form.Form.fromElement(element.configure.x)
659            self.assertEqual(NS_PUBSUB_CONFIG, form.formNamespace)
660            fields = form.fields
661
662            self.assertIn('pubsub#deliver_payloads', fields)
663            field = fields['pubsub#deliver_payloads']
664            self.assertEqual('boolean', field.fieldType)
665            self.assertEqual(False, field.value)
666
667            self.assertIn('pubsub#persist_items', fields)
668            field = fields['pubsub#persist_items']
669            self.assertEqual('boolean', field.fieldType)
670            self.assertEqual(True, field.value)
671
672        self.service.getConfigurationOptions = getConfigurationOptions
673        self.service.getConfiguration = getConfiguration
674        d = self.handleRequest(xml)
675        d.addCallback(cb)
676        return d
677
678
679    def test_onConfigureSet(self):
680        """
681        On a node configuration set request the Data Form is parsed and
682        L{PubSubService.setConfiguration} is called with the passed options.
683        """
684
685        xml = """
686        <iq type='set' to='pubsub.example.org'
687                       from='user@example.org'>
688          <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'>
689            <configure node='test'>
690              <x xmlns='jabber:x:data' type='submit'>
691                <field var='FORM_TYPE' type='hidden'>
692                  <value>http://jabber.org/protocol/pubsub#node_config</value>
693                </field>
694                <field var='pubsub#deliver_payloads'><value>0</value></field>
695                <field var='pubsub#persist_items'><value>1</value></field>
696              </x>
697            </configure>
698          </pubsub>
699        </iq>
700        """
701
702        def getConfigurationOptions():
703            return {
704                "pubsub#persist_items":
705                    {"type": "boolean",
706                     "label": "Persist items to storage"},
707                "pubsub#deliver_payloads":
708                    {"type": "boolean",
709                     "label": "Deliver payloads with event notifications"}
710                }
711
712        def setConfiguration(requestor, service, nodeIdentifier, options):
713            self.assertEqual(JID('user@example.org'), requestor)
714            self.assertEqual(JID('pubsub.example.org'), service)
715            self.assertEqual('test', nodeIdentifier)
716            self.assertEqual({'pubsub#deliver_payloads': False,
717                              'pubsub#persist_items': True}, options)
718            return defer.succeed(None)
719
720        self.service.getConfigurationOptions = getConfigurationOptions
721        self.service.setConfiguration = setConfiguration
722        return self.handleRequest(xml)
723
724
725    def test_onConfigureSetCancel(self):
726        """
727        The node configuration is cancelled, L{PubSubService.setConfiguration}
728        not called.
729        """
730
731        xml = """
732        <iq type='set' to='pubsub.example.org'
733                       from='user@example.org'>
734          <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'>
735            <configure node='test'>
736              <x xmlns='jabber:x:data' type='cancel'>
737                <field var='FORM_TYPE' type='hidden'>
738                  <value>http://jabber.org/protocol/pubsub#node_config</value>
739                </field>
740              </x>
741            </configure>
742          </pubsub>
743        </iq>
744        """
745
746        def setConfiguration(requestor, service, nodeIdentifier, options):
747            self.fail("Unexpected call to setConfiguration")
748
749        self.service.setConfiguration = setConfiguration
750        return self.handleRequest(xml)
751
752
753    def test_onConfigureSetIgnoreUnknown(self):
754        """
755        On a node configuration set request unknown fields should be ignored.
756        """
757
758        xml = """
759        <iq type='set' to='pubsub.example.org'
760                       from='user@example.org'>
761          <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'>
762            <configure node='test'>
763              <x xmlns='jabber:x:data' type='submit'>
764                <field var='FORM_TYPE' type='hidden'>
765                  <value>http://jabber.org/protocol/pubsub#node_config</value>
766                </field>
767                <field var='pubsub#deliver_payloads'><value>0</value></field>
768                <field var='x-myfield'><value>1</value></field>
769              </x>
770            </configure>
771          </pubsub>
772        </iq>
773        """
774
775        def getConfigurationOptions():
776            return {
777                "pubsub#persist_items":
778                    {"type": "boolean",
779                     "label": "Persist items to storage"},
780                "pubsub#deliver_payloads":
781                    {"type": "boolean",
782                     "label": "Deliver payloads with event notifications"}
783                }
784
785        def setConfiguration(requestor, service, nodeIdentifier, options):
786            self.assertEquals(['pubsub#deliver_payloads'], options.keys())
787
788        self.service.getConfigurationOptions = getConfigurationOptions
789        self.service.setConfiguration = setConfiguration
790        return self.handleRequest(xml)
791
792
793    def test_onItems(self):
794        """
795        On a items request, return all items for the given node.
796        """
797        xml = """
798        <iq type='get' to='pubsub.example.org'
799                       from='user@example.org'>
800          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
801            <items node='test'/>
802          </pubsub>
803        </iq>
804        """
805
806        def items(requestor, service, nodeIdentifier, maxItems, items):
807            self.assertEqual(JID('user@example.org'), requestor)
808            self.assertEqual(JID('pubsub.example.org'), service)
809            self.assertEqual('test', nodeIdentifier)
810            self.assertIdentical(None, maxItems)
811            self.assertEqual([], items)
812            return defer.succeed([pubsub.Item('current')])
813
814        def cb(element):
815            self.assertEqual(NS_PUBSUB, element.uri)
816            self.assertEqual(NS_PUBSUB, element.items.uri)
817            self.assertEqual(1, len(element.items.children))
818            item = element.items.children[-1]
819            self.assertTrue(domish.IElement.providedBy(item))
820            self.assertEqual('item', item.name)
821            self.assertEqual(NS_PUBSUB, item.uri)
822            self.assertEqual('current', item['id'])
823
824        self.service.items = items
825        d = self.handleRequest(xml)
826        d.addCallback(cb)
827        return d
828
829
830    def test_onRetract(self):
831        """
832        A retract request should result in L{PubSubService.retract} being
833        called.
834        """
835
836        xml = """
837        <iq type='set' to='pubsub.example.org'
838                       from='user@example.org'>
839          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
840            <retract node='test'>
841              <item id='item1'/>
842              <item id='item2'/>
843            </retract>
844          </pubsub>
845        </iq>
846        """
847
848        def retract(requestor, service, nodeIdentifier, itemIdentifiers):
849            self.assertEqual(JID('user@example.org'), requestor)
850            self.assertEqual(JID('pubsub.example.org'), service)
851            self.assertEqual('test', nodeIdentifier)
852            self.assertEqual(['item1', 'item2'], itemIdentifiers)
853            return defer.succeed(None)
854
855        self.service.retract = retract
856        return self.handleRequest(xml)
857
858
859    def test_onPurge(self):
860        """
861        A purge request should result in L{PubSubService.purge} being
862        called.
863        """
864
865        xml = """
866        <iq type='set' to='pubsub.example.org'
867                       from='user@example.org'>
868          <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'>
869            <purge node='test'/>
870          </pubsub>
871        </iq>
872        """
873
874        def purge(requestor, service, nodeIdentifier):
875            self.assertEqual(JID('user@example.org'), requestor)
876            self.assertEqual(JID('pubsub.example.org'), service)
877            self.assertEqual('test', nodeIdentifier)
878            return defer.succeed(None)
879
880        self.service.purge = purge
881        return self.handleRequest(xml)
882
883
884    def test_onDelete(self):
885        """
886        A delete request should result in L{PubSubService.delete} being
887        called.
888        """
889
890        xml = """
891        <iq type='set' to='pubsub.example.org'
892                       from='user@example.org'>
893          <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'>
894            <delete node='test'/>
895          </pubsub>
896        </iq>
897        """
898
899        def delete(requestor, service, nodeIdentifier):
900            self.assertEqual(JID('user@example.org'), requestor)
901            self.assertEqual(JID('pubsub.example.org'), service)
902            self.assertEqual('test', nodeIdentifier)
903            return defer.succeed(None)
904
905        self.service.delete = delete
906        return self.handleRequest(xml)
Note: See TracBrowser for help on using the repository browser.