source: ralphm-patches/disco-addressing.patch @ 47:f6d222b68f1c

wokkel/disco.py

@@ -14 +14 @@
 from twisted.words.protocols.jabber import error, jid
 from twisted.words.xish import domish
 
-from wokkel import data_form
+from wokkel import data_form, generic
 from wokkel.compat import IQ
 from wokkel.iwokkel import IDisco
 from wokkel.subprotocols import IQHandlerMixin, XMPPHandler
@@ -346 +346 @@
 
 
 
-class _DiscoRequest(IQ):
+class _DiscoRequest(generic.Request):
     """
-    Element representing an XMPP service discovery request.
+    A Service Discovery request.
+
+    @ivar verb: Type of request: C{'info'} or C{'items'}.
+    @type verb: C{str}
+    @ivar nodeIdentifier: Optional node to request info for.
+    @type nodeIdentifier: C{unicode}
     """
 
-    def __init__(self, xs, namespace, nodeIdentifier=''):
-        """
-        Initialize the request.
+    verb = None
+    nodeIdentifier = ''
 
-        @param xs: XML Stream the request should go out on.
-        @type xs: L{xmlstream.XmlStream}
-        @param namespace: Request namespace.
-        @type namespace: C{str}
-        @param nodeIdentifier: Node to request info from.
-        @type nodeIdentifier: C{unicode}
-        """
-        IQ.__init__(self, xs, "get")
-        query = self.addElement((namespace, 'query'))
-        if nodeIdentifier:
-            query['node'] = nodeIdentifier
+    _requestVerbMap = {
+            NS_DISCO_INFO: 'info',
+            NS_DISCO_ITEMS: 'items',
+            }
+
+    _verbRequestMap = dict(((v, k) for k, v in _requestVerbMap.iteritems()))
+
+    def __init__(self, verb=None, nodeIdentifier='',
+                       recipient=None, sender=None):
+        generic.Request.__init__(self, 'get', recipient, sender)
+        self.verb = verb
+        self.nodeIdentifier = nodeIdentifier
+
+
+    def parseElement(self, element):
+        generic.Request.parseElement(self, element)
+
+        verbElement = None
+        for child in element.elements():
+            if child.name == 'query' and child.uri in self._requestVerbMap:
+                self.verb = self._requestVerbMap[child.uri]
+                verbElement = child
+
+        if verbElement:
+            self.nodeIdentifier = verbElement.getAttribute('node', '')
+
+
+    def toElement(self):
+        element = generic.Request.toElement(self)
+
+        childURI = self._verbRequestMap[self.verb]
+        query = element.addElement((childURI, 'query'))
+
+        if self.nodeIdentifier:
+            query['node'] = self.nodeIdentifier
+
+        return element
 
 
 
@@ -388 +418 @@
         @type sender: L{jid.JID}
         """
 
-        request = _DiscoRequest(self.xmlstream, NS_DISCO_INFO, nodeIdentifier)
-        if sender is not None:
-            request['from'] = unicode(sender)
+        request = _DiscoRequest('info', nodeIdentifier)
+        request.sender = sender
+        request.recipient = entity
 
-        d = request.send(entity.full())
+        d = self.request(request)
         d.addCallback(lambda iq: DiscoInfo.fromElement(iq.query))
         return d
 
@@ -411 +441 @@
         @type sender: L{jid.JID}
         """
 
-        request = _DiscoRequest(self.xmlstream, NS_DISCO_ITEMS, nodeIdentifier)
-        if sender is not None:
-            request['from'] = unicode(sender)
+        request = _DiscoRequest('items', nodeIdentifier)
+        request.sender = sender
+        request.recipient = entity
 
-        d = request.send(entity.full())
+        d = self.request(request)
         d.addCallback(lambda iq: DiscoItems.fromElement(iq.query))
         return d
 
@@ -445 +475 @@
         @param iq: The request iq element.
         @type iq: L{Element<twisted.words.xish.domish.Element>}
         """
-        requestor = jid.internJID(iq["from"])
-        target = jid.internJID(iq["to"])
-        nodeIdentifier = iq.query.getAttribute("node", '')
+        request = _DiscoRequest.fromElement(iq)
 
         def toResponse(info):
-            if nodeIdentifier and not info:
+            if request.nodeIdentifier and not info:
                 raise error.StanzaError('item-not-found')
             else:
                 response = DiscoInfo()
-                response.nodeIdentifier = nodeIdentifier
+                response.nodeIdentifier = request.nodeIdentifier
 
                 for item in info:
                     response.append(item)
 
             return response.toElement()
 
-        d = self.info(requestor, target, nodeIdentifier)
+        d = self.info(request.sender, request.recipient,
+                      request.nodeIdentifier)
         d.addCallback(toResponse)
         return d
 
@@ -473 +502 @@
         @param iq: The request iq element.
         @type iq: L{Element<twisted.words.xish.domish.Element>}
         """
-        requestor = jid.internJID(iq["from"])
-        target = jid.internJID(iq["to"])
-        nodeIdentifier = iq.query.getAttribute("node", '')
+        request = _DiscoRequest.fromElement(iq)
 
         def toResponse(items):
             response = DiscoItems()
-            response.nodeIdentifier = nodeIdentifier
+            response.nodeIdentifier = request.nodeIdentifier
 
             for item in items:
                 response.append(item)
 
             return response.toElement()
 
-        d = self.items(requestor, target, nodeIdentifier)
+        d = self.items(request.sender, request.recipient,
+                       request.nodeIdentifier)
         d.addCallback(toResponse)
         return d
 

wokkel/generic.py

@@ -20 +20 @@
 except ImportError:
     from wokkel.compat import BootstrapMixin
 
-from wokkel import disco
 from wokkel.iwokkel import IDisco
 from wokkel.subprotocols import XMPPHandler
 
@@ -120 +119 @@
         info = set()
 
         if not node:
+            from wokkel import disco
             info.add(disco.DiscoFeature(NS_VERSION))
 
         return defer.succeed(info)
@@ -174 +174 @@
     @type recipient: L{jid.JID}
     """
 
+    recipient = None
+    sender = None
     stanzaKind = None
     stanzaID = None
     stanzaType = None

wokkel/test/test_disco.py

@@ -477 +477 @@
         Set up stub and protocol for testing.
         """
         self.stub = XmlStreamStub()
+        self.patch(XMPPHandler, 'request', self.request)
         self.protocol = disco.DiscoClientProtocol()
-        self.protocol.xmlstream = self.stub.xmlstream
-        self.protocol.connectionInitialized()
+
+
+    def request(self, request):
+        element = request.toElement()
+        self.stub.xmlstream.send(element)
+        return defer.Deferred()
 
 
     def test_requestItems(self):
@@ -511 +516 @@
         element = query.addElement(u'item')
         element[u'jid'] = u"test2.example.org"
 
-        self.stub.send(response)
+        d.callback(response)
         return d
 
 
@@ -527 +532 @@
 
         response = toResponse(iq, u'result')
         response.addElement((NS_DISCO_ITEMS, u'query'))
-        self.stub.send(response)
 
+        d.callback(response)
         return d
 
 
@@ -566 +571 @@
         element = query.addElement(u"feature")
         element[u'var'] = u'http://jabber.org/protocol/muc'
 
-        self.stub.send(response)
+        d.callback(response)
         return d
 
 
@@ -575 +580 @@
         A disco info request can be sent with an explicit sender address.
         """
         d = self.protocol.requestInfo(JID(u'example.org'),
-                                       sender=JID(u'test.example.org'))
+                                      sender=JID(u'test.example.org'))
 
         iq = self.stub.output[-1]
         self.assertEqual(u'test.example.org', iq.getAttribute(u'from'))
 
         response = toResponse(iq, u'result')
         response.addElement((NS_DISCO_INFO, u'query'))
-        self.stub.send(response)
 
+        d.callback(response)
         return d
 
 
@@ -676 +681 @@
         return d
 
 
+    def test_onDiscoInfoWithNoFromAttribute(self):
+        """
+        Disco info request without a from attribute has requestor None.
+        """
+        xml = """<iq to='example.com'
+                     type='get'>
+                   <query xmlns='%s'/>
+                 </iq>""" % NS_DISCO_INFO
+
+        def info(requestor, target, nodeIdentifier):
+            self.assertEqual(None, requestor)
+
+            return defer.succeed([
+                disco.DiscoIdentity('dummy', 'generic', 'Generic Dummy Entity'),
+                disco.DiscoFeature('jabber:iq:version')
+            ])
+
+        self.service.info = info
+        d = self.handleRequest(xml)
+        return d
+
+
+    def test_onDiscoInfoWithNoToAttribute(self):
+        """
+        Disco info request without a to attribute has target None.
+        """
+        xml = """<iq from='test@example.com'
+                     type='get'>
+                   <query xmlns='%s'/>
+                 </iq>""" % NS_DISCO_INFO
+
+        def info(requestor, target, nodeIdentifier):
+            self.assertEqual(JID('test@example.com'), requestor)
+
+            return defer.succeed([
+                disco.DiscoIdentity('dummy', 'generic', 'Generic Dummy Entity'),
+                disco.DiscoFeature('jabber:iq:version')
+            ])
+
+        self.service.info = info
+        d = self.handleRequest(xml)
+        return d
+
+
     def test_onDiscoInfoWithNode(self):
         """
         An info request for a node should return it in the response.