Ignore:
Timestamp:
Dec 26, 2008, 2:40:11 PM (14 years ago)
Author:
Ralph Meijer <ralphm@…>
Branch:
default
Convert:
svn:b33ecbfc-034c-dc11-8662-000475d9059e/trunk@140
Message:

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:
1 edited

Legend:

Unmodified
Added
Removed
  • wokkel/test/test_disco.py

    r31 r46  
    88from twisted.internet import defer
    99from twisted.trial import unittest
    10 from twisted.words.xish.xmlstream import XmlStreamFactory
     10from twisted.words.protocols.jabber.jid import JID
    1111from zope.interface import implements
    1212
    13 from wokkel.subprotocols import XMPPHandler, StreamManager
    14 
    1513from wokkel import disco
     14from wokkel.subprotocols import XMPPHandler
     15from wokkel.test.helpers import TestableRequestHandlerMixin
     16
    1617
    1718NS_DISCO_INFO = 'http://jabber.org/protocol/disco#info'
    1819NS_DISCO_ITEMS = 'http://jabber.org/protocol/disco#items'
    1920
    20 class DiscoResponder(XMPPHandler):
    21     implements(disco.IDisco)
    22 
    23     def getDiscoInfo(self, requestor, target, nodeIdentifier):
    24         if not nodeIdentifier:
     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
    2559            return defer.succeed([
    2660                disco.DiscoIdentity('dummy', 'generic', 'Generic Dummy Entity'),
    2761                disco.DiscoFeature('jabber:iq:version')
    2862            ])
    29         else:
    30             return defer.succeed([])
    31 
    32 class DiscoHandlerTest(unittest.TestCase):
    33     def test_DiscoInfo(self):
    34         factory = XmlStreamFactory()
    35         sm = StreamManager(factory)
    36         disco.DiscoHandler().setHandlerParent(sm)
    37         DiscoResponder().setHandlerParent(sm)
    38         xs = factory.buildProtocol(None)
    39         output = []
    40         xs.send = output.append
    41         xs.connectionMade()
    42         xs.dispatch(xs, "//event/stream/authd")
    43         xs.dataReceived("<stream>")
    44         xs.dataReceived("""<iq from='test@example.com' to='example.com'
    45                                type='get'>
    46                              <query xmlns='%s'/>
    47                            </iq>""" % NS_DISCO_INFO)
    48         reply = output[0]
    49         self.assertEqual(NS_DISCO_INFO, reply.query.uri)
    50         self.assertEqual(NS_DISCO_INFO, reply.query.identity.uri)
    51         self.assertEqual('dummy', reply.query.identity['category'])
    52         self.assertEqual('generic', reply.query.identity['type'])
    53         self.assertEqual('Generic Dummy Entity', reply.query.identity['name'])
    54         self.assertEqual(NS_DISCO_INFO, reply.query.feature.uri)
    55         self.assertEqual('jabber:iq:version', reply.query.feature['var'])
    56 
     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 TracChangeset for help on using the changeset viewer.