source: wokkel/test/test_disco.py @ 53:4aec395fda5b

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

Release Wokkel 0.5.0.

File size: 24.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_requestInfo(self):
518        """
519        Test request sent out by C{requestInfo} and parsing of response.
520        """
521        def cb(info):
522            self.assertIn((u'conference', u'text'), info.identities)
523            self.assertIn(u'http://jabber.org/protocol/disco#info',
524                          info.features)
525            self.assertIn(u'http://jabber.org/protocol/muc',
526                          info.features)
527
528        d = self.protocol.requestInfo(JID(u'example.org'),'foo')
529        d.addCallback(cb)
530
531        iq = self.stub.output[-1]
532        self.assertEqual(u'example.org', iq.getAttribute(u'to'))
533        self.assertEqual(u'get', iq.getAttribute(u'type'))
534        self.assertEqual(u'foo', iq.query.getAttribute(u'node'))
535        self.assertEqual(NS_DISCO_INFO, iq.query.uri)
536
537        response = toResponse(iq, u'result')
538        query = response.addElement((NS_DISCO_INFO, u'query'))
539
540        element = query.addElement(u"identity")
541        element[u'category'] = u'conference' # required
542        element[u'type'] = u'text' # required
543        element[u"name"] = u'Romeo and Juliet, Act II, Scene II' # optional
544
545        element = query.addElement("feature")
546        element[u'var'] = u'http://jabber.org/protocol/disco#info' # required
547
548        element = query.addElement(u"feature")
549        element[u'var'] = u'http://jabber.org/protocol/muc'
550
551        self.stub.send(response)
552        return d
553
554
555
556class DiscoHandlerTest(unittest.TestCase, TestableRequestHandlerMixin):
557    """
558    Tests for L{disco.DiscoHandler}.
559    """
560
561    def setUp(self):
562        self.service = disco.DiscoHandler()
563
564
565    def test_onDiscoInfo(self):
566        """
567        C{onDiscoInfo} should process an info request and return a response.
568
569        The request should be parsed, C{info} called with the extracted
570        parameters, and then the result should be formatted into a proper
571        response element.
572        """
573        xml = """<iq from='test@example.com' to='example.com'
574                     type='get'>
575                   <query xmlns='%s'/>
576                 </iq>""" % NS_DISCO_INFO
577
578        def cb(element):
579            self.assertEqual('query', element.name)
580            self.assertEqual(NS_DISCO_INFO, element.uri)
581            self.assertEqual(NS_DISCO_INFO, element.identity.uri)
582            self.assertEqual('dummy', element.identity['category'])
583            self.assertEqual('generic', element.identity['type'])
584            self.assertEqual('Generic Dummy Entity', element.identity['name'])
585            self.assertEqual(NS_DISCO_INFO, element.feature.uri)
586            self.assertEqual('jabber:iq:version', element.feature['var'])
587
588        def info(requestor, target, nodeIdentifier):
589            self.assertEqual(JID('test@example.com'), requestor)
590            self.assertEqual(JID('example.com'), target)
591            self.assertEqual('', nodeIdentifier)
592
593            return defer.succeed([
594                disco.DiscoIdentity('dummy', 'generic', 'Generic Dummy Entity'),
595                disco.DiscoFeature('jabber:iq:version')
596            ])
597
598        self.service.info = info
599        d = self.handleRequest(xml)
600        d.addCallback(cb)
601        return d
602
603
604    def test_onDiscoInfoWithNode(self):
605        """
606        An info request for a node should return it in the response.
607        """
608        xml = """<iq from='test@example.com' to='example.com'
609                     type='get'>
610                   <query xmlns='%s' node='test'/>
611                 </iq>""" % NS_DISCO_INFO
612
613        def cb(element):
614            self.assertTrue(element.hasAttribute('node'))
615            self.assertEqual('test', element['node'])
616
617        def info(requestor, target, nodeIdentifier):
618            self.assertEqual('test', nodeIdentifier)
619
620            return defer.succeed([
621                disco.DiscoFeature('jabber:iq:version')
622            ])
623
624        self.service.info = info
625        d = self.handleRequest(xml)
626        d.addCallback(cb)
627        return d
628
629
630    def test_onDiscoItems(self):
631        """
632        C{onDiscoItems} should process an items request and return a response.
633
634        The request should be parsed, C{items} called with the extracted
635        parameters, and then the result should be formatted into a proper
636        response element.
637        """
638        xml = """<iq from='test@example.com' to='example.com'
639                     type='get'>
640                   <query xmlns='%s'/>
641                 </iq>""" % NS_DISCO_ITEMS
642
643        def cb(element):
644            self.assertEqual('query', element.name)
645            self.assertEqual(NS_DISCO_ITEMS, element.uri)
646            self.assertEqual(NS_DISCO_ITEMS, element.item.uri)
647            self.assertEqual('example.com', element.item['jid'])
648            self.assertEqual('test', element.item['node'])
649            self.assertEqual('Test node', element.item['name'])
650
651        def items(requestor, target, nodeIdentifier):
652            self.assertEqual(JID('test@example.com'), requestor)
653            self.assertEqual(JID('example.com'), target)
654            self.assertEqual('', nodeIdentifier)
655
656            return defer.succeed([
657                disco.DiscoItem(JID('example.com'), 'test', 'Test node'),
658            ])
659
660        self.service.items = items
661        d = self.handleRequest(xml)
662        d.addCallback(cb)
663        return d
664
665
666    def test_onDiscoItemsWithNode(self):
667        """
668        An items request for a node should return it in the response.
669        """
670        xml = """<iq from='test@example.com' to='example.com'
671                     type='get'>
672                   <query xmlns='%s' node='test'/>
673                 </iq>""" % NS_DISCO_ITEMS
674
675        def cb(element):
676            self.assertTrue(element.hasAttribute('node'))
677            self.assertEqual('test', element['node'])
678
679        def items(requestor, target, nodeIdentifier):
680            self.assertEqual('test', nodeIdentifier)
681
682            return defer.succeed([
683                disco.DiscoFeature('jabber:iq:version')
684            ])
685
686        self.service.items = items
687        d = self.handleRequest(xml)
688        d.addCallback(cb)
689        return d
690
691
692    def test_info(self):
693        """
694        C{info} should gather disco info from sibling handlers.
695        """
696        discoItems = [disco.DiscoIdentity('dummy', 'generic',
697                                          'Generic Dummy Entity'),
698                      disco.DiscoFeature('jabber:iq:version')
699        ]
700
701        class DiscoResponder(XMPPHandler):
702            implements(disco.IDisco)
703
704            def getDiscoInfo(self, requestor, target, nodeIdentifier):
705                if not nodeIdentifier:
706                    return defer.succeed(discoItems)
707                else:
708                    return defer.succeed([])
709
710        def cb(result):
711            self.assertEquals(discoItems, result)
712
713        self.service.parent = [self.service, DiscoResponder()]
714        d = self.service.info(JID('test@example.com'), JID('example.com'), '')
715        d.addCallback(cb)
716        return d
717
718
719    def test_items(self):
720        """
721        C{info} should gather disco items from sibling handlers.
722        """
723        discoItems = [disco.DiscoItem(JID('example.com'), 'test', 'Test node')]
724
725        class DiscoResponder(XMPPHandler):
726            implements(disco.IDisco)
727
728            def getDiscoItems(self, requestor, target, nodeIdentifier):
729                if not nodeIdentifier:
730                    return defer.succeed(discoItems)
731                else:
732                    return defer.succeed([])
733
734        def cb(result):
735            self.assertEquals(discoItems, result)
736
737        self.service.parent = [self.service, DiscoResponder()]
738        d = self.service.items(JID('test@example.com'), JID('example.com'), '')
739        d.addCallback(cb)
740        return d
Note: See TracBrowser for help on using the repository browser.