source: wokkel/test/test_disco.py @ 46:4ee1f9c08b22

Last change on this file since 46:4ee1f9c08b22 was 46:4ee1f9c08b22, checked in by Ralph Meijer <ralphm@…>, 14 years ago

If provided, return NodeID in the response for Service Discovery requests.

This also renames the namespace constants to include DISCO in their name
and provides better tests and docstrings.

Author: ralphm.
Reviewer: tofu.
Fixes #7.

File size: 6.7 KB
Line 
1# Copyright (c) 2003-2008 Ralph Meijer
2# See LICENSE for details.
3
4"""
5Tests for L{wokkel.disco}.
6"""
7
8from twisted.internet import defer
9from twisted.trial import unittest
10from twisted.words.protocols.jabber.jid import JID
11from zope.interface import implements
12
13from wokkel import disco
14from wokkel.subprotocols import XMPPHandler
15from wokkel.test.helpers import TestableRequestHandlerMixin
16
17
18NS_DISCO_INFO = 'http://jabber.org/protocol/disco#info'
19NS_DISCO_ITEMS = 'http://jabber.org/protocol/disco#items'
20
21
22class DiscoHandlerTest(unittest.TestCase, TestableRequestHandlerMixin):
23    """
24    Tests for L{disco.DiscoHandler}.
25    """
26
27    def setUp(self):
28        self.service = disco.DiscoHandler()
29
30
31    def test_onDiscoInfo(self):
32        """
33        C{onDiscoInfo} should process an info request and return a response.
34
35        The request should be parsed, C{info} called with the extracted
36        parameters, and then the result should be formatted into a proper
37        response element.
38        """
39        xml = """<iq from='test@example.com' to='example.com'
40                     type='get'>
41                   <query xmlns='%s'/>
42                 </iq>""" % NS_DISCO_INFO
43
44        def cb(element):
45            self.assertEqual('query', element.name)
46            self.assertEqual(NS_DISCO_INFO, element.uri)
47            self.assertEqual(NS_DISCO_INFO, element.identity.uri)
48            self.assertEqual('dummy', element.identity['category'])
49            self.assertEqual('generic', element.identity['type'])
50            self.assertEqual('Generic Dummy Entity', element.identity['name'])
51            self.assertEqual(NS_DISCO_INFO, element.feature.uri)
52            self.assertEqual('jabber:iq:version', element.feature['var'])
53
54        def info(requestor, target, nodeIdentifier):
55            self.assertEqual(JID('test@example.com'), requestor)
56            self.assertEqual(JID('example.com'), target)
57            self.assertEqual('', nodeIdentifier)
58
59            return defer.succeed([
60                disco.DiscoIdentity('dummy', 'generic', 'Generic Dummy Entity'),
61                disco.DiscoFeature('jabber:iq:version')
62            ])
63
64        self.service.info = info
65        d = self.handleRequest(xml)
66        d.addCallback(cb)
67        return d
68
69    def test_onDiscoInfoWithNode(self):
70        """
71        An info request for a node should return it in the response.
72        """
73        xml = """<iq from='test@example.com' to='example.com'
74                     type='get'>
75                   <query xmlns='%s' node='test'/>
76                 </iq>""" % NS_DISCO_INFO
77
78        def cb(element):
79            self.assertTrue(element.hasAttribute('node'))
80            self.assertEqual('test', element['node'])
81
82        def info(requestor, target, nodeIdentifier):
83            self.assertEqual('test', nodeIdentifier)
84
85            return defer.succeed([
86                disco.DiscoFeature('jabber:iq:version')
87            ])
88
89        self.service.info = info
90        d = self.handleRequest(xml)
91        d.addCallback(cb)
92        return d
93
94
95    def test_onDiscoItems(self):
96        """
97        C{onDiscoItems} should process an items request and return a response.
98
99        The request should be parsed, C{items} called with the extracted
100        parameters, and then the result should be formatted into a proper
101        response element.
102        """
103        xml = """<iq from='test@example.com' to='example.com'
104                     type='get'>
105                   <query xmlns='%s'/>
106                 </iq>""" % NS_DISCO_ITEMS
107
108        def cb(element):
109            self.assertEqual('query', element.name)
110            self.assertEqual(NS_DISCO_ITEMS, element.uri)
111            self.assertEqual(NS_DISCO_ITEMS, element.item.uri)
112            self.assertEqual('example.com', element.item['jid'])
113            self.assertEqual('test', element.item['node'])
114            self.assertEqual('Test node', element.item['name'])
115
116        def items(requestor, target, nodeIdentifier):
117            self.assertEqual(JID('test@example.com'), requestor)
118            self.assertEqual(JID('example.com'), target)
119            self.assertEqual('', nodeIdentifier)
120
121            return defer.succeed([
122                disco.DiscoItem(JID('example.com'), 'test', 'Test node'),
123            ])
124
125        self.service.items = items
126        d = self.handleRequest(xml)
127        d.addCallback(cb)
128        return d
129
130    def test_onDiscoItemsWithNode(self):
131        """
132        An items request for a node should return it in the response.
133        """
134        xml = """<iq from='test@example.com' to='example.com'
135                     type='get'>
136                   <query xmlns='%s' node='test'/>
137                 </iq>""" % NS_DISCO_ITEMS
138
139        def cb(element):
140            self.assertTrue(element.hasAttribute('node'))
141            self.assertEqual('test', element['node'])
142
143        def items(requestor, target, nodeIdentifier):
144            self.assertEqual('test', nodeIdentifier)
145
146            return defer.succeed([
147                disco.DiscoFeature('jabber:iq:version')
148            ])
149
150        self.service.items = items
151        d = self.handleRequest(xml)
152        d.addCallback(cb)
153        return d
154
155
156    def test_info(self):
157        """
158        C{info} should gather disco info from sibling handlers.
159        """
160        discoItems = [disco.DiscoIdentity('dummy', 'generic',
161                                          'Generic Dummy Entity'),
162                      disco.DiscoFeature('jabber:iq:version')
163        ]
164
165        class DiscoResponder(XMPPHandler):
166            implements(disco.IDisco)
167
168            def getDiscoInfo(self, requestor, target, nodeIdentifier):
169                if not nodeIdentifier:
170                    return defer.succeed(discoItems)
171                else:
172                    return defer.succeed([])
173
174        def cb(result):
175            self.assertEquals(discoItems, result)
176
177        self.service.parent = [self.service, DiscoResponder()]
178        d = self.service.info(JID('test@example.com'), JID('example.com'), '')
179        d.addCallback(cb)
180        return d
181
182
183    def test_items(self):
184        """
185        C{info} should gather disco items from sibling handlers.
186        """
187        discoItems = [disco.DiscoItem(JID('example.com'), 'test', 'Test node')]
188
189        class DiscoResponder(XMPPHandler):
190            implements(disco.IDisco)
191
192            def getDiscoItems(self, requestor, target, nodeIdentifier):
193                if not nodeIdentifier:
194                    return defer.succeed(discoItems)
195                else:
196                    return defer.succeed([])
197
198        def cb(result):
199            self.assertEquals(discoItems, result)
200
201        self.service.parent = [self.service, DiscoResponder()]
202        d = self.service.items(JID('test@example.com'), JID('example.com'), '')
203        d.addCallback(cb)
204        return d
Note: See TracBrowser for help on using the repository browser.