source: ralphm-patches/stanza-module.patch

wokkel/generic.py

@@ -7 +7 @@
 Generic XMPP protocol helpers.
 """
 
+__all__ = ['parseXml', 'FallbackHandler', 'VersionHandler', 'XmlPipe',
+           'DeferredXmlStreamFactory', 'prepareIDNName',
+           'Stanza', 'Request', 'ErrorStanza']
+
 from zope.interface import implements
 
 from twisted.internet import defer, protocol
-from twisted.python import reflect
 from twisted.python.deprecate import deprecated
 from twisted.python.versions import Version
-from twisted.words.protocols.jabber import error, jid, xmlstream
+from twisted.words.protocols.jabber import error, xmlstream
 from twisted.words.protocols.jabber.xmlstream import toResponse
 from twisted.words.xish import domish, utility
 from twisted.words.xish.xmlstream import BootstrapMixin
 
 from wokkel.iwokkel import IDisco
+from wokkel.stanza import Stanza, ErrorStanza, Request
 from wokkel.subprotocols import XMPPHandler
 
 IQ_GET = '/iq[@type="get"]'
@@ -47 +51 @@
 
 
 
-def stripNamespace(rootElement):
-    namespace = rootElement.uri
-
-    def strip(element):
-        if element.uri == namespace:
-            element.uri = None
-            if element.defaultUri == namespace:
-                element.defaultUri = None
-            for child in element.elements():
-                strip(child)
-
-    if namespace is not None:
-        strip(rootElement)
-
-    return rootElement
-
-
-
 class FallbackHandler(XMPPHandler):
     """
     XMPP subprotocol handler that catches unhandled iq requests.
@@ -162 +148 @@
 
 
 
-class Stanza(object):
-    """
-    Abstract representation of a stanza.
-
-    @ivar sender: The sending entity.
-    @type sender: L{jid.JID}
-    @ivar recipient: The receiving entity.
-    @type recipient: L{jid.JID}
-    """
-
-    recipient = None
-    sender = None
-    stanzaKind = None
-    stanzaID = None
-    stanzaType = None
-
-    def __init__(self, recipient=None, sender=None):
-        self.recipient = recipient
-        self.sender = sender
-
-
-    @classmethod
-    def fromElement(Class, element):
-        """
-        Create a stanza from a L{domish.Element}.
-        """
-        stanza = Class()
-        stanza.parseElement(element)
-        return stanza
-
-
-    def parseElement(self, element):
-        """
-        Parse the stanza element.
-
-        This is called with the stanza's element when a L{Stanza} is
-        created using L{fromElement}. It parses the stanza's core attributes
-        (addressing, type and id), strips the namespace from the stanza
-        element for easier transport across streams and passes on
-        child elements for further parsing.
-
-        Child element parsers are defined by providing a C{childParsers}
-        attribute on a subclass, as a mapping from (URI, name) to the name
-        of the handler on C{self}. C{parseElement} will accumulate
-        C{childParsers} from its class hierarchy, iterate over the child
-        elements and pass it to matching handlers based on the child element's
-        URI and name. The special key of C{None} can be used to pass all
-        child elements to.
-        """
-        if element.hasAttribute('from'):
-            self.sender = jid.internJID(element['from'])
-        if element.hasAttribute('to'):
-            self.recipient = jid.internJID(element['to'])
-        self.stanzaType = element.getAttribute('type')
-        self.stanzaID = element.getAttribute('id')
-
-        # Save element
-        stripNamespace(element)
-        self.element = element
-
-        # accumulate all childHandlers in the class hierarchy of Class 
-        handlers = {}
-        reflect.accumulateClassDict(self.__class__, 'childParsers', handlers)
-
-        for child in element.elements():
-            try:
-                handler = handlers[child.uri, child.name]
-            except KeyError:
-                try:
-                    handler = handlers[None]
-                except KeyError:
-                    continue
-
-            getattr(self, handler)(child)
-
-
-    def toElement(self):
-        element = domish.Element((None, self.stanzaKind))
-        if self.sender is not None:
-            element['from'] = self.sender.full()
-        if self.recipient is not None:
-            element['to'] = self.recipient.full()
-        if self.stanzaType:
-            element['type'] = self.stanzaType
-        if self.stanzaID:
-            element['id'] = self.stanzaID
-        return element
-
-
-
-class ErrorStanza(Stanza):
-
-    def parseElement(self, element):
-        Stanza.parseElement(self, element)
-        self.exception = error.exceptionFromStanza(element)
-
-
-
-class Request(Stanza):
-    """
-    IQ request stanza.
-
-    This is a base class for IQ get or set stanzas, to be used with
-    L{wokkel.subprotocols.StreamManager.request}.
-    """
-
-    stanzaKind = 'iq'
-    stanzaType = 'get'
-    timeout = None
-
-    childParsers = {None: 'parseRequest'}
-
-    def __init__(self, recipient=None, sender=None, stanzaType=None):
-        Stanza.__init__(self, recipient=recipient, sender=sender)
-        if stanzaType is not None:
-            self.stanzaType = stanzaType
-
-
-    def parseRequest(self, element):
-        """
-        Called with the request's child element for parsing.
-
-        When a request instance is created using L{fromElement}, this method
-        is called with the child element of the iq. Override this method for
-        parsing the request's payload.
-        """
-
-
-    def toElement(self):
-        element = Stanza.toElement(self)
-
-        if not self.stanzaID:
-            element.addUniqueId()
-            self.stanzaID = element['id']
-
-        return element
-
-
-
 class DeferredXmlStreamFactory(BootstrapMixin, protocol.ClientFactory):
     protocol = xmlstream.XmlStream
 

new file wokkel/stanza.py

@@ +1 @@
+# -*- test-case-name: wokkel.test.test_stanza -*-
+#
+# Copyright (c) Ralph Meijer.
+# See LICENSE for details.
+
+"""
+XMPP Stanza helpers.
+"""
+
+from twisted.python import reflect
+from twisted.words.protocols.jabber import error, jid
+from twisted.words.xish import domish
+
+def stripNamespace(rootElement):
+    namespace = rootElement.uri
+
+    def strip(element):
+        if element.uri == namespace:
+            element.uri = None
+            if element.defaultUri == namespace:
+                element.defaultUri = None
+            for child in element.elements():
+                strip(child)
+
+    if namespace is not None:
+        strip(rootElement)
+
+    return rootElement
+
+
+
+class Stanza(object):
+    """
+    Abstract representation of a stanza.
+
+    @ivar recipient: The receiving entity.
+    @type recipient: L{jid.JID}
+
+    @ivar sender: The sending entity.
+    @type sender: L{jid.JID}
+
+    @ivar stanzaKind: One of C{'message'}, C{'presence'}, C{'iq'}.
+    @type stanzaKind: L{unicode}.
+
+    @ivar stanzaID: The optional stanza identifier.
+    @type stanzaID: L{unicode}.
+
+    @ivar stanzaType: The optional stanza type.
+    @type stanzaType: L{unicode}.
+
+    @ivar element: The serialized XML of this stanza.
+    @type element: L{domish.Element}.
+    """
+
+    recipient = None
+    sender = None
+    stanzaKind = None
+    stanzaID = None
+    stanzaType = None
+    element = None
+
+    def __init__(self, recipient=None, sender=None):
+        self.recipient = recipient
+        self.sender = sender
+
+
+    @classmethod
+    def fromElement(Class, element):
+        """
+        Create a stanza from a L{domish.Element}.
+        """
+        stanza = Class()
+        stanza.parseElement(element)
+        return stanza
+
+
+    def parseElement(self, element):
+        """
+        Parse the stanza element.
+
+        This is called with the stanza's element when a L{Stanza} is
+        created using L{fromElement}. It parses the stanza's core attributes
+        (addressing, type and id), strips the namespace from the stanza
+        element for easier transport across streams and passes on
+        child elements for further parsing.
+
+        Child element parsers are defined by providing a C{childParsers}
+        attribute on a subclass, as a mapping from (URI, name) to the name
+        of the handler on C{self}. C{parseElement} will accumulate
+        C{childParsers} from its class hierarchy, iterate over the child
+        elements and pass it to matching handlers based on the child element's
+        URI and name. The special key of C{None} can be used to pass all
+        child elements to.
+        """
+        if element.hasAttribute('from'):
+            self.sender = jid.internJID(element['from'])
+        if element.hasAttribute('to'):
+            self.recipient = jid.internJID(element['to'])
+        self.stanzaKind = element.name
+        self.stanzaType = element.getAttribute('type')
+        self.stanzaID = element.getAttribute('id')
+
+        # Save element
+        stripNamespace(element)
+        self.element = element
+
+        # accumulate all childHandlers in the class hierarchy of Class 
+        handlers = {}
+        reflect.accumulateClassDict(self.__class__, 'childParsers', handlers)
+
+        for child in element.elements():
+            try:
+                handler = handlers[child.uri, child.name]
+            except KeyError:
+                try:
+                    handler = handlers[None]
+                except KeyError:
+                    continue
+
+            getattr(self, handler)(child)
+
+
+    def toElement(self):
+        element = domish.Element((None, self.stanzaKind))
+        self.element = element
+        if self.sender is not None:
+            element['from'] = self.sender.full()
+        if self.recipient is not None:
+            element['to'] = self.recipient.full()
+        if self.stanzaType:
+            element['type'] = self.stanzaType
+        if self.stanzaID:
+            element['id'] = self.stanzaID
+        return element
+
+
+
+class ErrorStanza(Stanza):
+
+    def parseElement(self, element):
+        Stanza.parseElement(self, element)
+        self.exception = error.exceptionFromStanza(element)
+
+
+
+class Request(Stanza):
+    """
+    IQ request stanza.
+
+    This is a base class for IQ get or set stanzas, to be used with
+    L{wokkel.subprotocols.StreamManager.request}.
+    """
+
+    stanzaKind = 'iq'
+    stanzaType = 'get'
+    timeout = None
+
+    childParsers = {None: 'parseRequest'}
+
+    def __init__(self, recipient=None, sender=None, stanzaType=None):
+        Stanza.__init__(self, recipient=recipient, sender=sender)
+        if stanzaType is not None:
+            self.stanzaType = stanzaType
+
+
+    def parseRequest(self, element):
+        """
+        Called with the request's child element for parsing.
+
+        When a request instance is created using L{fromElement}, this method
+        is called with the child element of the iq. Override this method for
+        parsing the request's payload.
+        """
+
+
+    def toElement(self):
+        element = Stanza.toElement(self)
+
+        if not self.stanzaID:
+            element.addUniqueId()
+            self.stanzaID = element['id']
+
+        return element
+
+
+

new file wokkel/test/test_stanza.py

@@ +1 @@
+# Copyright (c) Ralph Meijer.
+# See LICENSE for details.
+
+from twisted.trial import unittest
+from twisted.words.protocols.jabber.jid import JID
+
+from wokkel.generic import parseXml
+from wokkel.stanza import Request, Stanza
+
+NS_VERSION = 'jabber:iq:version'
+
+"""
+Tests for L{wokkel.stanza}.
+"""
+
+
+
+class StanzaTest(unittest.TestCase):
+    """
+    Tests for L{Stanza}.
+    """
+
+    def test_fromElement(self):
+        xml = """
+        <message type='chat' from='other@example.org' to='user@example.org'/>
+        """
+
+        element = parseXml(xml)
+        stanza = Stanza.fromElement(element)
+        self.assertEqual('chat', stanza.stanzaType)
+        self.assertEqual(JID('other@example.org'), stanza.sender)
+        self.assertEqual(JID('user@example.org'), stanza.recipient)
+        self.assertIdentical(element, stanza.element)
+
+
+    def test_fromElementStanzaKind(self):
+        """
+        The stanza kind is also recorded in the stanza.
+        """
+        xml = """<presence/>"""
+        stanza = Stanza.fromElement(parseXml(xml))
+        self.assertEqual(u'presence', stanza.stanzaKind)
+
+
+    def test_fromElementChildParser(self):
+        """
+        Child elements for which no parser is defined are ignored.
+        """
+        xml = """
+        <message from='other@example.org' to='user@example.org'>
+          <x xmlns='http://example.org/'/>
+        </message>
+        """
+
+        class Message(Stanza):
+            childParsers = {('http://example.org/', 'x'): '_childParser_x'}
+            elements = []
+
+            def _childParser_x(self, element):
+                self.elements.append(element)
+
+        message = Message.fromElement(parseXml(xml))
+        self.assertEqual(1, len(message.elements))
+
+
+    def test_fromElementChildParserAll(self):
+        """
+        Child elements for which no parser is defined are ignored.
+        """
+        xml = """
+        <message from='other@example.org' to='user@example.org'>
+          <x xmlns='http://example.org/'/>
+        </message>
+        """
+
+        class Message(Stanza):
+            childParsers = {None: '_childParser'}
+            elements = []
+
+            def _childParser(self, element):
+                self.elements.append(element)
+
+        message = Message.fromElement(parseXml(xml))
+        self.assertEqual(1, len(message.elements))
+
+
+    def test_fromElementChildParserUnknown(self):
+        """
+        Child elements for which no parser is defined are ignored.
+        """
+        xml = """
+        <message from='other@example.org' to='user@example.org'>
+          <x xmlns='http://example.org/'/>
+        </message>
+        """
+        Stanza.fromElement(parseXml(xml))
+
+
+
+
+class RequestTest(unittest.TestCase):
+    """
+    Tests for L{Request}.
+    """
+
+    def setUp(self):
+        self.request = Request()
+
+
+    def test_requestParser(self):
+        """
+        The request's child element is passed to requestParser.
+        """
+        xml = """
+        <iq type='get'>
+          <query xmlns='jabber:iq:version'/>
+        </iq>
+        """
+
+        class VersionRequest(Request):
+            elements = []
+
+            def parseRequest(self, element):
+                self.elements.append((element.uri, element.name))
+
+        request = VersionRequest.fromElement(parseXml(xml))
+        self.assertEqual([(NS_VERSION, 'query')], request.elements)
+
+
+    def test_toElementStanzaKind(self):
+        """
+        A request is an iq stanza.
+        """
+        element = self.request.toElement()
+        self.assertIdentical(None, element.uri)
+        self.assertEquals('iq', element.name)
+
+
+    def test_toElementStanzaType(self):
+        """
+        The request has type 'get'.
+        """
+        self.assertEquals('get', self.request.stanzaType)
+        element = self.request.toElement()
+        self.assertEquals('get', element.getAttribute('type'))
+
+
+    def test_toElementStanzaTypeSet(self):
+        """
+        The request has type 'set'.
+        """
+        self.request.stanzaType = 'set'
+        element = self.request.toElement()
+        self.assertEquals('set', element.getAttribute('type'))
+
+
+    def test_toElementStanzaID(self):
+        """
+        A request, when rendered, has an identifier.
+        """
+        element = self.request.toElement()
+        self.assertNotIdentical(None, self.request.stanzaID)
+        self.assertEquals(self.request.stanzaID, element.getAttribute('id'))
+
+
+    def test_toElementRecipient(self):
+        """
+        A request without recipient, has no 'to' attribute.
+        """
+        self.request = Request(recipient=JID('other@example.org'))
+        self.assertEquals(JID('other@example.org'), self.request.recipient)
+        element = self.request.toElement()
+        self.assertEquals(u'other@example.org', element.getAttribute('to'))
+
+
+    def test_toElementRecipientNone(self):
+        """
+        A request without recipient, has no 'to' attribute.
+        """
+        element = self.request.toElement()
+        self.assertFalse(element.hasAttribute('to'))
+
+
+    def test_toElementSender(self):
+        """
+        A request with sender, has a 'from' attribute.
+        """
+        self.request = Request(sender=JID('user@example.org'))
+        self.assertEquals(JID('user@example.org'), self.request.sender)
+        element = self.request.toElement()
+        self.assertEquals(u'user@example.org', element.getAttribute('from'))
+
+
+    def test_toElementSenderNone(self):
+        """
+        A request without sender, has no 'from' attribute.
+        """
+        element = self.request.toElement()
+        self.assertFalse(element.hasAttribute('from'))
+
+
+    def test_timeoutDefault(self):
+        """
+        The default is no timeout.
+        """
+        self.assertIdentical(None, self.request.timeout)
+
+
+    def test_stanzaTypeInit(self):
+        """
+        If stanzaType is passed in __init__, it overrides the class variable.
+        """
+
+        class SetRequest(Request):
+            stanzaType = 'set'
+
+        request = SetRequest(stanzaType='get')
+        self.assertEqual('get', request.stanzaType)
+
+
+    def test_stanzaTypeClass(self):
+        """
+        If stanzaType is not passed in __init__, the class variable is used.
+        """
+
+        class SetRequest(Request):
+            stanzaType = 'set'
+
+        request = SetRequest()
+        self.assertEqual('set', request.stanzaType)