source: wokkel/test/test_disco.py @ 89:2a23913093ec

Last change on this file since 89:2a23913093ec was 89:2a23913093ec, checked in by Ralph Meijer <ralphm@…>, 11 years ago

Complete test coverage for Service Discovery.
File size: 29.5 KB
Line 
1# Copyright (c) 2003-2009 Ralph Meijer
2# See LICENSE for details.
3
4"""
5Tests for L{wokkel.disco}.
6"""
7
8from zope.interface import implements
9
10from twisted.internet import defer
11from twisted.trial import unittest
12from twisted.words.protocols.jabber.error import StanzaError
13from twisted.words.protocols.jabber.jid import JID
14from twisted.words.protocols.jabber.xmlstream import toResponse
15from twisted.words.xish import domish, utility
16
17from wokkel import data_form, disco
18from wokkel.generic import parseXml
19from wokkel.subprotocols import XMPPHandler
20from wokkel.test.helpers import TestableRequestHandlerMixin, XmlStreamStub
21
22NS_DISCO_INFO = 'http://jabber.org/protocol/disco#info'
23NS_DISCO_ITEMS = 'http://jabber.org/protocol/disco#items'
24
25class DiscoFeatureTest(unittest.TestCase):
26    """
27    Tests for L{disco.DiscoFeature}.
28    """
29
30    def test_init(self):
31        """
32        Test initialization with a with feature namespace URI.
33        """
34        feature = disco.DiscoFeature(u'testns')
35        self.assertEqual(u'testns', feature)
36
37
38    def test_toElement(self):
39        """
40        Test proper rendering to a DOM representation.
41
42        The returned element should be properly named and have a C{var}
43        attribute that holds the feature namespace URI.
44        """
45        feature = disco.DiscoFeature(u'testns')
46        element = feature.toElement()
47        self.assertEqual(NS_DISCO_INFO, element.uri)
48        self.assertEqual(u'feature', element.name)
49        self.assertTrue(element.hasAttribute(u'var'))
50        self.assertEqual(u'testns', element[u'var'])
51
52
53    def test_fromElement(self):
54        """
55        Test creating L{disco.DiscoFeature} from L{domish.Element}.
56        """
57        element = domish.Element((NS_DISCO_INFO, u'feature'))
58        element['var'] = u'testns'
59        feature = disco.DiscoFeature.fromElement(element)
60        self.assertEqual(u'testns', feature)
61
62
63
64class DiscoIdentityTest(unittest.TestCase):
65    """
66    Tests for L{disco.DiscoIdentity}.
67    """
68
69    def test_init(self):
70        """
71        Test initialization with a category, type and name.
72        """
73        identity = disco.DiscoIdentity(u'conference', u'text', u'The chatroom')
74        self.assertEqual(u'conference', identity.category)
75        self.assertEqual(u'text', identity.type)
76        self.assertEqual(u'The chatroom', identity.name)
77
78
79    def test_toElement(self):
80        """
81        Test proper rendering to a DOM representation.
82
83        The returned element should be properly named and have C{conference},
84        C{type}, and C{name} attributes.
85        """
86        identity = disco.DiscoIdentity(u'conference', u'text', u'The chatroom')
87        element = identity.toElement()
88        self.assertEqual(NS_DISCO_INFO, element.uri)
89        self.assertEqual(u'identity', element.name)
90        self.assertEqual(u'conference', element.getAttribute(u'category'))
91        self.assertEqual(u'text', element.getAttribute(u'type'))
92        self.assertEqual(u'The chatroom', element.getAttribute(u'name'))
93
94
95    def test_toElementWithoutName(self):
96        """
97        Test proper rendering to a DOM representation without a name.
98
99        The returned element should be properly named and have C{conference},
100        C{type} attributes, no C{name} attribute.
101        """
102        identity = disco.DiscoIdentity(u'conference', u'text')
103        element = identity.toElement()
104        self.assertEqual(NS_DISCO_INFO, element.uri)
105        self.assertEqual(u'identity', element.name)
106        self.assertEqual(u'conference', element.getAttribute(u'category'))
107        self.assertEqual(u'text', element.getAttribute(u'type'))
108        self.assertFalse(element.hasAttribute(u'name'))
109
110
111    def test_fromElement(self):
112        """
113        Test creating L{disco.DiscoIdentity} from L{domish.Element}.
114        """
115        element = domish.Element((NS_DISCO_INFO, u'identity'))
116        element['category'] = u'conference'
117        element['type'] = u'text'
118        element['name'] = u'The chatroom'
119        identity = disco.DiscoIdentity.fromElement(element)
120        self.assertEqual(u'conference', identity.category)
121        self.assertEqual(u'text', identity.type)
122        self.assertEqual(u'The chatroom', identity.name)
123
124
125    def test_fromElementWithoutName(self):
126        """
127        Test creating L{disco.DiscoIdentity} from L{domish.Element}, no name.
128        """
129        element = domish.Element((NS_DISCO_INFO, u'identity'))
130        element['category'] = u'conference'
131        element['type'] = u'text'
132        identity = disco.DiscoIdentity.fromElement(element)
133        self.assertEqual(u'conference', identity.category)
134        self.assertEqual(u'text', identity.type)
135        self.assertEqual(None, identity.name)
136
137
138
139class DiscoInfoTest(unittest.TestCase):
140    """
141    Tests for L{disco.DiscoInfo}.
142    """
143
144    def test_toElement(self):
145        """
146        Test C{toElement} creates a correctly namespaced element, no node.
147        """
148        info = disco.DiscoInfo()
149        element = info.toElement()
150
151        self.assertEqual(NS_DISCO_INFO, element.uri)
152        self.assertEqual(u'query', element.name)
153        self.assertFalse(element.hasAttribute(u'node'))
154
155
156    def test_toElementNode(self):
157        """
158        Test C{toElement} with a node.
159        """
160        info = disco.DiscoInfo()
161        info.nodeIdentifier = u'test'
162        element = info.toElement()
163
164        self.assertEqual(u'test', element.getAttribute(u'node'))
165
166
167    def test_toElementChildren(self):
168        """
169        Test C{toElement} creates a DOM with proper childs.
170        """
171        info = disco.DiscoInfo()
172        info.append(disco.DiscoFeature(u'jabber:iq:register'))
173        info.append(disco.DiscoIdentity(u'conference', u'text'))
174        info.append(data_form.Form(u'result'))
175        element = info.toElement()
176
177        featureElements = domish.generateElementsQNamed(element.children,
178                                                        u'feature',
179                                                        NS_DISCO_INFO)
180        self.assertEqual(1, len(list(featureElements)))
181
182        identityElements = domish.generateElementsQNamed(element.children,
183                                                         u'identity',
184                                                         NS_DISCO_INFO)
185        self.assertEqual(1, len(list(identityElements)))
186
187        extensionElements = domish.generateElementsQNamed(element.children,
188                                                         u'x',
189                                                         data_form.NS_X_DATA)
190        self.assertEqual(1, len(list(extensionElements)))
191
192
193    def test_fromElement(self):
194        """
195        Test properties when creating L{disco.DiscoInfo} from L{domish.Element}.
196        """
197        xml = """<query xmlns='http://jabber.org/protocol/disco#info'>
198                   <identity category='conference'
199                             type='text'
200                             name='A Dark Cave'/>
201                   <feature var='http://jabber.org/protocol/muc'/>
202                   <feature var='jabber:iq:register'/>
203                   <x xmlns='jabber:x:data' type='result'>
204                     <field var='FORM_TYPE' type='hidden'>
205                       <value>http://jabber.org/protocol/muc#roominfo</value>
206                     </field>
207                   </x>
208                 </query>"""
209
210        element = parseXml(xml)
211        info = disco.DiscoInfo.fromElement(element)
212
213        self.assertIn(u'http://jabber.org/protocol/muc', info.features)
214        self.assertIn(u'jabber:iq:register', info.features)
215
216        self.assertIn((u'conference', u'text'), info.identities)
217        self.assertEqual(u'A Dark Cave',
218                          info.identities[(u'conference', u'text')])
219
220        self.assertIn(u'http://jabber.org/protocol/muc#roominfo',
221                      info.extensions)
222
223
224    def test_fromElementItems(self):
225        """
226        Test items when creating L{disco.DiscoInfo} from L{domish.Element}.
227        """
228        xml = """<query xmlns='http://jabber.org/protocol/disco#info'>
229                   <identity category='conference'
230                             type='text'
231                             name='A Dark Cave'/>
232                   <feature var='http://jabber.org/protocol/muc'/>
233                   <feature var='jabber:iq:register'/>
234                   <x xmlns='jabber:x:data' type='result'>
235                     <field var='FORM_TYPE' type='hidden'>
236                       <value>http://jabber.org/protocol/muc#roominfo</value>
237                     </field>
238                   </x>
239                 </query>"""
240
241        element = parseXml(xml)
242        info = disco.DiscoInfo.fromElement(element)
243
244        info = list(info)
245        self.assertEqual(4, len(info))
246
247        identity = info[0]
248        self.assertEqual(u'conference', identity.category)
249
250        self.assertEqual(u'http://jabber.org/protocol/muc', info[1])
251        self.assertEqual(u'jabber:iq:register', info[2])
252
253        extension = info[3]
254        self.assertEqual(u'http://jabber.org/protocol/muc#roominfo',
255                         extension.formNamespace)
256
257
258    def test_fromElementNoNode(self):
259        """
260        Test creating L{disco.DiscoInfo} from L{domish.Element}, no node.
261        """
262        xml = """<query xmlns='http://jabber.org/protocol/disco#info'/>"""
263
264        element = parseXml(xml)
265        info = disco.DiscoInfo.fromElement(element)
266
267        self.assertEqual(u'', info.nodeIdentifier)
268
269
270    def test_fromElementNode(self):
271        """
272        Test creating L{disco.DiscoInfo} from L{domish.Element}, with node.
273        """
274        xml = """<query xmlns='http://jabber.org/protocol/disco#info'
275                        node='test'>
276                 </query>"""
277
278        element = parseXml(xml)
279        info = disco.DiscoInfo.fromElement(element)
280
281        self.assertEqual(u'test', info.nodeIdentifier)
282
283
284
285class DiscoItemTest(unittest.TestCase):
286    """
287    Tests for L{disco.DiscoItem}.
288    """
289
290    def test_init(self):
291        """
292        Test initialization with a category, type and name.
293        """
294        item = disco.DiscoItem(JID(u'example.org'), u'test', u'The node')
295        self.assertEqual(JID(u'example.org'), item.entity)
296        self.assertEqual(u'test', item.nodeIdentifier)
297        self.assertEqual(u'The node', item.name)
298
299
300    def test_toElement(self):
301        """
302        Test proper rendering to a DOM representation.
303
304        The returned element should be properly named and have C{jid}, C{node},
305        and C{name} attributes.
306        """
307        item = disco.DiscoItem(JID(u'example.org'), u'test', u'The node')
308        element = item.toElement()
309        self.assertEqual(NS_DISCO_ITEMS, element.uri)
310        self.assertEqual(u'item', element.name)
311        self.assertEqual(u'example.org', element.getAttribute(u'jid'))
312        self.assertEqual(u'test', element.getAttribute(u'node'))
313        self.assertEqual(u'The node', element.getAttribute(u'name'))
314
315
316    def test_toElementWithoutName(self):
317        """
318        Test proper rendering to a DOM representation without a name.
319
320        The returned element should be properly named and have C{jid}, C{node}
321        attributes, no C{name} attribute.
322        """
323        item = disco.DiscoItem(JID(u'example.org'), u'test')
324        element = item.toElement()
325        self.assertEqual(NS_DISCO_ITEMS, element.uri)
326        self.assertEqual(u'item', element.name)
327        self.assertEqual(u'example.org', element.getAttribute(u'jid'))
328        self.assertEqual(u'test', element.getAttribute(u'node'))
329        self.assertFalse(element.hasAttribute(u'name'))
330
331
332    def test_fromElement(self):
333        """
334        Test creating L{disco.DiscoItem} from L{domish.Element}.
335        """
336        element = domish.Element((NS_DISCO_ITEMS, u'item'))
337        element[u'jid'] = u'example.org'
338        element[u'node'] = u'test'
339        element[u'name'] = u'The node'
340        item = disco.DiscoItem.fromElement(element)
341        self.assertEqual(JID(u'example.org'), item.entity)
342        self.assertEqual(u'test', item.nodeIdentifier)
343        self.assertEqual(u'The node', item.name)
344
345    def test_fromElementNoNode(self):
346        """
347        Test creating L{disco.DiscoItem} from L{domish.Element}, no node.
348        """
349        element = domish.Element((NS_DISCO_ITEMS, u'item'))
350        element[u'jid'] = u'example.org'
351        element[u'name'] = u'The node'
352        item = disco.DiscoItem.fromElement(element)
353        self.assertEqual(JID(u'example.org'), item.entity)
354        self.assertEqual(u'', item.nodeIdentifier)
355        self.assertEqual(u'The node', item.name)
356
357
358    def test_fromElementNoName(self):
359        """
360        Test creating L{disco.DiscoItem} from L{domish.Element}, no name.
361        """
362        element = domish.Element((NS_DISCO_ITEMS, u'item'))
363        element[u'jid'] = u'example.org'
364        element[u'node'] = u'test'
365        item = disco.DiscoItem.fromElement(element)
366        self.assertEqual(JID(u'example.org'), item.entity)
367        self.assertEqual(u'test', item.nodeIdentifier)
368        self.assertEqual(None, item.name)
369
370    def test_fromElementBadJID(self):
371        """
372        Test creating L{disco.DiscoItem} from L{domish.Element}, bad JID.
373        """
374        element = domish.Element((NS_DISCO_ITEMS, u'item'))
375        element[u'jid'] = u'ex@@@ample.org'
376        item = disco.DiscoItem.fromElement(element)
377        self.assertIdentical(None, item.entity)
378
379
380
381class DiscoItemsTest(unittest.TestCase):
382    """
383    Tests for L{disco.DiscoItems}.
384    """
385
386    def test_toElement(self):
387        """
388        Test C{toElement} creates a correctly namespaced element, no node.
389        """
390        items = disco.DiscoItems()
391        element = items.toElement()
392
393        self.assertEqual(NS_DISCO_ITEMS, element.uri)
394        self.assertEqual(u'query', element.name)
395        self.assertFalse(element.hasAttribute(u'node'))
396
397
398    def test_toElementNode(self):
399        """
400        Test C{toElement} with a node.
401        """
402        items = disco.DiscoItems()
403        items.nodeIdentifier = u'test'
404        element = items.toElement()
405
406        self.assertEqual(u'test', element.getAttribute(u'node'))
407
408
409    def test_toElementChildren(self):
410        """
411        Test C{toElement} creates a DOM with proper childs.
412        """
413        items = disco.DiscoItems()
414        items.append(disco.DiscoItem(JID(u'example.org'), u'test', u'A node'))
415        element = items.toElement()
416
417        itemElements = domish.generateElementsQNamed(element.children,
418                                                     u'item',
419                                                     NS_DISCO_ITEMS)
420        self.assertEqual(1, len(list(itemElements)))
421
422
423    def test_fromElement(self):
424        """
425        Test creating L{disco.DiscoItems} from L{domish.Element}.
426        """
427        xml = """<query xmlns='http://jabber.org/protocol/disco#items'>
428                   <item jid='example.org' node='test' name='A node'/>
429                 </query>"""
430
431        element = parseXml(xml)
432        items = disco.DiscoItems.fromElement(element)
433
434        items = list(items)
435        self.assertEqual(1, len(items))
436        item = items[0]
437
438        self.assertEqual(JID(u'example.org'), item.entity)
439        self.assertEqual(u'test', item.nodeIdentifier)
440        self.assertEqual(u'A node', item.name)
441
442
443    def test_fromElementNoNode(self):
444        """
445        Test creating L{disco.DiscoItems} from L{domish.Element}, no node.
446        """
447        xml = """<query xmlns='http://jabber.org/protocol/disco#items'/>"""
448
449        element = parseXml(xml)
450        items = disco.DiscoItems.fromElement(element)
451
452        self.assertEqual(u'', items.nodeIdentifier)
453
454
455    def test_fromElementNode(self):
456        """
457        Test creating L{disco.DiscoItems} from L{domish.Element}, with node.
458        """
459        xml = """<query xmlns='http://jabber.org/protocol/disco#items'
460                        node='test'>
461                 </query>"""
462
463        element = parseXml(xml)
464        items = disco.DiscoItems.fromElement(element)
465
466        self.assertEqual(u'test', items.nodeIdentifier)
467
468
469
470class DiscoClientProtocolTest(unittest.TestCase):
471    """
472    Tests for L{disco.DiscoClientProtocol}.
473    """
474
475    def setUp(self):
476        """
477        Set up stub and protocol for testing.
478        """
479        self.stub = XmlStreamStub()
480        self.protocol = disco.DiscoClientProtocol()
481        self.protocol.xmlstream = self.stub.xmlstream
482        self.protocol.connectionInitialized()
483
484
485    def test_requestItems(self):
486        """
487        Test request sent out by C{requestItems} and parsing of response.
488        """
489        def cb(items):
490            items = list(items)
491            self.assertEqual(2, len(items))
492            self.assertEqual(JID(u'test.example.org'), items[0].entity)
493
494        d = self.protocol.requestItems(JID(u'example.org'),u"foo")
495        d.addCallback(cb)
496
497        iq = self.stub.output[-1]
498        self.assertEqual(u'example.org', iq.getAttribute(u'to'))
499        self.assertEqual(u'get', iq.getAttribute(u'type'))
500        self.assertEqual(u'foo', iq.query.getAttribute(u'node'))
501        self.assertEqual(NS_DISCO_ITEMS, iq.query.uri)
502
503        response = toResponse(iq, u'result')
504        query = response.addElement((NS_DISCO_ITEMS, u'query'))
505
506        element = query.addElement(u'item')
507        element[u'jid'] = u'test.example.org'
508        element[u'node'] = u'music'
509        element[u'name'] = u'Music from the time of Shakespeare'
510
511        element = query.addElement(u'item')
512        element[u'jid'] = u"test2.example.org"
513
514        self.stub.send(response)
515        return d
516
517
518    def test_requestItemsFrom(self):
519        """
520        A disco items request can be sent with an explicit sender address.
521        """
522        d = self.protocol.requestItems(JID(u'example.org'),
523                                       sender=JID(u'test.example.org'))
524
525        iq = self.stub.output[-1]
526        self.assertEqual(u'test.example.org', iq.getAttribute(u'from'))
527
528        response = toResponse(iq, u'result')
529        response.addElement((NS_DISCO_ITEMS, u'query'))
530        self.stub.send(response)
531
532        return d
533
534
535    def test_requestInfo(self):
536        """
537        Test request sent out by C{requestInfo} and parsing of response.
538        """
539        def cb(info):
540            self.assertIn((u'conference', u'text'), info.identities)
541            self.assertIn(u'http://jabber.org/protocol/disco#info',
542                          info.features)
543            self.assertIn(u'http://jabber.org/protocol/muc',
544                          info.features)
545
546        d = self.protocol.requestInfo(JID(u'example.org'),'foo')
547        d.addCallback(cb)
548
549        iq = self.stub.output[-1]
550        self.assertEqual(u'example.org', iq.getAttribute(u'to'))
551        self.assertEqual(u'get', iq.getAttribute(u'type'))
552        self.assertEqual(u'foo', iq.query.getAttribute(u'node'))
553        self.assertEqual(NS_DISCO_INFO, iq.query.uri)
554
555        response = toResponse(iq, u'result')
556        query = response.addElement((NS_DISCO_INFO, u'query'))
557
558        element = query.addElement(u"identity")
559        element[u'category'] = u'conference' # required
560        element[u'type'] = u'text' # required
561        element[u"name"] = u'Romeo and Juliet, Act II, Scene II' # optional
562
563        element = query.addElement("feature")
564        element[u'var'] = u'http://jabber.org/protocol/disco#info' # required
565
566        element = query.addElement(u"feature")
567        element[u'var'] = u'http://jabber.org/protocol/muc'
568
569        self.stub.send(response)
570        return d
571
572
573    def test_requestInfoFrom(self):
574        """
575        A disco info request can be sent with an explicit sender address.
576        """
577        d = self.protocol.requestInfo(JID(u'example.org'),
578                                       sender=JID(u'test.example.org'))
579
580        iq = self.stub.output[-1]
581        self.assertEqual(u'test.example.org', iq.getAttribute(u'from'))
582
583        response = toResponse(iq, u'result')
584        response.addElement((NS_DISCO_INFO, u'query'))
585        self.stub.send(response)
586
587        return d
588
589
590
591class DiscoHandlerTest(unittest.TestCase, TestableRequestHandlerMixin):
592    """
593    Tests for L{disco.DiscoHandler}.
594    """
595
596    def setUp(self):
597        self.service = disco.DiscoHandler()
598
599
600    def test_connectionInitializedObserveInfo(self):
601        """
602        An observer for Disco Info requests is setup on stream initialization.
603        """
604        xml = """<iq from='test@example.com' to='example.com'
605                     type='get'>
606                   <query xmlns='%s'/>
607                 </iq>""" % NS_DISCO_INFO
608
609        def handleRequest(iq):
610            called.append(iq)
611
612        called = []
613        self.service.xmlstream = utility.EventDispatcher()
614        self.service.handleRequest = handleRequest
615        self.service.connectionInitialized()
616        self.service.xmlstream.dispatch(parseXml(xml))
617        self.assertEqual(1, len(called))
618
619
620    def test_connectionInitializedObserveItems(self):
621        """
622        An observer for Disco Items requests is setup on stream initialization.
623        """
624        xml = """<iq from='test@example.com' to='example.com'
625                     type='get'>
626                   <query xmlns='%s'/>
627                 </iq>""" % NS_DISCO_ITEMS
628
629        def handleRequest(iq):
630            called.append(iq)
631
632        called = []
633        self.service.xmlstream = utility.EventDispatcher()
634        self.service.handleRequest = handleRequest
635        self.service.connectionInitialized()
636        self.service.xmlstream.dispatch(parseXml(xml))
637        self.assertEqual(1, len(called))
638
639
640    def test_onDiscoInfo(self):
641        """
642        C{onDiscoInfo} should process an info request and return a response.
643
644        The request should be parsed, C{info} called with the extracted
645        parameters, and then the result should be formatted into a proper
646        response element.
647        """
648        xml = """<iq from='test@example.com' to='example.com'
649                     type='get'>
650                   <query xmlns='%s'/>
651                 </iq>""" % NS_DISCO_INFO
652
653        def cb(element):
654            self.assertEqual('query', element.name)
655            self.assertEqual(NS_DISCO_INFO, element.uri)
656            self.assertEqual(NS_DISCO_INFO, element.identity.uri)
657            self.assertEqual('dummy', element.identity['category'])
658            self.assertEqual('generic', element.identity['type'])
659            self.assertEqual('Generic Dummy Entity', element.identity['name'])
660            self.assertEqual(NS_DISCO_INFO, element.feature.uri)
661            self.assertEqual('jabber:iq:version', element.feature['var'])
662
663        def info(requestor, target, nodeIdentifier):
664            self.assertEqual(JID('test@example.com'), requestor)
665            self.assertEqual(JID('example.com'), target)
666            self.assertEqual('', nodeIdentifier)
667
668            return defer.succeed([
669                disco.DiscoIdentity('dummy', 'generic', 'Generic Dummy Entity'),
670                disco.DiscoFeature('jabber:iq:version')
671            ])
672
673        self.service.info = info
674        d = self.handleRequest(xml)
675        d.addCallback(cb)
676        return d
677
678
679    def test_onDiscoInfoWithNode(self):
680        """
681        An info request for a node should return it in the response.
682        """
683        xml = """<iq from='test@example.com' to='example.com'
684                     type='get'>
685                   <query xmlns='%s' node='test'/>
686                 </iq>""" % NS_DISCO_INFO
687
688        def cb(element):
689            self.assertTrue(element.hasAttribute('node'))
690            self.assertEqual('test', element['node'])
691
692        def info(requestor, target, nodeIdentifier):
693            self.assertEqual('test', nodeIdentifier)
694
695            return defer.succeed([
696                disco.DiscoFeature('jabber:iq:version')
697            ])
698
699        self.service.info = info
700        d = self.handleRequest(xml)
701        d.addCallback(cb)
702        return d
703
704
705    def test_onDiscoInfoWithNodeNoResults(self):
706        """
707        An info request for a node with no results returns items-not-found.
708        """
709        xml = """<iq from='test@example.com' to='example.com'
710                     type='get'>
711                   <query xmlns='%s' node='test'/>
712                 </iq>""" % NS_DISCO_INFO
713
714        def cb(exc):
715            self.assertEquals('item-not-found', exc.condition)
716
717        def info(requestor, target, nodeIdentifier):
718            self.assertEqual('test', nodeIdentifier)
719
720            return defer.succeed([])
721
722        self.service.info = info
723        d = self.handleRequest(xml)
724        self.assertFailure(d, StanzaError)
725        d.addCallback(cb)
726        return d
727
728
729    def test_onDiscoItems(self):
730        """
731        C{onDiscoItems} should process an items request and return a response.
732
733        The request should be parsed, C{items} called with the extracted
734        parameters, and then the result should be formatted into a proper
735        response element.
736        """
737        xml = """<iq from='test@example.com' to='example.com'
738                     type='get'>
739                   <query xmlns='%s'/>
740                 </iq>""" % NS_DISCO_ITEMS
741
742        def cb(element):
743            self.assertEqual('query', element.name)
744            self.assertEqual(NS_DISCO_ITEMS, element.uri)
745            self.assertEqual(NS_DISCO_ITEMS, element.item.uri)
746            self.assertEqual('example.com', element.item['jid'])
747            self.assertEqual('test', element.item['node'])
748            self.assertEqual('Test node', element.item['name'])
749
750        def items(requestor, target, nodeIdentifier):
751            self.assertEqual(JID('test@example.com'), requestor)
752            self.assertEqual(JID('example.com'), target)
753            self.assertEqual('', nodeIdentifier)
754
755            return defer.succeed([
756                disco.DiscoItem(JID('example.com'), 'test', 'Test node'),
757            ])
758
759        self.service.items = items
760        d = self.handleRequest(xml)
761        d.addCallback(cb)
762        return d
763
764
765    def test_onDiscoItemsWithNode(self):
766        """
767        An items request for a node should return it in the response.
768        """
769        xml = """<iq from='test@example.com' to='example.com'
770                     type='get'>
771                   <query xmlns='%s' node='test'/>
772                 </iq>""" % NS_DISCO_ITEMS
773
774        def cb(element):
775            self.assertTrue(element.hasAttribute('node'))
776            self.assertEqual('test', element['node'])
777
778        def items(requestor, target, nodeIdentifier):
779            self.assertEqual('test', nodeIdentifier)
780
781            return defer.succeed([
782                disco.DiscoFeature('jabber:iq:version')
783            ])
784
785        self.service.items = items
786        d = self.handleRequest(xml)
787        d.addCallback(cb)
788        return d
789
790
791    def test_info(self):
792        """
793        C{info} should gather disco info from sibling handlers.
794        """
795        discoItems = [disco.DiscoIdentity('dummy', 'generic',
796                                          'Generic Dummy Entity'),
797                      disco.DiscoFeature('jabber:iq:version')
798        ]
799
800        class DiscoResponder(XMPPHandler):
801            implements(disco.IDisco)
802
803            def getDiscoInfo(self, requestor, target, nodeIdentifier):
804                if not nodeIdentifier:
805                    return defer.succeed(discoItems)
806                else:
807                    return defer.succeed([])
808
809        def cb(result):
810            self.assertEquals(discoItems, result)
811
812        self.service.parent = [self.service, DiscoResponder()]
813        d = self.service.info(JID('test@example.com'), JID('example.com'), '')
814        d.addCallback(cb)
815        return d
816
817
818    def test_infoNotDeferred(self):
819        """
820        C{info} should gather disco info from sibling handlers.
821        """
822        discoItems = [disco.DiscoIdentity('dummy', 'generic',
823                                          'Generic Dummy Entity'),
824                      disco.DiscoFeature('jabber:iq:version')
825        ]
826
827        class DiscoResponder(XMPPHandler):
828            implements(disco.IDisco)
829
830            def getDiscoInfo(self, requestor, target, nodeIdentifier):
831                if not nodeIdentifier:
832                    return discoItems
833                else:
834                    return []
835
836        def cb(result):
837            self.assertEquals(discoItems, result)
838
839        self.service.parent = [self.service, DiscoResponder()]
840        d = self.service.info(JID('test@example.com'), JID('example.com'), '')
841        d.addCallback(cb)
842        return d
843
844
845    def test_items(self):
846        """
847        C{info} should gather disco items from sibling handlers.
848        """
849        discoItems = [disco.DiscoItem(JID('example.com'), 'test', 'Test node')]
850
851        class DiscoResponder(XMPPHandler):
852            implements(disco.IDisco)
853
854            def getDiscoItems(self, requestor, target, nodeIdentifier):
855                if not nodeIdentifier:
856                    return defer.succeed(discoItems)
857                else:
858                    return defer.succeed([])
859
860        def cb(result):
861            self.assertEquals(discoItems, result)
862
863        self.service.parent = [self.service, DiscoResponder()]
864        d = self.service.items(JID('test@example.com'), JID('example.com'), '')
865        d.addCallback(cb)
866        return d
867
868
869    def test_itemsNotDeferred(self):
870        """
871        C{info} should also collect results not returned via a deferred.
872        """
873        discoItems = [disco.DiscoItem(JID('example.com'), 'test', 'Test node')]
874
875        class DiscoResponder(XMPPHandler):
876            implements(disco.IDisco)
877
878            def getDiscoItems(self, requestor, target, nodeIdentifier):
879                if not nodeIdentifier:
880                    return discoItems
881                else:
882                    return []
883
884        def cb(result):
885            self.assertEquals(discoItems, result)
886
887        self.service.parent = [self.service, DiscoResponder()]
888        d = self.service.items(JID('test@example.com'), JID('example.com'), '')
889        d.addCallback(cb)
890        return d
Note: See TracBrowser for help on using the repository browser.