source: wokkel/test/test_disco.py @ 62:b98e610f62cc

Last change on this file since 62:b98e610f62cc was 62:b98e610f62cc, checked in by Ralph Meijer <ralphm@…>, 12 years ago

Add sender parameter to disco requests.

Author: ralphm
Fixes #52.

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