Changes in [127:1610e7a3b777:128:db5de9ee45fa]

Files:

• LICENSE (modified) (1 diff)
• NEWS (modified) (1 diff)
• README (modified) (2 diffs)
• setup.py (modified) (2 diffs)
• wokkel/client.py (modified) (4 diffs)
• wokkel/compat.py (modified) (2 diffs)
• wokkel/component.py (modified) (3 diffs)
• wokkel/data_form.py (modified) (8 diffs)
• wokkel/disco.py (modified) (3 diffs)
• wokkel/generic.py (modified) (2 diffs)
• wokkel/iwokkel.py (modified) (17 diffs)
• wokkel/pubsub.py (modified) (29 diffs)
• wokkel/server.py (added)
• wokkel/subprotocols.py (modified) (17 diffs)
• wokkel/test/helpers.py (modified) (2 diffs)
• wokkel/test/test_client.py (modified) (4 diffs)
• wokkel/test/test_compat.py (modified) (5 diffs)
• wokkel/test/test_component.py (added)
• wokkel/test/test_data_form.py (modified) (16 diffs)
• wokkel/test/test_disco.py (modified) (2 diffs)
• wokkel/test/test_generic.py (modified) (1 diff)
• wokkel/test/test_pubsub.py (modified) (25 diffs)
• wokkel/test/test_server.py (added)
• wokkel/test/test_subprotocols.py (modified) (14 diffs)

LICENSE

@@ -1 @@
-Copyright (c) 2003-2008 Ralph Meijer
+Copyright (c) 2003-2009 Ralph Meijer
 
 Permission is hereby granted, free of charge, to any person obtaining

NEWS

@@ +1 @@
+0.6.0 (2009-04-22)
+==================
+
+Features
+--------
+
+ - Server-to-server support, based on the dialback protocol (#33).
+ - Enhancement to InternalProtocol to support multiple domains (#43).
+ - Publish-subscribe request abstraction (#45).
+ - Publish-subscribe abstraction to implement a node in code (#47).
+ - Enhancement to PubSubClient to send requests from a specific JID (#46).
+
+Fixes
+-----
+
+ - Remove type interpretation in Data Forms field parsing code (#44).
+
+
+0.5.0 (2009-04-07)
+==================
+
+This release drops support for Twisted versions older than 8.0, including
+Twisted 2.5 / Twisted Words 0.5.
+ 
+Features
+--------
+
+ - Support for sending and receiving Publish-Subscribe node delete
+   notifications with redirect.
+ - Service Discovery client support, including an overhaul of disco data
+   classes (#28).
+ - Initial support for building XMPP servers has been added:
+   - XmlStreamServerFactory has been backported from Twisted Words (#29).
+   - An XMPP router has been added (#30).
+   - A server-side component authenticator has been added (#30).
+   - A new server-side component service, that connects to a router within the
+     same process, was added (#31).
+
+
+Fixes
+-----
+
+ - Publish-Subscribe subscriptions requests work again (#22).
+ - Publish-Subscribe delete node requests now have the correct namespace (#27).
+ - NodeIDs in Service Discovery requests are now returned in responses (#7).
+ - The presence of stanzaType in toResponse is now checked correctly (#34).
+ - Data Form fields are now rendered depending on form type (#40).
+ - Data Form type checking issues were addressed (#41).
+ - Some compatibility fixes for Twisted 8.0 and 8.1.
+ - Various other fixes (#37, #42) and tracking changes to code already in
+   Twisted.
+
+
 0.4.0 (2008-08-05)
 ==================

README

@@ -1 @@
-Wokkel 0.4.0
+Wokkel 0.6.0
 
 What is this?
 =============
 
-Wokkel is a Python module for experimenting with future enhancements
-to Twisted Words. Everything is aimed to be included in the Twisted
-main development tree eventually.
+Wokkel is a Python module for experimenting with future enhancements to Twisted
+Words, that should eventually be included in the main Twisted main development
+tree. Some of the code in Wokkel has already made that transition, but is still
+included to be used with older Twisted releases.
 
-Dependencies
+
+Requirements
 ============
 
-This module depends on Twisted Words 0.5 or later.
+ - Python 2.4 or later.
+ - Twisted 8.0.0 or later.
 
-Copyright
+
+Resources
 =========
 
-The code in this distribution is Copyright (c) 2003-2008 Ralph Meijer, unless
+Wokkel's home is <http://wokkel.ik.nu/>. 
+
+Besides the general Twisted resources, help is available on the Twisted-Jabber
+mailing list::
+
+  <https://mailman.ik.nu/mailman/listinfo/twisted-jabber>
+
+
+Copyright and Warranty
+======================
+
+The code in this distribution is Copyright (c) 2003-2009 Ralph Meijer, unless
 excplicitely specified otherwise.
 
@@ -22 +37 @@
 describes this in detail.
 
-Contact
-=======
 
-Questions, comments or suggestions are welcome!
+Contributors
+============
+
+ - Christopher Zorn
+ - Jack Moffitt
+ - Mike Malone
+ - Pablo Martin
+
+
+Author
+======
 
 Ralph Meijer

setup.py

@@ -1 +1 @@
 #!/usr/bin/env python
 
-# Copyright (c) 2003-2008 Ralph Meijer
+# Copyright (c) 2003-2009 Ralph Meijer
 # See LICENSE for details.
 
@@ -7 +7 @@
 
 setup(name='wokkel',
-      version='0.4.0',
+      version='0.6.0',
       description='Twisted Jabber support library',
       author='Ralph Meijer',

wokkel/client.py

@@ -12 +12 @@
 
 from twisted.application import service
-from twisted.internet import defer, protocol, reactor
+from twisted.internet import reactor
 from twisted.names.srvconnect import SRVConnector
 from twisted.words.protocols.jabber import client, sasl, xmlstream
 
-try:
-    from twisted.words.xish.xmlstream import XmlStreamFactoryMixin
-except ImportError:
-    from wokkel.compat import XmlStreamFactoryMixin
-
-from wokkel.subprotocols import StreamManager, XMPPHandler
+from wokkel import generic
+from wokkel.subprotocols import StreamManager
 
 class CheckAuthInitializer(object):
@@ -128 +124 @@
 
 
-class DeferredClientFactory(XmlStreamFactoryMixin, protocol.ClientFactory):
-    protocol = xmlstream.XmlStream
+class DeferredClientFactory(generic.DeferredXmlStreamFactory):
 
     def __init__(self, jid, password):
-        self.authenticator = client.XMPPAuthenticator(jid, password)
-        XmlStreamFactoryMixin.__init__(self, self.authenticator)
+        authenticator = client.XMPPAuthenticator(jid, password)
+        generic.DeferredXmlStreamFactory.__init__(self, authenticator)
 
-        deferred = defer.Deferred()
-        self.deferred = deferred
-
-        self.addBootstrap(xmlstream.INIT_FAILED_EVENT, deferred.errback)
-
-        class ConnectionInitializedHandler(XMPPHandler):
-            def connectionInitialized(self):
-                deferred.callback(None)
-
-        self.streamManager = StreamManager(self)
-        self.addHandler(ConnectionInitializedHandler())
-
-    def clientConnectionFailed(self, connector, reason):
-        self.deferred.errback(reason)
 
     def addHandler(self, handler):
@@ -155 +136 @@
         """
         self.streamManager.addHandler(handler)
+
 
     def removeHandler(self, handler):
@@ -163 +145 @@
 
 
+
 def clientCreator(factory):
     domain = factory.authenticator.jid.host

wokkel/compat.py

@@ -1 +1 @@
 # -*- test-case-name: wokkel.test.test_compat -*-
 #
-# Copyright (c) 2001-2007 Twisted Matrix Laboratories.
+# Copyright (c) 2001-2008 Twisted Matrix Laboratories.
 # See LICENSE for details.
 
+from twisted.internet import protocol
+from twisted.words.protocols.jabber import xmlstream
 from twisted.words.xish import domish
 
-def toResponse(stanza, stanzaType=None):
+class BootstrapMixin(object):
     """
-    Create a response stanza from another stanza.
+    XmlStream factory mixin to install bootstrap event observers.
 
-    This takes the addressing and id attributes from a stanza to create a (new,
-    empty) response stanza. The addressing attributes are swapped and the id
-    copied. Optionally, the stanza type of the response can be specified.
+    This mixin is for factories providing
+    L{IProtocolFactory<twisted.internet.interfaces.IProtocolFactory>} to make
+    sure bootstrap event observers are set up on protocols, before incoming
+    data is processed. Such protocols typically derive from
+    L{utility.EventDispatcher}, like L{XmlStream}.
 
-    @param stanza: the original stanza
-    @type stanza: L{domish.Element}
-    @param stanzaType: optional response stanza type
-    @type stanzaType: C{str}
-    @return: the response stanza.
-    @rtype: L{domish.Element}
+    You can set up bootstrap event observers using C{addBootstrap}. The
+    C{event} and C{fn} parameters correspond with the C{event} and
+    C{observerfn} arguments to L{utility.EventDispatcher.addObserver}.
+
+    @since: 8.2.
+    @ivar bootstraps: The list of registered bootstrap event observers.
+    @type bootstrap: C{list}
     """
 
-    toAddr = stanza.getAttribute('from')
-    fromAddr = stanza.getAttribute('to')
-    stanzaID = stanza.getAttribute('id')
-
-    response = domish.Element((None, stanza.name))
-    if toAddr:
-        response['to'] = toAddr
-    if fromAddr:
-        response['from'] = fromAddr
-    if stanzaID:
-        response['id'] = stanzaID
-    if type:
-        response['type'] = stanzaType
-
-    return response
+    def __init__(self):
+        self.bootstraps = []
 
 
-class XmlStreamFactoryMixin(object):
+    def installBootstraps(self, dispatcher):
+        """
+        Install registered bootstrap observers.
+
+        @param dispatcher: Event dispatcher to add the observers to.
+        @type dispatcher: L{utility.EventDispatcher}
+        """
+        for event, fn in self.bootstraps:
+            dispatcher.addObserver(event, fn)
+
+
+    def addBootstrap(self, event, fn):
+        """
+        Add a bootstrap event handler.
+
+        @param event: The event to register an observer for.
+        @type event: C{str} or L{xpath.XPathQuery}
+        @param fn: The observer callable to be registered.
+        """
+        self.bootstraps.append((event, fn))
+
+
+    def removeBootstrap(self, event, fn):
+        """
+        Remove a bootstrap event handler.
+
+        @param event: The event the observer is registered for.
+        @type event: C{str} or L{xpath.XPathQuery}
+        @param fn: The registered observer callable.
+        """
+        self.bootstraps.remove((event, fn))
+
+
+
+class XmlStreamServerFactory(BootstrapMixin,
+                             protocol.ServerFactory):
     """
-    XmlStream factory mixin that takes care of event handlers.
+    Factory for Jabber XmlStream objects as a server.
 
-    To make sure certain event observers are set up before incoming data is
-    processed, you can set up bootstrap event observers using C{addBootstrap}.
-
-    The C{event} and C{fn} parameters correspond with the C{event} and
-    C{observerfn} arguments to L{utility.EventDispatcher.addObserver}.
+    @since: 8.2.
+    @ivar authenticatorFactory: Factory callable that takes no arguments, to
+                                create a fresh authenticator to be associated
+                                with the XmlStream.
     """
 
-    def __init__(self, *args, **kwargs):
-        self.bootstraps = []
-        self.args = args
-        self.kwargs = kwargs
+    protocol = xmlstream.XmlStream
+
+    def __init__(self, authenticatorFactory):
+        BootstrapMixin.__init__(self)
+        self.authenticatorFactory = authenticatorFactory
+
 
     def buildProtocol(self, addr):
@@ -59 +87 @@
         Create an instance of XmlStream.
 
-        The returned instance will have bootstrap event observers registered
-        and will proceed to handle input on an incoming connection.
+        A new authenticator instance will be created and passed to the new
+        XmlStream. Registered bootstrap event observers are installed as well.
         """
-        xs = self.protocol(*self.args, **self.kwargs)
+        authenticator = self.authenticatorFactory()
+        xs = self.protocol(authenticator)
         xs.factory = self
-        for event, fn in self.bootstraps:
-            xs.addObserver(event, fn)
+        self.installBootstraps(xs)
         return xs
-
-    def addBootstrap(self, event, fn):
-        """
-        Add a bootstrap event handler.
-        """
-        self.bootstraps.append((event, fn))
-
-    def removeBootstrap(self, event, fn):
-        """
-        Remove a bootstrap event handler.
-        """
-        self.bootstraps.remove((event, fn))

wokkel/component.py

@@ -1 @@
-# Copyright (c) 2003-2007 Ralph Meijer
+# -*- test-case-name: wokkel.test.test_component -*-
+#
+# Copyright (c) 2003-2008 Ralph Meijer
 # See LICENSE for details.
 
@@ -8 +10 @@
 from twisted.application import service
 from twisted.internet import reactor
-from twisted.words.protocols.jabber import component
+from twisted.python import log
+from twisted.words.protocols.jabber.jid import internJID as JID
+from twisted.words.protocols.jabber import component, error, xmlstream
 from twisted.words.xish import domish
 
+try:
+    #from twisted.words.protocols.jabber.xmlstream import XMPPHandler
+    from twisted.words.protocols.jabber.xmlstream import XMPPHandlerCollection
+except ImportError:
+    #from wokkel.subprotocols import XMPPHandler
+    from wokkel.subprotocols import XMPPHandlerCollection
+
+try:
+    from twisted.words.protocols.jabber.xmlstream import XmlStreamServerFactory
+except ImportError:
+    from wokkel.compat import XmlStreamServerFactory
+
+from wokkel.generic import XmlPipe
 from wokkel.subprotocols import StreamManager
+
+NS_COMPONENT_ACCEPT = 'jabber:component:accept'
 
 class Component(StreamManager, service.Service):
@@ -57 +76 @@
     def _getConnection(self):
         return reactor.connectTCP(self.host, self.port, self.factory)
+
+
+
+class InternalComponent(XMPPHandlerCollection, service.Service):
+    """
+    Component service that connects directly to a router.
+
+    Instead of opening a socket to connect to a router, like L{Component},
+    components of this type connect to a router in the same process. This
+    allows for one-process XMPP servers.
+
+    @ivar domains: Domains (as C{str}) this component will handle traffic for.
+    @type domains: L{set}
+    """
+
+    def __init__(self, router, domain=None):
+        XMPPHandlerCollection.__init__(self)
+
+        self._router = router
+        self.domains = set()
+        if domain:
+            self.domains.add(domain)
+
+        self.xmlstream = None
+
+    def startService(self):
+        """
+        Create a XML pipe, connect to the router and setup handlers.
+        """
+        service.Service.startService(self)
+
+        self._pipe = XmlPipe()
+        self.xmlstream = self._pipe.source
+
+        for domain in self.domains:
+            self._router.addRoute(domain, self._pipe.sink)
+
+        for e in self:
+            e.makeConnection(self.xmlstream)
+            e.connectionInitialized()
+
+
+    def stopService(self):
+        """
+        Disconnect from the router and handlers.
+        """
+        service.Service.stopService(self)
+
+        for domain in self.domains:
+            self._router.removeRoute(domain, self._pipe.sink)
+
+        self._pipe = None
+        self.xmlstream = None
+
+        for e in self:
+            e.connectionLost(None)
+
+
+    def addHandler(self, handler):
+        """
+        Add a new handler and connect it to the stream.
+        """
+        XMPPHandlerCollection.addHandler(self, handler)
+
+        if self.xmlstream:
+            handler.makeConnection(self.xmlstream)
+            handler.connectionInitialized()
+
+
+    def send(self, obj):
+        """
+        Send data to the XML stream, so it ends up at the router.
+        """
+        self.xmlstream.send(obj)
+
+
+
+class ListenComponentAuthenticator(xmlstream.ListenAuthenticator):
+    """
+    Authenticator for accepting components.
+
+    @ivar secret: The shared used to authorized incoming component connections.
+    @type secret: C{str}.
+    """
+
+    namespace = NS_COMPONENT_ACCEPT
+
+    def __init__(self, secret):
+        self.secret = secret
+        xmlstream.ListenAuthenticator.__init__(self)
+
+
+    def associateWithStream(self, xs):
+        """
+        Associate the authenticator with a stream.
+
+        This sets the stream's version to 0.0, because the XEP-0114 component
+        protocol was not designed for XMPP 1.0.
+        """
+        xs.version = (0, 0)
+        xmlstream.ListenAuthenticator.associateWithStream(self, xs)
+
+
+    def streamStarted(self, rootElement):
+        """
+        Called by the stream when it has started.
+
+        This examines the default namespace of the incoming stream and whether
+        there is a requested hostname for the component. Then it generates a
+        stream identifier, sends a response header and adds an observer for
+        the first incoming element, triggering L{onElement}.
+        """
+
+        xmlstream.ListenAuthenticator.streamStarted(self, rootElement)
+
+        # Compatibility fix for pre-8.2 implementations of ListenAuthenticator
+        if not self.xmlstream.sid:
+            from twisted.python import randbytes
+            self.xmlstream.sid = randbytes.secureRandom(8).encode('hex')
+
+        if rootElement.defaultUri != self.namespace:
+            exc = error.StreamError('invalid-namespace')
+            self.xmlstream.sendStreamError(exc)
+            return
+
+        # self.xmlstream.thisEntity is set to the address the component
+        # wants to assume.
+        if not self.xmlstream.thisEntity:
+            exc = error.StreamError('improper-addressing')
+            self.xmlstream.sendStreamError(exc)
+            return
+
+        self.xmlstream.sendHeader()
+        self.xmlstream.addOnetimeObserver('/*', self.onElement)
+
+
+    def onElement(self, element):
+        """
+        Called on incoming XML Stanzas.
+
+        The very first element received should be a request for handshake.
+        Otherwise, the stream is dropped with a 'not-authorized' error. If a
+        handshake request was received, the hash is extracted and passed to
+        L{onHandshake}.
+        """
+        if (element.uri, element.name) == (self.namespace, 'handshake'):
+            self.onHandshake(unicode(element))
+        else:
+            exc = error.StreamError('not-authorized')
+            self.xmlstream.sendStreamError(exc)
+
+
+    def onHandshake(self, handshake):
+        """
+        Called upon receiving the handshake request.
+
+        This checks that the given hash in C{handshake} is equal to a
+        calculated hash, responding with a handshake reply or a stream error.
+        If the handshake was ok, the stream is authorized, and  XML Stanzas may
+        be exchanged.
+        """
+        calculatedHash = xmlstream.hashPassword(self.xmlstream.sid, self.secret)
+        if handshake != calculatedHash:
+            exc = error.StreamError('not-authorized', text='Invalid hash')
+            self.xmlstream.sendStreamError(exc)
+        else:
+            self.xmlstream.send('<handshake/>')
+            self.xmlstream.dispatch(self.xmlstream,
+                                    xmlstream.STREAM_AUTHD_EVENT)
+
+
+
+class Router(object):
+    """
+    XMPP Server's Router.
+
+    A router connects the different components of the XMPP service and routes
+    messages between them based on the given routing table.
+
+    Connected components are trusted to have correct addressing in the
+    stanzas they offer for routing.
+
+    A route destination of C{None} adds a default route. Traffic for which no
+    specific route exists, will be routed to this default route.
+
+    @ivar routes: Routes based on the host part of JIDs. Maps host names to the
+                  L{EventDispatcher<utility.EventDispatcher>}s that should
+                  receive the traffic. A key of C{None} means the default
+                  route.
+    @type routes: C{dict}
+    """
+
+    def __init__(self):
+        self.routes = {}
+
+
+    def addRoute(self, destination, xs):
+        """
+        Add a new route.
+
+        The passed XML Stream C{xs} will have an observer for all stanzas
+        added to route its outgoing traffic. In turn, traffic for
+        C{destination} will be passed to this stream.
+
+        @param destination: Destination of the route to be added as a host name
+                            or C{None} for the default route.
+        @type destination: C{str} or C{NoneType}.
+        @param xs: XML Stream to register the route for.
+        @type xs: L{EventDispatcher<utility.EventDispatcher>}.
+        """
+        self.routes[destination] = xs
+        xs.addObserver('/*', self.route)
+
+
+    def removeRoute(self, destination, xs):
+        """
+        Remove a route.
+
+        @param destination: Destination of the route that should be removed.
+        @type destination: C{str}.
+        @param xs: XML Stream to remove the route for.
+        @type xs: L{EventDispatcher<utility.EventDispatcher>}.
+        """
+        xs.removeObserver('/*', self.route)
+        if (xs == self.routes[destination]):
+            del self.routes[destination]
+
+
+    def route(self, stanza):
+        """
+        Route a stanza.
+
+        @param stanza: The stanza to be routed.
+        @type stanza: L{domish.Element}.
+        """
+        destination = JID(stanza['to'])
+
+        log.msg("Routing to %s: %r" % (destination.full(), stanza.toXml()))
+
+        if destination.host in self.routes:
+            self.routes[destination.host].send(stanza)
+        else:
+            self.routes[None].send(stanza)
+
+
+
+class XMPPComponentServerFactory(XmlStreamServerFactory):
+    """
+    XMPP Component Server factory.
+
+    This factory accepts XMPP external component connections and makes
+    the router service route traffic for a component's bound domain
+    to that component.
+    """
+
+    logTraffic = False
+
+    def __init__(self, router, secret='secret'):
+        self.router = router
+        self.secret = secret
+
+        def authenticatorFactory():
+            return ListenComponentAuthenticator(self.secret)
+
+        XmlStreamServerFactory.__init__(self, authenticatorFactory)
+        self.addBootstrap(xmlstream.STREAM_CONNECTED_EVENT,
+                          self.makeConnection)
+        self.addBootstrap(xmlstream.STREAM_AUTHD_EVENT,
+                          self.connectionInitialized)
+
+        self.serial = 0
+
+
+    def makeConnection(self, xs):
+        """
+        Called when a component connection was made.
+
+        This enables traffic debugging on incoming streams.
+        """
+        xs.serial = self.serial
+        self.serial += 1
+
+        def logDataIn(buf):
+            log.msg("RECV (%d): %r" % (xs.serial, buf))
+
+        def logDataOut(buf):
+            log.msg("SEND (%d): %r" % (xs.serial, buf))
+
+        if self.logTraffic:
+            xs.rawDataInFn = logDataIn
+            xs.rawDataOutFn = logDataOut
+
+        xs.addObserver(xmlstream.STREAM_ERROR_EVENT, self.onError)
+
+
+    def connectionInitialized(self, xs):
+        """
+        Called when a component has succesfully authenticated.
+
+        Add the component to the routing table and establish a handler
+        for a closed connection.
+        """
+        destination = xs.thisEntity.host
+
+        self.router.addRoute(destination, xs)
+        xs.addObserver(xmlstream.STREAM_END_EVENT, self.connectionLost, 0,
+                                                   destination, xs)
+
+
+    def onError(self, reason):
+        log.err(reason, "Stream Error")
+
+
+    def connectionLost(self, destination, xs, reason):
+        self.router.removeRoute(destination, xs)

wokkel/data_form.py

@@ -1 +1 @@
 # -*- test-case-name: wokkel.test.test_data_form -*-
 #
-# Copyright (c) 2003-2008 Ralph Meijer
+# Copyright (c) 2003-2009 Ralph Meijer
 # See LICENSE for details.
 
@@ -69 +69 @@
         Return the DOM representation of this option.
 
-        @rtype L{domish.Element}.
+        @rtype: L{domish.Element}.
         """
         option = domish.Element((NS_X_DATA, 'option'))
@@ -220 +220 @@
             for value in self.values:
                 if self.fieldType == 'boolean':
-                    # We send out the textual representation of boolean values
-                    value = bool(int(value))
+                    if isinstance(value, (str, unicode)):
+                        checkValue = value.lower()
+                        if not checkValue in ('0', '1', 'false', 'true'):
+                            raise ValueError("Not a boolean")
+                        value = checkValue in ('1', 'true')
+                    value = bool(value)
                 elif self.fieldType in ('jid-single', 'jid-multi'):
-                    value = value.full()
+                    if not hasattr(value, 'full'):
+                        value = JID(value)
 
                 newValues.append(value)
@@ -229 +234 @@
             self.values = newValues
 
-    def toElement(self):
+    def toElement(self, asForm=False):
         """
         Return the DOM representation of this Field.
 
-        @rtype L{domish.Element}.
+        @rtype: L{domish.Element}.
         """
 
@@ -239 +244 @@
 
         field = domish.Element((NS_X_DATA, 'field'))
-        field['type'] = self.fieldType
+
+        if asForm or self.fieldType != 'text-single':
+            field['type'] = self.fieldType
 
         if self.var is not None:
@@ -247 +254 @@
             if self.fieldType == 'boolean':
                 value = unicode(value).lower()
+            elif self.fieldType in ('jid-single', 'jid-multi'):
+                value = value.full()
+
             field.addElement('value', content=value)
 
-        if self.fieldType in ('list-single', 'list-multi'):
-            for option in self.options:
-                field.addChild(option.toElement())
-
-        if self.label is not None:
-            field['label'] = self.label
-
-        if self.desc is not None:
-            field.addElement('desc', content=self.desc)
-
-        if self.required:
-            field.addElement('required')
+        if asForm:
+            if self.fieldType in ('list-single', 'list-multi'):
+                for option in self.options:
+                    field.addChild(option.toElement())
+
+            if self.label is not None:
+                field['label'] = self.label
+
+            if self.desc is not None:
+                field.addElement('desc', content=self.desc)
+
+            if self.required:
+                field.addElement('required')
 
         return field
@@ -285 +296 @@
     def _parse_value(field, element):
         value = unicode(element)
-        if field.fieldType == 'boolean':
-            value = value.lower() in ('1', 'true')
-        elif field.fieldType in ('jid-multi', 'jid-single'):
-            value = JID(value)
         field.values.append(value)
 
@@ -425 +432 @@
 
         for field in self.fieldList:
-            form.addChild(field.toElement())
+            form.addChild(field.toElement(self.formType=='form'))
 
         return form

wokkel/disco.py

@@ -1 +1 @@
 # -*- test-case-name: wokkel.test.test_disco -*-
 #
-# Copyright (c) 2003-2008 Ralph Meijer
+# Copyright (c) 2003-2009 Ralph Meijer
 # See LICENSE for details.
 
@@ -15 +15 @@
 from twisted.words.xish import domish
 
+from wokkel import data_form
 from wokkel.iwokkel import IDisco
 from wokkel.subprotocols import IQHandlerMixin, XMPPHandler
 
-NS = 'http://jabber.org/protocol/disco'
-NS_INFO = NS + '#info'
-NS_ITEMS = NS + '#items'
+NS_DISCO = 'http://jabber.org/protocol/disco'
+NS_DISCO_INFO = NS_DISCO + '#info'
+NS_DISCO_ITEMS = NS_DISCO + '#items'
 
 IQ_GET = '/iq[@type="get"]'
-DISCO_INFO = IQ_GET + '/query[@xmlns="' + NS_INFO + '"]'
-DISCO_ITEMS = IQ_GET + '/query[@xmlns="' + NS_ITEMS + '"]'
-
-class DiscoFeature(domish.Element):
-    """
-    Element representing an XMPP service discovery feature.
-    """
-
-    def __init__(self, feature):
-        domish.Element.__init__(self, (NS_INFO, 'feature'),
-                                attribs={'var': feature})
-
-
-class DiscoIdentity(domish.Element):
-    """
-    Element representing an XMPP service discovery identity.
-    """
-
-    def __init__(self, category, type, name = None):
-        domish.Element.__init__(self, (NS_INFO, 'identity'),
-                                attribs={'category': category,
-                                         'type': type})
-        if name:
-            self['name'] = name
-
-
-class DiscoItem(domish.Element):
-    """
-    Element representing an XMPP service discovery item.
-    """
-
-    def __init__(self, jid, node='', name=None):
-        domish.Element.__init__(self, (NS_ITEMS, 'item'),
-                                attribs={'jid': jid.full()})
-        if node:
-            self['node'] = node
-
-        if name:
-            self['name'] = name
+DISCO_INFO = IQ_GET + '/query[@xmlns="' + NS_DISCO_INFO + '"]'
+DISCO_ITEMS = IQ_GET + '/query[@xmlns="' + NS_DISCO_ITEMS + '"]'
+
+class DiscoFeature(unicode):
+    """
+    XMPP service discovery feature.
+
+    This extends C{unicode} to convert to and from L{domish.Element}, but
+    further behaves identically.
+    """
+
+    def toElement(self):
+        """
+        Render to a DOM representation.
+
+        @rtype: L{domish.Element}.
+        """
+        element = domish.Element((NS_DISCO_INFO, 'feature'))
+        element['var'] = unicode(self)
+        return element
+
+
+    @staticmethod
+    def fromElement(element):
+        """
+        Parse a DOM representation into a L{DiscoFeature} instance.
+
+        @param element: Element that represents the disco feature.
+        @type element: L{domish.Element}.
+        @rtype L{DiscoFeature}.
+        """
+        featureURI = element.getAttribute('var', u'')
+        feature = DiscoFeature(featureURI)
+        return feature
+
+
+
+class DiscoIdentity(object):
+    """
+    XMPP service discovery identity.
+
+    @ivar category: The identity category.
+    @type category: C{unicode}
+    @ivar type: The identity type.
+    @type type: C{unicode}
+    @ivar name: The optional natural language name for this entity.
+    @type name: C{unicode}
+    """
+
+    def __init__(self, category, idType, name=None):
+        self.category = category
+        self.type = idType
+        self.name = name
+
+
+    def toElement(self):
+        """
+        Generate a DOM representation.
+
+        @rtype: L{domish.Element}.
+        """
+        element = domish.Element((NS_DISCO_INFO, 'identity'))
+        if self.category:
+            element['category'] = self.category
+        if self.type:
+            element['type'] = self.type
+        if self.name:
+            element['name'] = self.name
+        return element
+
+
+    @staticmethod
+    def fromElement(element):
+        """
+        Parse a DOM representation into a L{DiscoIdentity} instance.
+
+        @param element: Element that represents the disco identity.
+        @type element: L{domish.Element}.
+        @rtype L{DiscoIdentity}.
+        """
+        category = element.getAttribute('category')
+        idType = element.getAttribute('type')
+        name = element.getAttribute('name')
+        feature = DiscoIdentity(category, idType, name)
+        return feature
+
+
+
+class DiscoInfo(object):
+    """
+    XMPP service discovery info.
+
+    @ivar nodeIdentifier: The optional node this info applies to.
+    @type nodeIdentifier: C{unicode}
+    @ivar features: Features as L{DiscoFeature}.
+    @type features: C{set)
+    @ivar identities: Identities as a mapping from (category, type) to name,
+                      all C{unicode}.
+    @type identities: C{dict}
+    @ivar extensions: Service discovery extensions as a mapping from the
+                      extension form's C{FORM_TYPE} (C{unicode}) to
+                      L{data_form.Form}. Forms with no C{FORM_TYPE} field
+                      are mapped as C{None}. Note that multiple forms
+                      with the same C{FORM_TYPE} have the last in sequence
+                      prevail.
+    @type extensions: C{dict}
+    @ivar _items: Sequence of added items.
+    @type _items: C{list}
+    """
+
+    def __init__(self):
+        self.nodeIdentifier = ''
+        self.features = set()
+        self.identities = {}
+        self.extensions = {}
+        self._items = []
+
+
+    def __iter__(self):
+        """
+        Iterator over sequence of items in the order added.
+        """
+        return iter(self._items)
+
+
+    def append(self, item):
+        """
+        Add a piece of service discovery info.
+
+        @param item: A feature, identity or extension form.
+        @type item: L{DiscoFeature}, L{DiscoIdentity} or L{data_form.Form}
+        """
+        self._items.append(item)
+
+        if isinstance(item, DiscoFeature):
+            self.features.add(item)
+        elif isinstance(item, DiscoIdentity):
+            self.identities[(item.category, item.type)] = item.name
+        elif isinstance(item, data_form.Form):
+            self.extensions[item.formNamespace] = item
+
+
+    def toElement(self):
+        """
+        Generate a DOM representation.
+
+        This takes the items added with C{append} to create a DOM
+        representation of service discovery information.
+
+        @rtype: L{domish.Element}.
+        """
+        element = domish.Element((NS_DISCO_INFO, 'query'))
+
+        if self.nodeIdentifier:
+            element['node'] = self.nodeIdentifier
+
+        for item in self:
+            element.addChild(item.toElement())
+
+        return element
+
+
+    @staticmethod
+    def fromElement(element):
+        """
+        Parse a DOM representation into a L{DiscoInfo} instance.
+
+        @param element: Element that represents the disco info.
+        @type element: L{domish.Element}.
+        @rtype L{DiscoInfo}.
+        """
+
+        info = DiscoInfo()
+
+        info.nodeIdentifier = element.getAttribute('node', '')
+
+        for child in element.elements():
+            item = None
+
+            if (child.uri, child.name) == (NS_DISCO_INFO, 'feature'):
+                item = DiscoFeature.fromElement(child)
+            elif (child.uri, child.name) == (NS_DISCO_INFO, 'identity'):
+                item = DiscoIdentity.fromElement(child)
+            elif (child.uri, child.name) == (data_form.NS_X_DATA, 'x'):
+                item = data_form.Form.fromElement(child)
+
+            if item:
+                info.append(item)
+
+        return info
+
+
+
+class DiscoItem(object):
+    """
+    XMPP service discovery item.
+
+    @ivar entity: The entity holding the item.
+    @type entity: L{jid.JID}
+    @ivar nodeIdentifier: The optional node identifier for the item.
+    @type nodeIdentifier: C{unicode}
+    @ivar name: The optional natural language name for this entity.
+    @type name: C{unicode}
+    """
+
+    def __init__(self, entity, nodeIdentifier='', name=None):
+        self.entity = entity
+        self.nodeIdentifier = nodeIdentifier
+        self.name = name
+
+
+    def toElement(self):
+        """
+        Generate a DOM representation.
+
+        @rtype: L{domish.Element}.
+        """
+        element = domish.Element((NS_DISCO_ITEMS, 'item'))
+        if self.entity:
+            element['jid'] = self.entity.full()
+        if self.nodeIdentifier:
+            element['node'] = self.nodeIdentifier
+        if self.name:
+            element['name'] = self.name
+        return element
+
+
+    @staticmethod
+    def fromElement(element):
+        """
+        Parse a DOM representation into a L{DiscoItem} instance.
+
+        @param element: Element that represents the disco iitem.
+        @type element: L{domish.Element}.
+        @rtype L{DiscoItem}.
+        """
+        try:
+            entity = jid.JID(element.getAttribute('jid', ' '))
+        except jid.InvalidFormat:
+            entity = None
+        nodeIdentifier = element.getAttribute('node', '')
+        name = element.getAttribute('name')
+        feature = DiscoItem(entity, nodeIdentifier, name)
+        return feature
+
+
+
+class DiscoItems(object):
+    """
+    XMPP service discovery items.
+
+    @ivar nodeIdentifier: The optional node this info applies to.
+    @type nodeIdentifier: C{unicode}
+    @ivar _items: Sequence of added items.
+    @type _items: C{list}
+    """
+
+    def __init__(self):
+        self.nodeIdentifier = ''
+        self._items = []
+
+
+    def __iter__(self):
+        """
+        Iterator over sequence of items in the order added.
+        """
+        return iter(self._items)
+
+
+    def append(self, item):
+        """
+        Append item to the sequence of items.
+
+        @param item: Item to be added.
+        @type item: L{DiscoItem}
+        """
+        self._items.append(item)
+
+
+    def toElement(self):
+        """
+        Generate a DOM representation.
+
+        This takes the items added with C{append} to create a DOM
+        representation of service discovery items.
+
+        @rtype: L{domish.Element}.
+        """
+        element = domish.Element((NS_DISCO_ITEMS, 'query'))
+
+        if self.nodeIdentifier:
+            element['node'] = self.nodeIdentifier
+
+        for item in self:
+            element.addChild(item.toElement())
+
+        return element
+
+
+    @staticmethod
+    def fromElement(element):
+        """
+        Parse a DOM representation into a L{DiscoItems} instance.
+
+        @param element: Element that represents the disco items.
+        @type element: L{domish.Element}.
+        @rtype L{DiscoItems}.
+        """
+
+        info = DiscoItems()
+
+        info.nodeIdentifier = element.getAttribute('node', '')
+
+        for child in element.elements():
+            if (child.uri, child.name) == (NS_DISCO_ITEMS, 'item'):
+                item = DiscoItem.fromElement(child)
+                info.append(item)
+
+        return info
+
+
+
+class _DiscoRequest(xmlstream.IQ):
+    """
+    Element representing an XMPP service discovery request.
+    """
+
+    def __init__(self, xs, namespace, nodeIdentifier=''):
+        """
+        Initialize the request.
+
+        @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}
+        """
+        xmlstream.IQ.__init__(self, xs, "get")
+        query = self.addElement((namespace, 'query'))
+        if nodeIdentifier:
+            query['node'] = nodeIdentifier
+
+
+
+class DiscoClientProtocol(XMPPHandler):
+    """
+    XMPP Service Discovery client protocol.
+    """
+
+    def requestInfo(self, entity, nodeIdentifier=''):
+        """
+        Request information discovery from a node.
+
+        @param entity: Entity to send the request to.
+        @type entity: L{jid.JID}
+        @param nodeIdentifier: Optional node to request info from.
+        @type nodeIdentifier: C{unicode}
+        """
+
+        request = _DiscoRequest(self.xmlstream, NS_DISCO_INFO, nodeIdentifier)
+
+        d = request.send(entity.full())
+        d.addCallback(lambda iq: DiscoInfo.fromElement(iq.query))
+        return d
+
+
+    def requestItems(self, entity, nodeIdentifier=''):
+        """
+        Request items discovery from a node.
+
+        @param entity: Entity to send the request to.
+        @type entity: L{jid.JID}
+        @param nodeIdentifier: Optional node to request info from.
+        @type nodeIdentifier: C{unicode}
+        """
+
+        request = _DiscoRequest(self.xmlstream, NS_DISCO_ITEMS, nodeIdentifier)
+
+        d = request.send(entity.full())
+        d.addCallback(lambda iq: DiscoItems.fromElement(iq.query))
+        return d
+
 
 
@@ -96 +441 @@
         self.xmlstream.addObserver(DISCO_ITEMS, self.handleRequest)
 
-    def _error(self, failure):
-        failure.trap(defer.FirstError)
-        return failure.value.subFailure
 
     def _onDiscoInfo(self, iq):
+        """
+        Called for incoming disco info requests.
+
+        @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", '')
 
-        def toResponse(results):
-            info = []
-            for i in results:
-                info.extend(i[1])
-
+        def toResponse(info):
             if nodeIdentifier and not info:
                 raise error.StanzaError('item-not-found')
             else:
-                response = domish.Element((NS_INFO, 'query'))
+                response = DiscoInfo()
+                response.nodeIdentifier = nodeIdentifier
 
                 for item in info:
-                    response.addChild(item)
-
-            return response
-
-        dl = []
-        for handler in self.parent:
-            if IDisco.providedBy(handler):
-                dl.append(handler.getDiscoInfo(requestor, target,
-                                               nodeIdentifier))
-
-        d = defer.DeferredList(dl, fireOnOneErrback=1, consumeErrors=1)
-        d.addCallbacks(toResponse, self._error)
+                    response.append(item)
+
+            return response.toElement()
+
+        d = self.info(requestor, target, nodeIdentifier)
+        d.addCallback(toResponse)
         return d
 
+
     def _onDiscoItems(self, iq):
+        """
+        Called for incoming disco items requests.
+
+        @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", '')
 
-        def toResponse(results):
-            items = []
-            for i in results:
-                items.extend(i[1])
-
-            response = domish.Element((NS_ITEMS, 'query'))
+        def toResponse(items):
+            response = DiscoItems()
+            response.nodeIdentifier = nodeIdentifier
 
             for item in items:
-                response.addChild(item)
-
-            return response
-
-        dl = []
-        for handler in self.parent:
-            if IDisco.providedBy(handler):
-                dl.append(handler.getDiscoItems(requestor, target,
-                                                nodeIdentifier))
-
-        d = defer.DeferredList(dl, fireOnOneErrback=1, consumeErrors=1)
-        d.addCallbacks(toResponse, self._error)
+                response.append(item)
+
+            return response.toElement()
+
+        d = self.items(requestor, target, nodeIdentifier)
+        d.addCallback(toResponse)
         return d
+
+
+    def _gatherResults(self, deferredList):
+        """
+        Gather results from a list of deferreds.
+
+        Similar to L{defer.gatherResults}, but flattens the returned results,
+        consumes errors after the first one and fires the errback of the
+        returned deferred with the failure of the first deferred that fires its
+        errback.
+
+        @param deferredList: List of deferreds for which the results should be
+                             gathered.
+        @type deferredList: C{list}
+        @return: Deferred that fires with a list of gathered results.
+        @rtype: L{defer.Deferred}
+        """
+        def cb(resultList):
+            results = []
+            for success, value in resultList:
+                results.extend(value)
+            return results
+
+        def eb(failure):
+            failure.trap(defer.FirstError)
+            return failure.value.subFailure
+
+        d = defer.DeferredList(deferredList, fireOnOneErrback=1,
+                                             consumeErrors=1)
+        d.addCallbacks(cb, eb)
+        return d
+
+
+    def info(self, requestor, target, nodeIdentifier):
+        """
+        Inspect all sibling protocol handlers for disco info.
+
+        Calls the L{getDiscoInfo<IDisco.getDiscoInfo>} method on all child
+        handlers of the parent, that provide L{IDisco}.
+
+        @param requestor: The entity that sent the request.
+        @type requestor: L{JID<twisted.words.protocols.jabber.jid.JID>}
+        @param target: The entity the request was sent to.
+        @type target: L{JID<twisted.words.protocols.jabber.jid.JID>}
+        @param nodeIdentifier: The optional node being queried, or C{''}.
+        @type nodeIdentifier: C{unicode}
+        @return: Deferred with the gathered results from sibling handlers.
+        @rtype: L{defer.Deferred}
+        """
+        dl = [handler.getDiscoInfo(requestor, target, nodeIdentifier)
+              for handler in self.parent
+              if IDisco.providedBy(handler)]
+        return self._gatherResults(dl)
+
+
+    def items(self, requestor, target, nodeIdentifier):
+        """
+        Inspect all sibling protocol handlers for disco items.
+
+        Calls the L{getDiscoItems<IDisco.getDiscoItems>} method on all child
+        handlers of the parent, that provide L{IDisco}.
+
+        @param requestor: The entity that sent the request.
+        @type requestor: L{JID<twisted.words.protocols.jabber.jid.JID>}
+        @param target: The entity the request was sent to.
+        @type target: L{JID<twisted.words.protocols.jabber.jid.JID>}
+        @param nodeIdentifier: The optional node being queried, or C{''}.
+        @type nodeIdentifier: C{unicode}
+        @return: Deferred with the gathered results from sibling handlers.
+        @rtype: L{defer.Deferred}
+        """
+        dl = [handler.getDiscoItems(requestor, target, nodeIdentifier)
+              for handler in self.parent
+              if IDisco.providedBy(handler)]
+        return self._gatherResults(dl)

wokkel/generic.py

@@ -10 +10 @@
 from zope.interface import implements
 
-from twisted.internet import defer
-from twisted.words.protocols.jabber import error
+from twisted.internet import defer, protocol
+from twisted.words.protocols.jabber import error, jid, xmlstream
 from twisted.words.protocols.jabber.xmlstream import toResponse
-from twisted.words.xish import domish
+from twisted.words.xish import domish, utility
+
+try:
+    from twisted.words.xish.xmlstream import BootstrapMixin
+except ImportError:
+    from wokkel.compat import BootstrapMixin
 
 from wokkel import disco
@@ -121 +126 @@
     def getDiscoItems(self, requestor, target, node):
         return defer.succeed([])
+
+
+
+class XmlPipe(object):
+    """
+    XML stream pipe.
+
+    Connects two objects that communicate stanzas through an XML stream like
+    interface. Each of the ends of the pipe (sink and source) can be used to
+    send XML stanzas to the other side, or add observers to process XML stanzas
+    that were sent from the other side.
+
+    XML pipes are usually used in place of regular XML streams that are
+    transported over TCP. This is the reason for the use of the names source
+    and sink for both ends of the pipe. The source side corresponds with the
+    entity that initiated the TCP connection, whereas the sink corresponds with
+    the entity that accepts that connection. In this object, though, the source
+    and sink are treated equally.
+
+    Unlike Jabber
+    L{XmlStream<twisted.words.protocols.jabber.xmlstream.XmlStream>}s, the sink
+    and source objects are assumed to represent an eternal connected and
+    initialized XML stream. As such, events corresponding to connection,
+    disconnection, initialization and stream errors are not dispatched or
+    processed.
+
+    @ivar source: Source XML stream.
+    @ivar sink: Sink XML stream.
+    """
+
+    def __init__(self):
+        self.source = utility.EventDispatcher()
+        self.sink = utility.EventDispatcher()
+        self.source.send = lambda obj: self.sink.dispatch(obj)
+        self.sink.send = lambda obj: self.source.dispatch(obj)
+
+
+
+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}
+    """
+
+    sender = None
+    recipient = None
+    stanzaType = None
+
+    @classmethod
+    def fromElement(Class, element):
+        stanza = Class()
+        stanza.parseElement(element)
+        return stanza
+
+
+    def parseElement(self, element):
+        self.sender = jid.internJID(element['from'])
+        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')
+
+
+class DeferredXmlStreamFactory(BootstrapMixin, protocol.ClientFactory):
+    protocol = xmlstream.XmlStream
+
+    def __init__(self, authenticator):
+        BootstrapMixin.__init__(self)
+
+        self.authenticator = authenticator
+
+        deferred = defer.Deferred()
+        self.deferred = deferred
+        self.addBootstrap(xmlstream.STREAM_AUTHD_EVENT, self.deferred.callback)
+        self.addBootstrap(xmlstream.INIT_FAILED_EVENT, deferred.errback)
+
+
+    def buildProtocol(self, addr):
+        """
+        Create an instance of XmlStream.
+
+        A new authenticator instance will be created and passed to the new
+        XmlStream. Registered bootstrap event observers are installed as well.
+        """
+        xs = self.protocol(self.authenticator)
+        xs.factory = self
+        self.installBootstraps(xs)
+        return xs
+
+
+    def clientConnectionFailed(self, connector, reason):
+        self.deferred.errback(reason)

wokkel/iwokkel.py

@@ -16 +16 @@
     """
 
-    manager = Attribute("""XML stream manager""")
+    parent = Attribute("""XML stream manager for this handler""")
     xmlstream = Attribute("""The managed XML stream""")
 
@@ -26 +26 @@
         """
 
+
     def disownHandlerParent(parent):
         """
@@ -32 +33 @@
         @type parent: L{IXMPPHandlerCollection}
         """
+
 
     def makeConnection(xs):
@@ -45 +47 @@
         @type xs: L{XmlStream<twisted.words.protocols.jabber.XmlStream>}
         """
+
 
     def connectionMade():
@@ -55 +58 @@
         """
 
+
     def connectionInitialized():
         """
@@ -64 +68 @@
         """
 
+
     def connectionLost(reason):
         """
@@ -73 +78 @@
         @type reason: L{twisted.python.failure.Failure}
         """
+
 
 
@@ -87 +93 @@
         """
 
+
     def addHandler(handler):
         """
@@ -94 +101 @@
         """
 
+
     def removeHandler(handler):
         """
@@ -100 +108 @@
         @type handler: L{IXMPPHandler}
         """
+
 
 
@@ -270 +279 @@
         """
 
-    def notifyDelete(service, nodeIdentifier, subscriptions):
+
+    def notifyDelete(service, nodeIdentifier, subscribers,
+                     redirectURI=None):
         """
         Send out node deletion notifications.
@@ -278 +289 @@
         @param nodeIdentifier: The identifier of the node that was deleted.
         @type nodeIdentifier: C{unicode}
-        @param subscriptions: The subscriptions for which a notification should
-                              be sent out.
-        @type subscriptions: C{list} of L{jid.JID}
+        @param subscribers: The subscribers for which a notification should
+                            be sent out.
+        @type subscribers: C{list} of L{jid.JID}
+        @param redirectURI: Optional XMPP URI of another node that subscribers
+                            are redirected to.
+        @type redirectURI: C{str}
         """
 
@@ -387 +401 @@
         that option in a dictionary:
 
-        - C{'type'} (C{str}): The option's type (see
-          L{Field<wokkel.data_form.Field>}'s doc string for possible values).
-        - C{'label'} (C{unicode}): A human readable label for this option.
-        - C{'options'} (C{dict}): Optional list of possible values for this
-          option.
+         - C{'type'} (C{str}): The option's type (see
+           L{Field<wokkel.data_form.Field>}'s doc string for possible values).
+         - C{'label'} (C{unicode}): A human readable label for this option.
+         - C{'options'} (C{dict}): Optional list of possible values for this
+           option.
 
         Example::
@@ -414 +428 @@
         """
 
-    def getDefaultConfiguration(requestor, service):
+    def getDefaultConfiguration(requestor, service, nodeType):
         """
         Called when a default node configuration request has been received.
@@ -422 +436 @@
         @param service: The entity the request was addressed to.
         @type service: L{jid.JID}
+        @param nodeType: The type of node for which the configuration is
+                         retrieved, C{'leaf'} or C{'collection'}.
+        @type nodeType: C{str}
         @return: A deferred that fires with a C{dict} representing the default
                  node configuration. Keys are C{str}s that represent the
@@ -511 +528 @@
         @type nodeIdentifier: C{unicode}
         """
+
+
+
+class IPubSubResource(Interface):
+
+    def locateResource(request):
+        """
+        Locate a resource that will handle the request.
+
+        @param request: The publish-subscribe request.
+        @type request: L{wokkel.pubsub.PubSubRequest}
+        """
+
+
+    def getInfo(requestor, service, nodeIdentifier):
+        """
+        Get node type and meta data.
+
+        @param requestor: The entity the request originated from.
+        @type requestor: L{jid.JID}
+        @param service: The publish-subscribe service entity.
+        @type service: L{jid.JID}
+        @param nodeIdentifier: Identifier of the node to request the info for.
+        @type nodeIdentifier: L{unicode}
+        @return: A deferred that fires with a dictionary. If not empty,
+                 it must have the keys C{'type'} and C{'meta-data'} to keep
+                 respectively the node type and a dictionary with the meta
+                 data for that node.
+        @rtype: L{defer.Deferred}
+        """
+
+
+    def getNodes(requestor, service, nodeIdentifier):
+        """
+        Get all nodes contained by this node.
+
+        @param requestor: The entity the request originated from.
+        @type requestor: L{jid.JID}
+        @param service: The publish-subscribe service entity.
+        @type service: L{jid.JID}
+        @param nodeIdentifier: Identifier of the node to request the childs for.
+        @type nodeIdentifier: L{unicode}
+        @return: A deferred that fires with a list of child node identifiers.
+        @rtype: L{defer.Deferred}
+        """
+
+
+    def getConfigurationOptions():
+        """
+        Retrieve all known node configuration options.
+
+        The returned dictionary holds the possible node configuration options
+        by option name. The value of each entry represents the specifics for
+        that option in a dictionary:
+
+         - C{'type'} (C{str}): The option's type (see
+           L{Field<wokkel.data_form.Field>}'s doc string for possible values).
+         - C{'label'} (C{unicode}): A human readable label for this option.
+         - C{'options'} (C{dict}): Optional list of possible values for this
+           option.
+
+        Example::
+
+            {
+            "pubsub#persist_items":
+                {"type": "boolean",
+                 "label": "Persist items to storage"},
+            "pubsub#deliver_payloads":
+                {"type": "boolean",
+                 "label": "Deliver payloads with event notifications"},
+            "pubsub#send_last_published_item":
+                {"type": "list-single",
+                 "label": "When to send the last published item",
+                 "options": {
+                     "never": "Never",
+                     "on_sub": "When a new subscription is processed"}
+                }
+            }
+
+        @rtype: C{dict}.
+        """
+
+
+    def publish(request):
+        """
+        Called when a publish request has been received.
+
+        @param request: The publish-subscribe request.
+        @type request: L{wokkel.pubsub.PubSubRequest}
+        @return: deferred that fires on success.
+        @rtype: L{defer.Deferred}
+        """
+
+
+    def subscribe(request):
+        """
+        Called when a subscribe request has been received.
+
+        @param request: The publish-subscribe request.
+        @type request: L{wokkel.pubsub.PubSubRequest}
+        @return: A deferred that fires with a
+                 L{Subscription<wokkel.pubsub.Subscription>}.
+        @rtype: L{defer.Deferred}
+        """
+
+
+    def unsubscribe(request):
+        """
+        Called when a subscribe request has been received.
+
+        @param request: The publish-subscribe request.
+        @type request: L{wokkel.pubsub.PubSubRequest}
+        @return: A deferred that fires with C{None} when unsubscription has
+                 succeeded.
+        @rtype: L{defer.Deferred}
+        """
+
+
+    def subscriptions(request):
+        """
+        Called when a subscriptions retrieval request has been received.
+
+        @param request: The publish-subscribe request.
+        @type request: L{wokkel.pubsub.PubSubRequest}
+        @return: A deferred that fires with a C{list} of subscriptions as
+                 L{Subscription<wokkel.pubsub.Subscription>}.
+        @rtype: L{defer.Deferred}
+        """
+
+
+    def affiliations(request):
+        """
+        Called when a affiliations retrieval request has been received.
+
+        @param request: The publish-subscribe request.
+        @type request: L{wokkel.pubsub.PubSubRequest}
+        @return: A deferred that fires with a C{list} of affiliations as
+                 C{tuple}s of (node identifier as C{unicode}, affiliation state
+                 as C{str}). The affiliation can be C{'owner'}, C{'publisher'},
+                 or C{'outcast'}.
+        @rtype: L{defer.Deferred}
+        """
+
+
+    def create(request):
+        """
+        Called when a node creation request has been received.
+
+        @param request: The publish-subscribe request.
+        @type request: L{wokkel.pubsub.PubSubRequest}
+        @return: A deferred that fires with a C{unicode} that represents
+                 the identifier of the new node.
+        @rtype: L{defer.Deferred}
+        """
+
+
+    def default(request):
+        """
+        Called when a default node configuration request has been received.
+
+        @param request: The publish-subscribe request.
+        @type request: L{wokkel.pubsub.PubSubRequest}
+        @return: A deferred that fires with a C{dict} representing the default
+                 node configuration. Keys are C{str}s that represent the
+                 field name. Values can be of types C{unicode}, C{int} or
+                 C{bool}.
+        @rtype: L{defer.Deferred}
+        """
+
+
+    def configureGet(request):
+        """
+        Called when a node configuration retrieval request has been received.
+
+        @param request: The publish-subscribe request.
+        @type request: L{wokkel.pubsub.PubSubRequest}
+        @return: A deferred that fires with a C{dict} representing the node
+                 configuration. Keys are C{str}s that represent the field name.
+                 Values can be of types C{unicode}, C{int} or C{bool}.
+        @rtype: L{defer.Deferred}
+        """
+
+
+    def configureSet(request):
+        """
+        Called when a node configuration change request has been received.
+
+        @param request: The publish-subscribe request.
+        @type request: L{wokkel.pubsub.PubSubRequest}
+        @return: A deferred that fires with C{None} when the node's
+                 configuration has been changed.
+        @rtype: L{defer.Deferred}
+        """
+
+
+    def items(request):
+        """
+        Called when a items retrieval request has been received.
+
+        @param request: The publish-subscribe request.
+        @type request: L{wokkel.pubsub.PubSubRequest}
+        @return: A deferred that fires with a C{list} of L{pubsub.Item}.
+        @rtype: L{defer.Deferred}
+        """
+
+
+    def retract(request):
+        """
+        Called when a item retraction request has been received.
+
+        @param request: The publish-subscribe request.
+        @type request: L{wokkel.pubsub.PubSubRequest}
+        @return: A deferred that fires with C{None} when the given items have
+                 been retracted.
+        @rtype: L{defer.Deferred}
+        """
+
+
+    def purge(request):
+        """
+        Called when a node purge request has been received.
+
+        @param request: The publish-subscribe request.
+        @type request: L{wokkel.pubsub.PubSubRequest}
+        @return: A deferred that fires with C{None} when the node has been
+                 purged.
+        @rtype: L{defer.Deferred}
+        """
+
+
+    def delete(request):
+        """
+        Called when a node deletion request has been received.
+
+        @param request: The publish-subscribe request.
+        @type request: L{wokkel.pubsub.PubSubRequest}
+        @return: A deferred that fires with C{None} when the node has been
+                 deleted.
+        @rtype: L{defer.Deferred}
+        """
+
 
 
@@ -655 +913 @@
         """
         """
-

wokkel/pubsub.py

@@ -14 +14 @@
 
 from twisted.internet import defer
+from twisted.python import log
 from twisted.words.protocols.jabber import jid, error, xmlstream
 from twisted.words.xish import domish
 
-from wokkel import disco, data_form, shim
+from wokkel import disco, data_form, generic, shim
 from wokkel.subprotocols import IQHandlerMixin, XMPPHandler
-from wokkel.iwokkel import IPubSubClient, IPubSubService
+from wokkel.iwokkel import IPubSubClient, IPubSubService, IPubSubResource
 
 # Iq get and set XPath queries
@@ -32 +33 @@
 NS_PUBSUB_NODE_CONFIG = NS_PUBSUB + "#node_config"
 NS_PUBSUB_META_DATA = NS_PUBSUB + "#meta-data"
-
-# In publish-subscribe namespace XPath query selector.
-IN_NS_PUBSUB = '[@xmlns="' + NS_PUBSUB + '"]'
-IN_NS_PUBSUB_OWNER = '[@xmlns="' + NS_PUBSUB_OWNER + '"]'
-
-# Publish-subscribe XPath queries
-PUBSUB_ELEMENT = '/pubsub' + IN_NS_PUBSUB
-PUBSUB_OWNER_ELEMENT = '/pubsub' + IN_NS_PUBSUB_OWNER
-PUBSUB_GET = IQ_GET + PUBSUB_ELEMENT
-PUBSUB_SET = IQ_SET + PUBSUB_ELEMENT
-PUBSUB_OWNER_GET = IQ_GET + PUBSUB_OWNER_ELEMENT
-PUBSUB_OWNER_SET = IQ_SET + PUBSUB_OWNER_ELEMENT
-
-# Publish-subscribe command XPath queries
-PUBSUB_PUBLISH = PUBSUB_SET + '/publish' + IN_NS_PUBSUB
-PUBSUB_CREATE = PUBSUB_SET + '/create' + IN_NS_PUBSUB
-PUBSUB_SUBSCRIBE = PUBSUB_SET + '/subscribe' + IN_NS_PUBSUB
-PUBSUB_UNSUBSCRIBE = PUBSUB_SET + '/unsubscribe' + IN_NS_PUBSUB
-PUBSUB_OPTIONS_GET = PUBSUB_GET + '/options' + IN_NS_PUBSUB
-PUBSUB_OPTIONS_SET = PUBSUB_SET + '/options' + IN_NS_PUBSUB
-PUBSUB_DEFAULT = PUBSUB_OWNER_GET + '/default' + IN_NS_PUBSUB_OWNER
-PUBSUB_CONFIGURE_GET = PUBSUB_OWNER_GET + '/configure' + IN_NS_PUBSUB_OWNER
-PUBSUB_CONFIGURE_SET = PUBSUB_OWNER_SET + '/configure' + IN_NS_PUBSUB_OWNER
-PUBSUB_SUBSCRIPTIONS = PUBSUB_GET + '/subscriptions' + IN_NS_PUBSUB
-PUBSUB_AFFILIATIONS = PUBSUB_GET + '/affiliations' + IN_NS_PUBSUB
-PUBSUB_AFFILIATIONS_GET = PUBSUB_OWNER_GET + '/affiliations' + \
-                          IN_NS_PUBSUB_OWNER
-PUBSUB_AFFILIATIONS_SET = PUBSUB_OWNER_SET + '/affiliations' + \
-                          IN_NS_PUBSUB_OWNER
-PUBSUB_SUBSCRIPTIONS_GET = PUBSUB_OWNER_GET + '/subscriptions' + \
-                          IN_NS_PUBSUB_OWNER
-PUBSUB_SUBSCRIPTIONS_SET = PUBSUB_OWNER_SET + '/subscriptions' + \
-                          IN_NS_PUBSUB_OWNER
-PUBSUB_ITEMS = PUBSUB_GET + '/items' + IN_NS_PUBSUB
-PUBSUB_RETRACT = PUBSUB_SET + '/retract' + IN_NS_PUBSUB
-PUBSUB_PURGE = PUBSUB_OWNER_SET + '/purge' + IN_NS_PUBSUB_OWNER
-PUBSUB_DELETE = PUBSUB_OWNER_SET + '/delete' + IN_NS_PUBSUB_OWNER
+NS_PUBSUB_SUBSCRIBE_OPTIONS = NS_PUBSUB + "#subscribe_options"
+
+# XPath to match pubsub requests
+PUBSUB_REQUEST = '/iq[@type="get" or @type="set"]/' + \
+                    'pubsub[@xmlns="' + NS_PUBSUB + '" or ' + \
+                           '@xmlns="' + NS_PUBSUB_OWNER + '"]'
 
 class SubscriptionPending(Exception):
@@ -99 +69 @@
 
 
-class BadRequest(PubSubError):
+class BadRequest(error.StanzaError):
     """
     Bad request stanza error.
     """
     def __init__(self, pubsubCondition=None, text=None):
-        PubSubError.__init__(self, 'bad-request', pubsubCondition, text)
+        if pubsubCondition:
+            appCondition = domish.Element((NS_PUBSUB_ERRORS, pubsubCondition))
+        else:
+            appCondition = None
+        error.StanzaError.__init__(self, 'bad-request',
+                                         text=text,
+                                         appCondition=appCondition)
 
 
@@ -110 +86 @@
 class Unsupported(PubSubError):
     def __init__(self, feature, text=None):
+        self.feature = feature
         PubSubError.__init__(self, 'feature-not-implemented',
                                    'unsupported',
@@ -115 +92 @@
                                    text)
 
+    def __str__(self):
+        message = PubSubError.__str__(self)
+        message += ', feature %r' % self.feature
+        return message
 
 
@@ -168 +149 @@
 
 
-class _PubSubRequest(xmlstream.IQ):
-    """
-    Publish subscribe request.
-
-    @ivar verb: Request verb
-    @type verb: C{str}
-    @ivar namespace: Request namespace.
-    @type namespace: C{str}
-    @ivar method: Type attribute of the IQ request. Either C{'set'} or C{'get'}
-    @type method: C{str}
-    @ivar command: Command element of the request. This is the direct child of
-                   the C{pubsub} element in the C{namespace} with the name
-                   C{verb}.
-    """
-
-    def __init__(self, xs, verb, namespace=NS_PUBSUB, method='set'):
-        xmlstream.IQ.__init__(self, xs, method)
-        self.addElement((namespace, 'pubsub'))
-
-        self.command = self.pubsub.addElement(verb)
-
-
-    def send(self, to):
-        """
-        Send out request.
-
-        Extends L{xmlstream.IQ.send} by requiring the C{to} parameter to be
-        a L{JID} instance.
-
-        @param to: Entity to send the request to.
-        @type to: L{JID}
-        """
-        destination = to.full()
-        return xmlstream.IQ.send(self, destination)
+class PubSubRequest(generic.Stanza):
+    """
+    A publish-subscribe request.
+
+    The set of instance variables used depends on the type of request. If
+    a variable is not applicable or not passed in the request, its value is
+    C{None}.
+
+    @ivar verb: The type of publish-subscribe request. See L{_requestVerbMap}.
+    @type verb: C{str}.
+
+    @ivar affiliations: Affiliations to be modified.
+    @type affiliations: C{set}
+    @ivar items: The items to be published, as L{domish.Element}s.
+    @type items: C{list}
+    @ivar itemIdentifiers: Identifiers of the items to be retrieved or
+                           retracted.
+    @type itemIdentifiers: C{set}
+    @ivar maxItems: Maximum number of items to retrieve.
+    @type maxItems: C{int}.
+    @ivar nodeIdentifier: Identifier of the node the request is about.
+    @type nodeIdentifier: C{unicode}
+    @ivar nodeType: The type of node that should be created, or for which the
+                    configuration is retrieved. C{'leaf'} or C{'collection'}.
+    @type nodeType: C{str}
+    @ivar options: Configurations options for nodes, subscriptions and publish
+                   requests.
+    @type options: L{data_form.Form}
+    @ivar subscriber: The subscribing entity.
+    @type subscriber: L{JID}
+    @ivar subscriptionIdentifier: Identifier for a specific subscription.
+    @type subscriptionIdentifier: C{unicode}
+    @ivar subscriptions: Subscriptions to be modified, as a set of
+                         L{Subscription}.
+    @type subscriptions: C{set}
+    """
+
+    verb = None
+
+    affiliations = None
+    items = None
+    itemIdentifiers = None
+    maxItems = None
+    nodeIdentifier = None
+    nodeType = None
+    options = None
+    subscriber = None
+    subscriptionIdentifier = None
+    subscriptions = None
+
+    # Map request iq type and subelement name to request verb
+    _requestVerbMap = {
+        ('set', NS_PUBSUB, 'publish'): 'publish',
+        ('set', NS_PUBSUB, 'subscribe'): 'subscribe',
+        ('set', NS_PUBSUB, 'unsubscribe'): 'unsubscribe',
+        ('get', NS_PUBSUB, 'options'): 'optionsGet',
+        ('set', NS_PUBSUB, 'options'): 'optionsSet',
+        ('get', NS_PUBSUB, 'subscriptions'): 'subscriptions',
+        ('get', NS_PUBSUB, 'affiliations'): 'affiliations',
+        ('set', NS_PUBSUB, 'create'): 'create',
+        ('get', NS_PUBSUB_OWNER, 'default'): 'default',
+        ('get', NS_PUBSUB_OWNER, 'configure'): 'configureGet',
+        ('set', NS_PUBSUB_OWNER, 'configure'): 'configureSet',
+        ('get', NS_PUBSUB, 'items'): 'items',
+        ('set', NS_PUBSUB, 'retract'): 'retract',
+        ('set', NS_PUBSUB_OWNER, 'purge'): 'purge',
+        ('set', NS_PUBSUB_OWNER, 'delete'): 'delete',
+        ('get', NS_PUBSUB_OWNER, 'affiliations'): 'affiliationsGet',
+        ('set', NS_PUBSUB_OWNER, 'affiliations'): 'affiliationsSet',
+        ('get', NS_PUBSUB_OWNER, 'subscriptions'): 'subscriptionsGet',
+        ('set', NS_PUBSUB_OWNER, 'subscriptions'): 'subscriptionsSet',
+    }
+
+    # Map request verb to request iq type and subelement name
+    _verbRequestMap = dict(((v, k) for k, v in _requestVerbMap.iteritems()))
+
+    # Map request verb to parameter handler names
+    _parameters = {
+        'publish': ['node', 'items'],
+        'subscribe': ['nodeOrEmpty', 'jid'],
+        'unsubscribe': ['nodeOrEmpty', 'jid'],
+        'optionsGet': ['nodeOrEmpty', 'jid'],
+        'optionsSet': ['nodeOrEmpty', 'jid', 'options'],
+        'subscriptions': [],
+        'affiliations': [],
+        'create': ['nodeOrNone'],
+        'default': ['default'],
+        'configureGet': ['nodeOrEmpty'],
+        'configureSet': ['nodeOrEmpty', 'configure'],
+        'items': ['node', 'maxItems', 'itemIdentifiers'],
+        'retract': ['node', 'itemIdentifiers'],
+        'purge': ['node'],
+        'delete': ['node'],
+        'affiliationsGet': ['nodeOrEmpty'],
+        'affiliationsSet': [],
+        'subscriptionsGet': ['nodeOrEmpty'],
+        'subscriptionsSet': [],
+    }
+
+    def __init__(self, verb=None):
+        self.verb = verb
+
+
+    @staticmethod
+    def _findForm(element, formNamespace):
+        """
+        Find a Data Form.
+
+        Look for an element that represents a Data Form with the specified
+        form namespace as a child element of the given element.
+        """
+        if not element:
+            return None
+
+        form = None
+        for child in element.elements():
+            try:
+                form = data_form.Form.fromElement(child)
+            except data_form.Error:
+                continue
+
+            if form.formNamespace != NS_PUBSUB_NODE_CONFIG:
+                continue
+
+        return form
+
+
+    def _parse_node(self, verbElement):
+        """
+        Parse the required node identifier out of the verbElement.
+        """
+        try:
+            self.nodeIdentifier = verbElement["node"]
+        except KeyError:
+            raise BadRequest('nodeid-required')
+
+
+    def _render_node(self, verbElement):
+        """
+        Render the required node identifier on the verbElement.
+        """
+        if not self.nodeIdentifier:
+            raise Exception("Node identifier is required")
+
+        verbElement['node'] = self.nodeIdentifier
+
+
+    def _parse_nodeOrEmpty(self, verbElement):
+        """
+        Parse the node identifier out of the verbElement. May be empty.
+        """
+        self.nodeIdentifier = verbElement.getAttribute("node", '')
+
+
+    def _render_nodeOrEmpty(self, verbElement):
+        """
+        Render the node identifier on the verbElement. May be empty.
+        """
+        if self.nodeIdentifier:
+            verbElement['node'] = self.nodeIdentifier
+
+
+    def _parse_nodeOrNone(self, verbElement):
+        """
+        Parse the optional node identifier out of the verbElement.
+        """
+        self.nodeIdentifier = verbElement.getAttribute("node")
+
+
+    def _render_nodeOrNone(self, verbElement):
+        """
+        Render the optional node identifier on the verbElement.
+        """
+        if self.nodeIdentifier:
+            verbElement['node'] = self.nodeIdentifier
+
+
+    def _parse_items(self, verbElement):
+        """
+        Parse items out of the verbElement for publish requests.
+        """
+        self.items = []
+        for element in verbElement.elements():
+            if element.uri == NS_PUBSUB and element.name == 'item':
+                self.items.append(element)
+
+
+    def _render_items(self, verbElement):
+        """
+        Render items into the verbElement for publish requests.
+        """
+        if self.items:
+            for item in self.items:
+                verbElement.addChild(item)
+
+
+    def _parse_jid(self, verbElement):
+        """
+        Parse subscriber out of the verbElement for un-/subscribe requests.
+        """
+        try:
+            self.subscriber = jid.internJID(verbElement["jid"])
+        except KeyError:
+            raise BadRequest('jid-required')
+
+
+    def _render_jid(self, verbElement):
+        """
+        Render subscriber into the verbElement for un-/subscribe requests.
+        """
+        verbElement['jid'] = self.subscriber.full()
+
+
+    def _parse_default(self, verbElement):
+        """
+        Parse node type out of a request for the default node configuration.
+        """
+        form = PubSubRequest._findForm(verbElement, NS_PUBSUB_NODE_CONFIG)
+        if form and form.formType == 'submit':
+            values = form.getValues()
+            self.nodeType = values.get('pubsub#node_type', 'leaf')
+        else:
+            self.nodeType = 'leaf'
+
+
+    def _parse_configure(self, verbElement):
+        """
+        Parse options out of a request for setting the node configuration.
+        """
+        form = PubSubRequest._findForm(verbElement, NS_PUBSUB_NODE_CONFIG)
+        if form:
+            if form.formType == 'submit':
+                self.options = form.getValues()
+            elif form.formType == 'cancel':
+                self.options = {}
+            else:
+                raise BadRequest(text="Unexpected form type %r" % form.formType)
+        else:
+            raise BadRequest(text="Missing configuration form")
+
+
+
+    def _parse_itemIdentifiers(self, verbElement):
+        """
+        Parse item identifiers out of items and retract requests.
+        """
+        self.itemIdentifiers = []
+        for element in verbElement.elements():
+            if element.uri == NS_PUBSUB and element.name == 'item':
+                try:
+                    self.itemIdentifiers.append(element["id"])
+                except KeyError:
+                    raise BadRequest()
+
+
+    def _render_itemIdentifiers(self, verbElement):
+        """
+        Render item identifiers into items and retract requests.
+        """
+        if self.itemIdentifiers:
+            for itemIdentifier in self.itemIdentifiers:
+                item = verbElement.addElement('item')
+                item['id'] = itemIdentifier
+
+
+    def _parse_maxItems(self, verbElement):
+        """
+        Parse maximum items out of an items request.
+        """
+        value = verbElement.getAttribute('max_items')
+
+        if value:
+            try:
+                self.maxItems = int(value)
+            except ValueError:
+                raise BadRequest(text="Field max_items requires a positive " +
+                                      "integer value")
+
+
+    def _render_maxItems(self, verbElement):
+        """
+        Parse maximum items into an items request.
+        """
+        if self.maxItems:
+            verbElement['max_items'] = unicode(self.maxItems)
+
+
+    def _parse_options(self, verbElement):
+        form = PubSubRequest._findForm(verbElement, NS_PUBSUB_SUBSCRIBE_OPTIONS)
+        if form:
+            if form.formType == 'submit':
+                self.options = form.getValues()
+            elif form.formType == 'cancel':
+                self.options = {}
+            else:
+                raise BadRequest(text="Unexpected form type %r" % form.formType)
+        else:
+            raise BadRequest(text="Missing options form")
+
+    def parseElement(self, element):
+        """
+        Parse the publish-subscribe verb and parameters out of a request.
+        """
+        generic.Stanza.parseElement(self, element)
+
+        for child in element.pubsub.elements():
+            key = (self.stanzaType, child.uri, child.name)
+            try:
+                verb = self._requestVerbMap[key]
+            except KeyError:
+                continue
+            else:
+                self.verb = verb
+                break
+
+        if not self.verb:
+            raise NotImplementedError()
+
+        for parameter in self._parameters[verb]:
+            getattr(self, '_parse_%s' % parameter)(child)
+
+
+    def send(self, xs):
+        """
+        Send this request to its recipient.
+
+        This renders all of the relevant parameters for this specific
+        requests into an L{xmlstream.IQ}, and invoke its C{send} method.
+        This returns a deferred that fires upon reception of a response. See
+        L{xmlstream.IQ} for details.
+
+        @param xs: The XML stream to send the request on.
+        @type xs: L{xmlstream.XmlStream}
+        @rtype: L{defer.Deferred}.
+        """
+
+        try:
+            (self.stanzaType,
+             childURI,
+             childName) = self._verbRequestMap[self.verb]
+        except KeyError:
+            raise NotImplementedError()
+
+        iq = xmlstream.IQ(xs, self.stanzaType)
+        iq.addElement((childURI, 'pubsub'))
+        verbElement = iq.pubsub.addElement(childName)
+
+        if self.sender:
+            iq['from'] = self.sender.full()
+        if self.recipient:
+            iq['to'] = self.recipient.full()
+
+        for parameter in self._parameters[self.verb]:
+            getattr(self, '_render_%s' % parameter)(verbElement)
+
+        return iq.send()
 
 
@@ -246 +549 @@
     """
 
+    redirectURI = None
+
 
 
@@ -303 +608 @@
         nodeIdentifier = action["node"]
         event = DeleteEvent(sender, recipient, nodeIdentifier, headers)
+        if action.redirect:
+            event.redirectURI = action.redirect.getAttribute('uri')
         self.deleteReceived(event)
 
@@ -324 +631 @@
 
 
-    def createNode(self, service, nodeIdentifier=None):
+    def createNode(self, service, nodeIdentifier=None, sender=None):
         """
         Create a publish subscribe node.
@@ -333 +640 @@
         @type nodeIdentifier: C{unicode}
         """
-
-
-        request = _PubSubRequest(self.xmlstream, 'create')
-        if nodeIdentifier:
-            request.command['node'] = nodeIdentifier
+        request = PubSubRequest('create')
+        request.recipient = service
+        request.nodeIdentifier = nodeIdentifier
+        request.sender = sender
 
         def cb(iq):
@@ -347 +653 @@
             return new_node
 
-        return request.send(service).addCallback(cb)
-
-
-    def deleteNode(self, service, nodeIdentifier):
+        d = request.send(self.xmlstream)
+        d.addCallback(cb)
+        return d
+
+
+    def deleteNode(self, service, nodeIdentifier, sender=None):
         """
         Delete a publish subscribe node.
@@ -359 +667 @@
         @type nodeIdentifier: C{unicode}
         """
-        request = _PubSubRequest(self.xmlstream, 'delete')
-        request.command['node'] = nodeIdentifier
-        return request.send(service)
-
-
-    def subscribe(self, service, nodeIdentifier, subscriber):
+        request = PubSubRequest('delete')
+        request.recipient = service
+        request.nodeIdentifier = nodeIdentifier
+        request.sender = sender
+        return request.send(self.xmlstream)
+
+
+    def subscribe(self, service, nodeIdentifier, subscriber, sender=None):
         """
         Subscribe to a publish subscribe node.
@@ -376 +686 @@
         @type subscriber: L{JID}
         """
-        request = _PubSubRequest(self.xmlstream, 'subscribe')
-        if nodeIdentifier:
-            request.command['node'] = nodeIdentifier
-        request.command['jid'] = subscriber.full()
+        request = PubSubRequest('subscribe')
+        request.recipient = service
+        request.nodeIdentifier = nodeIdentifier
+        request.subscriber = subscriber
+        request.sender = sender
 
         def cb(iq):
@@ -394 +705 @@
                 return None
 
-        return request.send(service).addCallback(cb)
-
-
-    def unsubscribe(self, service, nodeIdentifier, subscriber):
+        d = request.send(self.xmlstream)
+        d.addCallback(cb)
+        return d
+
+
+    def unsubscribe(self, service, nodeIdentifier, subscriber, sender=None):
         """
         Unsubscribe from a publish subscribe node.
@@ -408 +721 @@
         @type subscriber: L{JID}
         """
-        request = _PubSubRequest(self.xmlstream, 'unsubscribe')
-        if nodeIdentifier:
-            request.command['node'] = nodeIdentifier
-        request.command['jid'] = subscriber.full()
-        return request.send(service)
-
-
-    def publish(self, service, nodeIdentifier, items=None):
+        request = PubSubRequest('unsubscribe')
+        request.recipient = service
+        request.nodeIdentifier = nodeIdentifier
+        request.subscriber = subscriber
+        request.sender = sender
+        return request.send(self.xmlstream)
+
+
+    def publish(self, service, nodeIdentifier, items=None, sender=None):
         """
         Publish to a publish subscribe node.
@@ -426 +740 @@
         @type items: C{list}
         """
-        request = _PubSubRequest(self.xmlstream, 'publish')
-        request.command['node'] = nodeIdentifier
-        if items:
-            for item in items:
-                request.command.addChild(item)
-
-        return request.send(service)
-
-
-    def items(self, service, nodeIdentifier, maxItems=None):
+        request = PubSubRequest('publish')
+        request.recipient = service
+        request.nodeIdentifier = nodeIdentifier
+        request.items = items
+        request.sender = sender
+        return request.send(self.xmlstream)
+
+
+    def items(self, service, nodeIdentifier, maxItems=None, sender=None):
         """
         Retrieve previously published items from a publish subscribe node.
@@ -446 +759 @@
         @type maxItems: C{int}
         """
-        request = _PubSubRequest(self.xmlstream, 'items', method='get')
-        if nodeIdentifier:
-            request.command['node'] = nodeIdentifier
+        request = PubSubRequest('items')
+        request.recipient = service
+        request.nodeIdentifier = nodeIdentifier
         if maxItems:
-            request.command["max_items"] = str(int(maxItems))
+            request.maxItems = str(int(maxItems))
+        request.sender = sender
 
         def cb(iq):
@@ -459 +773 @@
             return items
 
-        return request.send(service).addCallback(cb)
+        d = request.send(self.xmlstream)
+        d.addCallback(cb)
+        return d
 
 
@@ -494 +810 @@
 
     iqHandlers = {
-            PUBSUB_PUBLISH: '_onPublish',
-            PUBSUB_CREATE: '_onCreate',
-            PUBSUB_SUBSCRIBE: '_onSubscribe',
-            PUBSUB_OPTIONS_GET: '_onOptionsGet',
-            PUBSUB_OPTIONS_SET: '_onOptionsSet',
-            PUBSUB_AFFILIATIONS: '_onAffiliations',
-            PUBSUB_ITEMS: '_onItems',
-            PUBSUB_RETRACT: '_onRetract',
-            PUBSUB_SUBSCRIPTIONS: '_onSubscriptions',
-            PUBSUB_UNSUBSCRIBE: '_onUnsubscribe',
-
-            PUBSUB_AFFILIATIONS_GET: '_onAffiliationsGet',
-            PUBSUB_AFFILIATIONS_SET: '_onAffiliationsSet',
-            PUBSUB_CONFIGURE_GET: '_onConfigureGet',
-            PUBSUB_CONFIGURE_SET: '_onConfigureSet',
-            PUBSUB_DEFAULT: '_onDefault',
-            PUBSUB_PURGE: '_onPurge',
-            PUBSUB_DELETE: '_onDelete',
-            PUBSUB_SUBSCRIPTIONS_GET: '_onSubscriptionsGet',
-            PUBSUB_SUBSCRIPTIONS_SET: '_onSubscriptionsSet',
-
+            '/*': '_onPubSubRequest',
             }
 
-
-    def __init__(self):
+    _legacyHandlers = {
+        'publish': ('publish', ['sender', 'recipient',
+                                'nodeIdentifier', 'items']),
+        'subscribe': ('subscribe', ['sender', 'recipient',
+                                    'nodeIdentifier', 'subscriber']),
+        'unsubscribe': ('unsubscribe', ['sender', 'recipient',
+                                        'nodeIdentifier', 'subscriber']),
+        'subscriptions': ('subscriptions', ['sender', 'recipient']),
+        'affiliations': ('affiliations', ['sender', 'recipient']),
+        'create': ('create', ['sender', 'recipient', 'nodeIdentifier']),
+        'getConfigurationOptions': ('getConfigurationOptions', []),
+        'default': ('getDefaultConfiguration',
+                    ['sender', 'recipient', 'nodeType']),
+        'configureGet': ('getConfiguration', ['sender', 'recipient',
+                                              'nodeIdentifier']),
+        'configureSet': ('setConfiguration', ['sender', 'recipient',
+                                              'nodeIdentifier', 'options']),
+        'items': ('items', ['sender', 'recipient', 'nodeIdentifier',
+                            'maxItems', 'itemIdentifiers']),
+        'retract': ('retract', ['sender', 'recipient', 'nodeIdentifier',
+                                'itemIdentifiers']),
+        'purge': ('purge', ['sender', 'recipient', 'nodeIdentifier']),
+        'delete': ('delete', ['sender', 'recipient', 'nodeIdentifier']),
+    }
+
+    hideNodes = False
+
+    def __init__(self, resource=None):
+        self.resource = resource
         self.discoIdentity = {'category': 'pubsub',
                               'type': 'generic',
@@ -527 +850 @@
 
     def connectionMade(self):
-        self.xmlstream.addObserver(PUBSUB_GET, self.handleRequest)
-        self.xmlstream.addObserver(PUBSUB_SET, self.handleRequest)
-        self.xmlstream.addObserver(PUBSUB_OWNER_GET, self.handleRequest)
-        self.xmlstream.addObserver(PUBSUB_OWNER_SET, self.handleRequest)
+        self.xmlstream.addObserver(PUBSUB_REQUEST, self.handleRequest)
 
 
     def getDiscoInfo(self, requestor, target, nodeIdentifier):
-        info = []
-
-        if not nodeIdentifier:
-            info.append(disco.DiscoIdentity(**self.discoIdentity))
-
-            info.append(disco.DiscoFeature(disco.NS_ITEMS))
-            info.extend([disco.DiscoFeature("%s#%s" % (NS_PUBSUB, feature))
-                         for feature in self.pubSubFeatures])
-
-        def toInfo(nodeInfo):
+        def toInfo(nodeInfo, info):
             if not nodeInfo:
-                return
+                return info
 
             (nodeType, metaData) = nodeInfo['type'], nodeInfo['meta-data']
@@ -563 +874 @@
                     form.addField(data_form.Field.fromDict(metaDatum))
 
-                info.append(form.toElement())
-
-        d = self.getNodeInfo(requestor, target, nodeIdentifier or '')
-        d.addCallback(toInfo)
-        d.addBoth(lambda result: info)
+                info.append(form)
+
+            return info
+
+        info = []
+
+        request = PubSubRequest('discoInfo')
+
+        if self.resource is not None:
+            resource = self.resource.locateResource(request)
+            identity = resource.discoIdentity
+            features = resource.features
+            getInfo = resource.getInfo
+        else:
+            category, idType, name = self.discoIdentity
+            identity = disco.DiscoIdentity(category, idType, name)
+            features = self.pubSubFeatures
+            getInfo = self.getNodeInfo
+
+        if not nodeIdentifier:
+            info.append(identity)
+            info.append(disco.DiscoFeature(disco.NS_DISCO_ITEMS))
+            info.extend([disco.DiscoFeature("%s#%s" % (NS_PUBSUB, feature))
+                         for feature in features])
+
+        d = getInfo(requestor, target, nodeIdentifier or '')
+        d.addCallback(toInfo, info)
+        d.addErrback(log.err)
         return d
 
 
     def getDiscoItems(self, requestor, target, nodeIdentifier):
-        if nodeIdentifier or self.hideNodes:
-            return defer.succeed([])
-
-        d = self.getNodes(requestor, target)
+        if self.hideNodes:
+            d = defer.succeed([])
+        elif self.resource is not None:
+            request = PubSubRequest('discoInfo')
+            resource = self.resource.locateResource(request)
+            d = resource.getNodes(requestor, target, nodeIdentifier)
+        elif nodeIdentifier:
+            d = self.getNodes(requestor, target)
+        else:
+            d = defer.succeed([])
+            
+
+
         d.addCallback(lambda nodes: [disco.DiscoItem(target, node)
                                      for node in nodes])
@@ -581 +924 @@
 
 
-    def _findForm(self, element, formNamespace):
-        if not element:
-            return None
-
-        form = None
-        for child in element.elements():
+    def _onPubSubRequest(self, iq):
+        request = PubSubRequest.fromElement(iq)
+
+        if self.resource is not None:
+            resource = self.resource.locateResource(request)
+        else:
+            resource = self
+
+        # Preprocess the request, knowing the handling resource
+        try:
+            preProcessor = getattr(self, '_preProcess_%s' % request.verb)
+        except AttributeError:
+            pass
+        else:
+            request = preProcessor(resource, request)
+            if request is None:
+                return defer.succeed(None)
+
+        # Process the request itself, 
+        if resource is not self:
             try:
-                form = data_form.Form.fromElement(child)
-            except data_form.Error:
-                continue
-
-            if form.formNamespace != NS_PUBSUB_NODE_CONFIG:
-                continue
-
-        return form
-
-
-    def _getParameter_node(self, commandElement):
+                handler = getattr(resource, request.verb)
+            except AttributeError:
+                # fix lookup feature
+                text = "Request verb: %s" % request.verb
+                return defer.fail(Unsupported('', text))
+
+            d = handler(request)
+        else:
+            handlerName, argNames = self._legacyHandlers[request.verb]
+            handler = getattr(self, handlerName)
+            args = [getattr(request, arg) for arg in argNames]
+            d = handler(*args)
+
+        # If needed, translate the result into a response
         try:
-            return commandElement["node"]
-        except KeyError:
-            raise BadRequest('nodeid-required')
-
-
-    def _getParameter_nodeOrEmpty(self, commandElement):
-        return commandElement.getAttribute("node", '')
-
-
-    def _getParameter_jid(self, commandElement):
-        try:
-            return jid.internJID(commandElement["jid"])
-        except KeyError:
-            raise BadRequest('jid-required')
-
-
-    def _getParameter_max_items(self, commandElement):
-        value = commandElement.getAttribute('max_items')
-
-        if value:
-            try:
-                return int(value)
-            except ValueError:
-                raise BadRequest(text="Field max_items requires a positive " +
-                                      "integer value")
+            cb = getattr(self, '_toResponse_%s' % request.verb)
+        except AttributeError:
+            pass
+        else:
+            d.addCallback(cb, resource, request)
+
+        return d
+
+
+    def _toResponse_subscribe(self, result, resource, request):
+        response = domish.Element((NS_PUBSUB, "pubsub"))
+        subscription = response.addElement("subscription")
+        if result.nodeIdentifier:
+            subscription["node"] = result.nodeIdentifier
+        subscription["jid"] = result.subscriber.full()
+        subscription["subscription"] = result.state
+        return response
+
+
+    def _toResponse_subscriptions(self, result, resource, request):
+        response = domish.Element((NS_PUBSUB, 'pubsub'))
+        subscriptions = response.addElement('subscriptions')
+        for subscription in result:
+            item = subscriptions.addElement('subscription')
+            item['node'] = subscription.nodeIdentifier
+            item['jid'] = subscription.subscriber.full()
+            item['subscription'] = subscription.state
+        return response
+
+
+    def _toResponse_affiliations(self, result, resource, request):
+        response = domish.Element((NS_PUBSUB, 'pubsub'))
+        affiliations = response.addElement('affiliations')
+
+        for nodeIdentifier, affiliation in result:
+            item = affiliations.addElement('affiliation')
+            item['node'] = nodeIdentifier
+            item['affiliation'] = affiliation
+
+        return response
+
+
+    def _toResponse_create(self, result, resource, request):
+        if not request.nodeIdentifier or request.nodeIdentifier != result:
+            response = domish.Element((NS_PUBSUB, 'pubsub'))
+            create = response.addElement('create')
+            create['node'] = result
+            return response
         else:
             return None
-
-
-    def _getParameters(self, iq, *names):
-        requestor = jid.internJID(iq["from"]).userhostJID()
-        service = jid.internJID(iq["to"])
-
-        params = [requestor, service]
-
-        if names:
-            command = names[0]
-            commandElement = getattr(iq.pubsub, command)
-            if not commandElement:
-                raise Exception("Could not find command element %r" % command)
-
-        for name in names[1:]:
-            try:
-                getter = getattr(self, '_getParameter_' + name)
-            except KeyError:
-                raise Exception("No parameter getter for this name")
-
-            params.append(getter(commandElement))
-
-        return params
-
-
-    def _onPublish(self, iq):
-        requestor, service, nodeIdentifier = self._getParameters(
-                iq, 'publish', 'node')
-
-        items = []
-        for element in iq.pubsub.publish.elements():
-            if element.uri == NS_PUBSUB and element.name == 'item':
-                items.append(element)
-
-        return self.publish(requestor, service, nodeIdentifier, items)
-
-
-    def _onSubscribe(self, iq):
-        requestor, service, nodeIdentifier, subscriber = self._getParameters(
-                iq, 'subscribe', 'nodeOrEmpty', 'jid')
-
-        def toResponse(result):
-            response = domish.Element((NS_PUBSUB, "pubsub"))
-            subscription = response.addElement("subscription")
-            if result.nodeIdentifier:
-                subscription["node"] = result.nodeIdentifier
-            subscription["jid"] = result.subscriber.full()
-            subscription["subscription"] = result.state
-            return response
-
-        d = self.subscribe(requestor, service, nodeIdentifier, subscriber)
-        d.addCallback(toResponse)
-        return d
-
-
-    def _onUnsubscribe(self, iq):
-        requestor, service, nodeIdentifier, subscriber = self._getParameters(
-                iq, 'unsubscribe', 'nodeOrEmpty', 'jid')
-
-        return self.unsubscribe(requestor, service, nodeIdentifier, subscriber)
-
-
-    def _onOptionsGet(self, iq):
-        raise Unsupported('subscription-options')
-
-
-    def _onOptionsSet(self, iq):
-        raise Unsupported('subscription-options')
-
-
-    def _onSubscriptions(self, iq):
-        requestor, service = self._getParameters(iq)
-
-        def toResponse(result):
-            response = domish.Element((NS_PUBSUB, 'pubsub'))
-            subscriptions = response.addElement('subscriptions')
-            for node, subscriber, state in result:
-                item = subscriptions.addElement('subscription')
-                item['node'] = node
-                item['jid'] = subscriber.full()
-                item['subscription'] = state
-            return response
-
-        d = self.subscriptions(requestor, service)
-        d.addCallback(toResponse)
-        return d
-
-
-    def _onAffiliations(self, iq):
-        requestor, service = self._getParameters(iq)
-
-        def toResponse(result):
-            response = domish.Element((NS_PUBSUB, 'pubsub'))
-            affiliations = response.addElement('affiliations')
-
-            for nodeIdentifier, affiliation in result:
-                item = affiliations.addElement('affiliation')
-                item['node'] = nodeIdentifier
-                item['affiliation'] = affiliation
-
-            return response
-
-        d = self.affiliations(requestor, service)
-        d.addCallback(toResponse)
-        return d
-
-
-    def _onCreate(self, iq):
-        requestor, service = self._getParameters(iq)
-        nodeIdentifier = iq.pubsub.create.getAttribute("node")
-
-        def toResponse(result):
-            if not nodeIdentifier or nodeIdentifier != result:
-                response = domish.Element((NS_PUBSUB, 'pubsub'))
-                create = response.addElement('create')
-                create['node'] = result
-                return response
-            else:
-                return None
-
-        d = self.create(requestor, service, nodeIdentifier)
-        d.addCallback(toResponse)
-        return d
 
 
@@ -767 +1027 @@
         return fields
 
-    def _formFromConfiguration(self, values):
-        options = self.getConfigurationOptions()
+
+    def _formFromConfiguration(self, resource, values):
+        options = resource.getConfigurationOptions()
         fields = self._makeFields(options, values)
         form = data_form.Form(formType="form",
@@ -776 +1037 @@
         return form
 
-    def _checkConfiguration(self, values):
-        options = self.getConfigurationOptions()
+
+    def _checkConfiguration(self, resource, values):
+        options = resource.getConfigurationOptions()
         processedValues = {}
 
@@ -801 +1063 @@
 
 
-    def _onDefault(self, iq):
-        requestor, service = self._getParameters(iq)
-
-        def toResponse(options):
-            response = domish.Element((NS_PUBSUB_OWNER, "pubsub"))
-            default = response.addElement("default")
-            default.addChild(self._formFromConfiguration(options).toElement())
-            return response
-
-        form = self._findForm(iq.pubsub.config, NS_PUBSUB_NODE_CONFIG)
-        values = form and form.formType == 'result' and form.getValues() or {}
-        nodeType = values.get('pubsub#node_type', 'leaf')
-
-        if nodeType not in ('leaf', 'collections'):
-            return defer.fail(error.StanzaError('not-acceptable'))
-
-        d = self.getDefaultConfiguration(requestor, service, nodeType)
-        d.addCallback(toResponse)
-        return d
-
-
-    def _onConfigureGet(self, iq):
-        requestor, service, nodeIdentifier = self._getParameters(
-                iq, 'configure', 'nodeOrEmpty')
-
-        def toResponse(options):
-            response = domish.Element((NS_PUBSUB_OWNER, "pubsub"))
-            configure = response.addElement("configure")
-            configure.addChild(self._formFromConfiguration(options).toElement())
-
-            if nodeIdentifier:
-                configure["node"] = nodeIdentifier
-
-            return response
-
-        d = self.getConfiguration(requestor, service, nodeIdentifier)
-        d.addCallback(toResponse)
-        return d
-
-
-    def _onConfigureSet(self, iq):
-        requestor, service, nodeIdentifier = self._getParameters(
-                iq, 'configure', 'nodeOrEmpty')
-
-        # Search configuration form with correct FORM_TYPE and process it
-
-        form = self._findForm(iq.pubsub.configure, NS_PUBSUB_NODE_CONFIG)
-
-        if form:
-            if form.formType == 'submit':
-                options = self._checkConfiguration(form.getValues())
-
-                return self.setConfiguration(requestor, service,
-                                             nodeIdentifier, options)
-            elif form.formType == 'cancel':
-                return None
-
-        raise BadRequest()
-
-
-    def _onItems(self, iq):
-        requestor, service, nodeIdentifier, maxItems = self._getParameters(
-                iq, 'items', 'nodeOrEmpty', 'max_items')
-
-        itemIdentifiers = []
-        for child in iq.pubsub.items.elements():
-            if child.name == 'item' and child.uri == NS_PUBSUB:
-                try:
-                    itemIdentifiers.append(child["id"])
-                except KeyError:
-                    raise BadRequest()
-
-        def toResponse(result):
-            response = domish.Element((NS_PUBSUB, 'pubsub'))
-            items = response.addElement('items')
-            if nodeIdentifier:
-                items["node"] = nodeIdentifier
-
-            for item in result:
-                items.addChild(item)
-
-            return response
-
-        d = self.items(requestor, service, nodeIdentifier, maxItems,
-                       itemIdentifiers)
-        d.addCallback(toResponse)
-        return d
-
-
-    def _onRetract(self, iq):
-        requestor, service, nodeIdentifier = self._getParameters(
-                iq, 'retract', 'node')
-
-        itemIdentifiers = []
-        for child in iq.pubsub.retract.elements():
-            if child.uri == NS_PUBSUB and child.name == 'item':
-                try:
-                    itemIdentifiers.append(child["id"])
-                except KeyError:
-                    raise BadRequest()
-
-        return self.retract(requestor, service, nodeIdentifier,
-                            itemIdentifiers)
-
-
-    def _onPurge(self, iq):
-        requestor, service, nodeIdentifier = self._getParameters(
-                iq, 'purge', 'node')
-        return self.purge(requestor, service, nodeIdentifier)
-
-
-    def _onDelete(self, iq):
-        requestor, service, nodeIdentifier = self._getParameters(
-                iq, 'delete', 'node')
-        return self.delete(requestor, service, nodeIdentifier)
-
-
-    def _onAffiliationsGet(self, iq):
-        raise Unsupported('modify-affiliations')
-
-
-    def _onAffiliationsSet(self, iq):
-        raise Unsupported('modify-affiliations')
-
-
-    def _onSubscriptionsGet(self, iq):
-        raise Unsupported('manage-subscriptions')
-
-
-    def _onSubscriptionsSet(self, iq):
-        raise Unsupported('manage-subscriptions')
-
-    # public methods
+    def _preProcess_default(self, resource, request):
+        if request.nodeType not in ('leaf', 'collection'):
+            raise error.StanzaError('not-acceptable')
+        else:
+            return request
+
+
+    def _toResponse_default(self, options, resource, request):
+        response = domish.Element((NS_PUBSUB_OWNER, "pubsub"))
+        default = response.addElement("default")
+        form = self._formFromConfiguration(resource, options)
+        default.addChild(form.toElement())
+        return response
+
+
+    def _toResponse_configureGet(self, options, resource, request):
+        response = domish.Element((NS_PUBSUB_OWNER, "pubsub"))
+        configure = response.addElement("configure")
+        form = self._formFromConfiguration(resource, options)
+        configure.addChild(form.toElement())
+
+        if request.nodeIdentifier:
+            configure["node"] = request.nodeIdentifier
+
+        return response
+
+
+    def _preProcess_configureSet(self, resource, request):
+        if request.options:
+            request.options = self._checkConfiguration(resource,
+                                                       request.options)
+            return request
+        else:
+            return None
+
+
+    def _toResponse_items(self, result, resource, request):
+        response = domish.Element((NS_PUBSUB, 'pubsub'))
+        items = response.addElement('items')
+        items["node"] = request.nodeIdentifier
+
+        for item in result:
+            items.addChild(item)
+
+        return response
+
 
     def _createNotification(self, eventType, service, nodeIdentifier,
@@ -956 +1131 @@
 
         return message
+
+    # public methods
 
     def notifyPublish(self, service, nodeIdentifier, notifications):
@@ -966 +1143 @@
 
 
-    def notifyDelete(self, service, nodeIdentifier, subscriptions):
-        for subscription in subscriptions:
+    def notifyDelete(self, service, nodeIdentifier, subscribers,
+                           redirectURI=None):
+        for subscriber in subscribers:
             message = self._createNotification('delete', service,
                                                nodeIdentifier,
-                                               subscription.subscriber)
+                                               subscriber)
+            if redirectURI:
+                redirect = message.event.delete.addElement('redirect')
+                redirect['uri'] = redirectURI
             self.send(message)
 
@@ -1010 +1191 @@
 
 
-    def getDefaultConfiguration(self, requestor, service):
+    def getDefaultConfiguration(self, requestor, service, nodeType):
         raise Unsupported('retrieve-default')
 
@@ -1037 +1218 @@
     def delete(self, requestor, service, nodeIdentifier):
         raise Unsupported('delete-nodes')
+
+
+
+class PubSubResource(object):
+
+    implements(IPubSubResource)
+
+    features = []
+    discoIdentity = disco.DiscoIdentity('pubsub',
+                                        'service',
+                                        'Publish-Subscribe Service')
+
+
+    def locateResource(self, request):
+        return self
+
+
+    def getInfo(self, requestor, service, nodeIdentifier):
+        return defer.succeed(None)
+
+
+    def getNodes(self, requestor, service, nodeIdentifier):
+        return defer.succeed([])
+
+
+    def getConfigurationOptions(self):
+        return {}
+
+
+    def publish(self, request):
+        return defer.fail(Unsupported('publish'))
+
+
+    def subscribe(self, request):
+        return defer.fail(Unsupported('subscribe'))
+
+
+    def unsubscribe(self, request):
+        return defer.fail(Unsupported('subscribe'))
+
+
+    def subscriptions(self, request):
+        return defer.fail(Unsupported('retrieve-subscriptions'))
+
+
+    def affiliations(self, request):
+        return defer.fail(Unsupported('retrieve-affiliations'))
+
+
+    def create(self, request):
+        return defer.fail(Unsupported('create-nodes'))
+
+
+    def default(self, request):
+        return defer.fail(Unsupported('retrieve-default'))
+
+
+    def configureGet(self, request):
+        return defer.fail(Unsupported('config-node'))
+
+
+    def configureSet(self, request):
+        return defer.fail(Unsupported('config-node'))
+
+
+    def items(self, request):
+        return defer.fail(Unsupported('retrieve-items'))
+
+
+    def retract(self, request):
+        return defer.fail(Unsupported('retract-items'))
+
+
+    def purge(self, request):
+        return defer.fail(Unsupported('purge-nodes'))
+
+
+    def delete(self, request):
+        return defer.fail(Unsupported('delete-nodes'))
+
+
+    def affiliationsGet(self, request):
+        return defer.fail(Unsupported('modify-affiliations'))
+
+
+    def affiliationsSet(self, request):
+        return defer.fail(Unsupported('modify-affiliations'))
+
+
+    def subscriptionsGet(self, request):
+        return defer.fail(Unsupported('manage-subscriptions'))
+
+
+    def subscriptionsSet(self, request):
+        return defer.fail(Unsupported('manage-subscriptions'))

wokkel/subprotocols.py

@@ -1 +1 @@
 # -*- test-case-name: wokkel.test.test_subprotocols -*-
 #
-# Copyright (c) 2001-2007 Twisted Matrix Laboratories.
+# Copyright (c) 2001-2009 Twisted Matrix Laboratories.
 # See LICENSE for details.
 
@@ -13 +13 @@
 from twisted.python import log
 from twisted.words.protocols.jabber import error, xmlstream
+from twisted.words.protocols.jabber.xmlstream import toResponse
 from twisted.words.xish import xpath
 from twisted.words.xish.domish import IElement
 
-try:
-    from twisted.words.protocols.jabber.xmlstream import toResponse
-except ImportError:
-    from wokkel.compat import toResponse
-
 from wokkel.iwokkel import IXMPPHandler, IXMPPHandlerCollection
 
 class XMPPHandler(object):
+    """
+    XMPP protocol handler.
+
+    Classes derived from this class implement (part of) one or more XMPP
+    extension protocols, and are referred to as a subprotocol implementation.
+    """
+
     implements(IXMPPHandler)
+
+    def __init__(self):
+        self.parent = None
+        self.xmlstream = None
+
 
     def setHandlerParent(self, parent):
@@ -30 +38 @@
         self.parent.addHandler(self)
 
+
     def disownHandlerParent(self, parent):
         self.parent.removeHandler(self)
         self.parent = None
 
+
     def makeConnection(self, xs):
         self.xmlstream = xs
         self.connectionMade()
 
+
     def connectionMade(self):
-        pass
+        """
+        Called after a connection has been established.
+
+        Can be overridden to perform work before stream initialization.
+        """
+
 
     def connectionInitialized(self):
-        pass
+        """
+        The XML stream has been initialized.
+
+        Can be overridden to perform work after stream initialization, e.g. to
+        set up observers and start exchanging XML stanzas.
+        """
+
 
     def connectionLost(self, reason):
+        """
+        The XML stream has been closed.
+
+        This method can be extended to inspect the C{reason} argument and
+        act on it.
+        """
         self.xmlstream = None
+
 
     def send(self, obj):
@@ -65 +94 @@
 
 
+
 class XMPPHandlerCollection(object):
     """
@@ -72 +102 @@
     L{XMPPHandler} itself, so this is not recursive.
 
-    @ivar xmlstream: Currently managed XML stream.
-    @type xmlstream: L{XmlStream}
     @ivar handlers: List of protocol handlers.
     @type handlers: L{list} of objects providing
@@ -83 +111 @@
     def __init__(self):
         self.handlers = []
-        self.xmlstream = None
-        self._initialized = False
+
 
     def __iter__(self):
@@ -92 +119 @@
         return iter(self.handlers)
 
+
     def addHandler(self, handler):
         """
@@ -97 +125 @@
 
         Protocol handlers are expected to provide L{IXMPPHandler}.
-
-        When an XML stream has already been established, the handler's
-        C{connectionInitialized} will be called to get it up to speed.
-        """
-
+        """
         self.handlers.append(handler)
 
-        # get protocol handler up to speed when a connection has already
-        # been established
-        if self.xmlstream and self._initialized:
-            handler.makeConnection(self.xmlstream)
-            handler.connectionInitialized()
 
     def removeHandler(self, handler):
@@ -114 +133 @@
         Remove protocol handler.
         """
-
         self.handlers.remove(handler)
+
+
 
 class StreamManager(XMPPHandlerCollection):
@@ -126 +146 @@
     using L{addHandler}.
 
+    @ivar xmlstream: currently managed XML stream
+    @type xmlstream: L{XmlStream}
     @ivar logTraffic: if true, log all traffic.
     @type logTraffic: L{bool}
+    @ivar _initialized: Whether the stream represented by L{xmlstream} has
+                        been initialized. This is used when caching outgoing
+                        stanzas.
+    @type _initialized: C{bool}
     @ivar _packetQueue: internal buffer of unsent data. See L{send} for details.
     @type _packetQueue: L{list}
@@ -135 +161 @@
 
     def __init__(self, factory):
-        self.handlers = []
+        XMPPHandlerCollection.__init__(self)
         self.xmlstream = None
         self._packetQueue = []
@@ -147 +173 @@
         self.factory = factory
 
+
+    def addHandler(self, handler):
+        """
+        Add protocol handler.
+
+        When an XML stream has already been established, the handler's
+        C{connectionInitialized} will be called to get it up to speed.
+        """
+        XMPPHandlerCollection.addHandler(self, handler)
+
+        # get protocol handler up to speed when a connection has already
+        # been established
+        if self.xmlstream and self._initialized:
+            handler.makeConnection(self.xmlstream)
+            handler.connectionInitialized()
+
+
     def _connected(self, xs):
+        """
+        Called when the transport connection has been established.
+
+        Here we optionally set up traffic logging (depending on L{logTraffic})
+        and call each handler's C{makeConnection} method with the L{XmlStream}
+        instance.
+        """
         def logDataIn(buf):
             log.msg("RECV: %r" % buf)
@@ -163 +213 @@
             e.makeConnection(xs)
 
+
     def _authd(self, xs):
+        """
+        Called when the stream has been initialized.
+
+        Send out cached stanzas and call each handler's
+        C{connectionInitialized} method.
+        """
         # Flush all pending packets
         for p in self._packetQueue:
@@ -175 +232 @@
             e.connectionInitialized()
 
+
     def initializationFailed(self, reason):
         """
@@ -188 +246 @@
         """
 
+
     def _disconnected(self, _):
+        """
+        Called when the stream has been closed.
+
+        From this point on, the manager doesn't interact with the
+        L{XmlStream} anymore and notifies each handler that the connection
+        was lost by calling its C{connectionLost} method.
+        """
         self.xmlstream = None
         self._initialized = False
@@ -195 +261 @@
         # the IService interface
         for e in self:
-            e.xmlstream = None
             e.connectionLost(None)
+
 
     def send(self, obj):
@@ -208 +274 @@
                     L{xmlstream.XmlStream.send} for details.
         """
-
         if self._initialized:
             self.xmlstream.send(obj)
         else:
             self._packetQueue.append(obj)
+
 
 

wokkel/test/helpers.py

@@ -6 +6 @@
 """
 
+from twisted.internet import defer
+from twisted.words.xish import xpath
 from twisted.words.xish.utility import EventDispatcher
+
+from wokkel.generic import parseXml
 
 class XmlStreamStub(object):
@@ -55 +59 @@
         """
         self.xmlstream.dispatch(obj)
+
+
+class TestableRequestHandlerMixin(object):
+    """
+    Mixin for testing XMPPHandlers that process iq requests.
+
+    Handlers that use L{wokkel.subprotocols.IQHandlerMixin} define a
+    C{iqHandlers} attribute that lists the handlers to be called for iq
+    requests. This mixin provides L{handleRequest} to mimic the handler
+    processing for easier testing.
+    """
+
+    def handleRequest(self, xml):
+        """
+        Find a handler and call it directly.
+
+        @param xml: XML stanza that may yield a handler being called.
+        @type xml: C{str}.
+        @return: Deferred that fires with the result of a handler for this
+                 stanza. If no handler was found, the deferred has its errback
+                 called with a C{NotImplementedError} exception.
+        """
+        handler = None
+        iq = parseXml(xml)
+        for queryString, method in self.service.iqHandlers.iteritems():
+            if xpath.internQuery(queryString).matches(iq):
+                handler = getattr(self.service, method)
+
+        if handler:
+            d = defer.maybeDeferred(handler, iq)
+        else:
+            d = defer.fail(NotImplementedError())
+
+        return d

wokkel/test/test_client.py

@@ -6 +6 @@
 """
 
+from twisted.internet import defer
 from twisted.trial import unittest
+from twisted.words.protocols.jabber import xmlstream
+from twisted.words.protocols.jabber.client import XMPPAuthenticator
 from twisted.words.protocols.jabber.jid import JID
 from twisted.words.protocols.jabber.xmlstream import STREAM_AUTHD_EVENT
 from twisted.words.protocols.jabber.xmlstream import INIT_FAILED_EVENT
 
-from wokkel.client import DeferredClientFactory
+from wokkel import client
+from wokkel.test.test_compat import BootstrapMixinTest
 
-class DeferredClientFactoryTest(unittest.TestCase):
+class DeferredClientFactoryTest(BootstrapMixinTest):
+    """
+    Tests for L{client.DeferredClientFactory}.
+    """
+
+    def setUp(self):
+        self.factory = client.DeferredClientFactory(JID('user@example.org'),
+                                                    'secret')
+
+
+    def test_buildProtocol(self):
+        """
+        The authenticator factory should be passed to its protocol and it
+        should instantiate the authenticator and save it.
+        L{xmlstream.XmlStream}s do that, but we also want to ensure it really
+        is one.
+        """
+        xs = self.factory.buildProtocol(None)
+        self.assertIdentical(self.factory, xs.factory)
+        self.assertIsInstance(xs, xmlstream.XmlStream)
+        self.assertIsInstance(xs.authenticator, XMPPAuthenticator)
+
 
     def test_deferredOnInitialized(self):
@@ -20 +45 @@
         """
 
-        f = DeferredClientFactory(JID('user@example.org'), 'secret')
-        xmlstream = f.buildProtocol(None)
-        xmlstream.dispatch(xmlstream, STREAM_AUTHD_EVENT)
-        return f.deferred
+        xs = self.factory.buildProtocol(None)
+        xs.dispatch(xs, STREAM_AUTHD_EVENT)
+        return self.factory.deferred
+
 
     def test_deferredOnNotInitialized(self):
@@ -30 +55 @@
         """
 
-        f = DeferredClientFactory(JID('user@example.org'), 'secret')
-        xmlstream = f.buildProtocol(None)
-
         class TestException(Exception):
             pass
 
-        xmlstream.dispatch(TestException(), INIT_FAILED_EVENT)
-        self.assertFailure(f.deferred, TestException)
-        return f.deferred
+        xs = self.factory.buildProtocol(None)
+        xs.dispatch(TestException(), INIT_FAILED_EVENT)
+        self.assertFailure(self.factory.deferred, TestException)
+        return self.factory.deferred
+
 
     def test_deferredOnConnectionFailure(self):
@@ -45 +69 @@
         """
 
-        f = DeferredClientFactory(JID('user@example.org'), 'secret')
-        xmlstream = f.buildProtocol(None)
-
         class TestException(Exception):
             pass
 
-        f.clientConnectionFailed(self, TestException())
-        self.assertFailure(f.deferred, TestException)
-        return f.deferred
+        xs = self.factory.buildProtocol(None)
+        self.factory.clientConnectionFailed(self, TestException())
+        self.assertFailure(self.factory.deferred, TestException)
+        return self.factory.deferred
+
+
+
+class ClientCreatorTest(unittest.TestCase):
+    """
+    Tests for L{client.clientCreator}.
+    """
+
+    def test_call(self):
+        """
+        The factory is passed to an SRVConnector and a connection initiated.
+        """
+
+        d1 = defer.Deferred()
+        factory = client.DeferredClientFactory(JID('user@example.org'),
+                                               'secret')
+
+        def cb(connector):
+            self.assertEqual('xmpp-client', connector.service)
+            self.assertEqual('example.org', connector.domain)
+            self.assertEqual(factory, connector.factory)
+
+        def connect(connector):
+            d1.callback(connector)
+
+        d1.addCallback(cb)
+        self.patch(client.SRVConnector, 'connect', connect)
+
+        d2 = client.clientCreator(factory)
+        self.assertEqual(factory.deferred, d2)
+
+        return d1

wokkel/test/test_compat.py

@@ -1 @@
-# Copyright (c) 2001-2007 Twisted Matrix Laboratories.
-# Copyright (c) 2008 Ralph Meijer
+# Copyright (c) 2001-2008 Twisted Matrix Laboratories.
+# Copyright (c) 2008-2009 Ralph Meijer
 # See LICENSE for details.
 
@@ -7 +7 @@
 """
 
+from zope.interface.verify import verifyObject
 from twisted.internet import defer, protocol
+from twisted.internet.interfaces import IProtocolFactory
 from twisted.trial import unittest
 from twisted.words.xish import domish, utility
-from wokkel.compat import toResponse, XmlStreamFactoryMixin
+from twisted.words.protocols.jabber import xmlstream
+from wokkel.compat import BootstrapMixin, XmlStreamServerFactory
 
 class DummyProtocol(protocol.Protocol, utility.EventDispatcher):
@@ -16 +19 @@
     I am a protocol with an event dispatcher without further processing.
 
-    This protocol is only used for testing XmlStreamFactoryMixin to make
+    This protocol is only used for testing BootstrapMixin to make
     sure the bootstrap observers are added to the protocol instance.
     """
@@ -28 +31 @@
 
 
-class XmlStreamFactoryMixinTest(unittest.TestCase):
 
-    def test_buildProtocol(self):
+class BootstrapMixinTest(unittest.TestCase):
+    """
+    Tests for L{BootstrapMixin}.
+
+    @ivar factory: Instance of the factory or mixin under test.
+    """
+
+    def setUp(self):
+        self.factory = BootstrapMixin()
+
+
+    def test_installBootstraps(self):
         """
-        Test building of protocol.
+        Dispatching an event should fire registered bootstrap observers.
+        """
+        called = []
 
-        Arguments passed to Factory should be passed to protocol on
-        instantiation. Bootstrap observers should be setup.
-        """
-        d = defer.Deferred()
+        def cb(data):
+            called.append(data)
 
-        f = XmlStreamFactoryMixin(None, test=None)
-        f.protocol = DummyProtocol
-        f.addBootstrap('//event/myevent', d.callback)
-        xs = f.buildProtocol(None)
+        dispatcher = DummyProtocol()
+        self.factory.addBootstrap('//event/myevent', cb)
+        self.factory.installBootstraps(dispatcher)
 
-        self.assertEquals(f, xs.factory)
-        self.assertEquals((None,), xs.args)
-        self.assertEquals({'test': None}, xs.kwargs)
-        xs.dispatch(None, '//event/myevent')
-        return d
+        dispatcher.dispatch(None, '//event/myevent')
+        self.assertEquals(1, len(called))
+
 
     def test_addAndRemoveBootstrap(self):
@@ -54 +64 @@
         Test addition and removal of a bootstrap event handler.
         """
-        def cb(self):
-            pass
 
-        f = XmlStreamFactoryMixin(None, test=None)
+        called = []
 
-        f.addBootstrap('//event/myevent', cb)
-        self.assertIn(('//event/myevent', cb), f.bootstraps)
+        def cb(data):
+            called.append(data)
 
-        f.removeBootstrap('//event/myevent', cb)
-        self.assertNotIn(('//event/myevent', cb), f.bootstraps)
+        self.factory.addBootstrap('//event/myevent', cb)
+        self.factory.removeBootstrap('//event/myevent', cb)
 
-class ToResponseTest(unittest.TestCase):
+        dispatcher = DummyProtocol()
+        self.factory.installBootstraps(dispatcher)
 
-    def test_toResponse(self):
+        dispatcher.dispatch(None, '//event/myevent')
+        self.assertFalse(called)
+
+
+
+class XmlStreamServerFactoryTest(BootstrapMixinTest):
+    """
+    Tests for L{XmlStreamServerFactory}.
+    """
+
+    def setUp(self):
         """
-        Test that a response stanza is generated with addressing swapped.
+        Set up a server factory with a authenticator factory function.
         """
-        stanza = domish.Element(('jabber:client', 'iq'))
-        stanza['type'] = 'get'
-        stanza['to'] = 'user1@example.com'
-        stanza['from'] = 'user2@example.com/resource'
-        stanza['id'] = 'stanza1'
-        response = toResponse(stanza, 'result')
-        self.assertNotIdentical(stanza, response)
-        self.assertEqual(response['from'], 'user1@example.com')
-        self.assertEqual(response['to'], 'user2@example.com/resource')
-        self.assertEqual(response['type'], 'result')
-        self.assertEqual(response['id'], 'stanza1')
+        class TestAuthenticator(object):
+            def __init__(self):
+                self.xmlstreams = []
 
-    def test_toResponseNoFrom(self):
+            def associateWithStream(self, xs):
+                self.xmlstreams.append(xs)
+
+        def authenticatorFactory():
+            return TestAuthenticator()
+
+        self.factory = XmlStreamServerFactory(authenticatorFactory)
+
+
+    def test_interface(self):
         """
-        Test that a response is generated from a stanza without a from address.
+        L{XmlStreamServerFactory} is a L{Factory}.
         """
-        stanza = domish.Element(('jabber:client', 'iq'))
-        stanza['type'] = 'get'
-        stanza['to'] = 'user1@example.com'
-        response = toResponse(stanza)
-        self.assertEqual(response['from'], 'user1@example.com')
-        self.failIf(response.hasAttribute('to'))
+        verifyObject(IProtocolFactory, self.factory)
 
-    def test_toResponseNoTo(self):
+
+    def test_buildProtocolAuthenticatorInstantiation(self):
         """
-        Test that a response is generated from a stanza without a to address.
+        The authenticator factory should be used to instantiate the
+        authenticator and pass it to the protocol.
+
+        The default protocol, L{XmlStream} stores the authenticator it is
+        passed, and calls its C{associateWithStream} method. so we use that to
+        check whether our authenticator factory is used and the protocol
+        instance gets an authenticator.
         """
-        stanza = domish.Element(('jabber:client', 'iq'))
-        stanza['type'] = 'get'
-        stanza['from'] = 'user2@example.com/resource'
-        response = toResponse(stanza)
-        self.failIf(response.hasAttribute('from'))
-        self.assertEqual(response['to'], 'user2@example.com/resource')
+        xs = self.factory.buildProtocol(None)
+        self.assertEquals([xs], xs.authenticator.xmlstreams)
 
-    def test_toResponseNoAddressing(self):
+
+    def test_buildProtocolXmlStream(self):
         """
-        Test that a response is generated from a stanza without any addressing.
+        The protocol factory creates Jabber XML Stream protocols by default.
         """
-        stanza = domish.Element(('jabber:client', 'message'))
-        stanza['type'] = 'chat'
-        response = toResponse(stanza)
-        self.failIf(response.hasAttribute('to'))
-        self.failIf(response.hasAttribute('from'))
+        xs = self.factory.buildProtocol(None)
+        self.assertIsInstance(xs, xmlstream.XmlStream)
 
-    def test_noID(self):
+
+    def test_buildProtocolTwice(self):
         """
-        Test that a proper response is generated without id attribute.
+        Subsequent calls to buildProtocol should result in different instances
+        of the protocol, as well as their authenticators.
         """
-        stanza = domish.Element(('jabber:client', 'message'))
-        response = toResponse(stanza)
-        self.failIf(response.hasAttribute('id'))
+        xs1 = self.factory.buildProtocol(None)
+        xs2 = self.factory.buildProtocol(None)
+        self.assertNotIdentical(xs1, xs2)
+        self.assertNotIdentical(xs1.authenticator, xs2.authenticator)
+
+
+    def test_buildProtocolInstallsBootstraps(self):
+        """
+        The protocol factory installs bootstrap event handlers on the protocol.
+        """
+        called = []
+
+        def cb(data):
+            called.append(data)
+
+        self.factory.addBootstrap('//event/myevent', cb)
+
+        xs = self.factory.buildProtocol(None)
+        xs.dispatch(None, '//event/myevent')
+
+        self.assertEquals(1, len(called))
+
+
+    def test_buildProtocolStoresFactory(self):
+        """
+        The protocol factory is saved in the protocol.
+        """
+        xs = self.factory.buildProtocol(None)
+        self.assertIdentical(self.factory, xs.factory)

wokkel/test/test_data_form.py

@@ -1 @@
-# Copyright (c) 2003-2008 Ralph Meijer
+# Copyright (c) 2003-2009 Ralph Meijer
 # See LICENSE for details.
 
@@ -8 +8 @@
 from twisted.trial import unittest
 from twisted.words.xish import domish
-
-from wokkel.data_form import Field, Form, Option, FieldNameRequiredError
+from twisted.words.protocols.jabber import jid
+
+from wokkel import data_form
 
 NS_X_DATA = 'jabber:x:data'
 
-
-
 class OptionTest(unittest.TestCase):
     """
-    Tests for L{Option}.
+    Tests for L{data_form.Option}.
     """
 
     def test_toElement(self):
-        option = Option('value', 'label')
+        option = data_form.Option('value', 'label')
         element = option.toElement()
         self.assertEquals('option', element.name)
@@ -34 +33 @@
 class FieldTest(unittest.TestCase):
     """
-    Tests for L{Field}.
+    Tests for L{data_form.Field}.
     """
 
     def test_basic(self):
-        field = Field(var='test')
+        """
+        Test basic field initialization.
+        """
+        field = data_form.Field(var='test')
         self.assertEqual('text-single', field.fieldType)
         self.assertEqual('test', field.var)
 
+
+    def test_toElement(self):
+        """
+        Test rendering to a DOM.
+        """
+        field = data_form.Field(var='test')
         element = field.toElement()
 
@@ -47 +55 @@
         self.assertEquals('field', element.name)
         self.assertEquals(NS_X_DATA, element.uri)
-        self.assertEquals('text-single', element['type'])
+        self.assertEquals('text-single',
+                          element.getAttribute('type', 'text-single'))
         self.assertEquals('test', element['var'])
         self.assertEquals([], element.children)
 
 
-    def test_noFieldName(self):
-        field = Field()
-        self.assertRaises(FieldNameRequiredError, field.toElement)
+    def test_toElementTypeNotListSingle(self):
+        """
+        Always render the field type, if different from list-single.
+        """
+        field = data_form.Field('hidden', var='test')
+        element = field.toElement()
+
+        self.assertEquals('hidden', element.getAttribute('type'))
+
+
+    def test_toElementAsForm(self):
+        """
+        Always render the field type, if asForm is True.
+        """
+        field = data_form.Field(var='test')
+        element = field.toElement(True)
+
+        self.assertEquals('text-single', element.getAttribute('type'))
+
+
+    def test_toElementOptions(self):
+        """
+        Test rendering to a DOM with options.
+        """
+        field = data_form.Field('list-single', var='test')
+        field.options = [data_form.Option(u'option1'),
+                         data_form.Option(u'option2')]
+        element = field.toElement(True)
+
+        self.assertEqual(2, len(element.children))
+
+
+    def test_toElementLabel(self):
+        """
+        Test rendering to a DOM with a label.
+        """
+        field = data_form.Field(var='test', label=u'my label')
+        element = field.toElement(True)
+
+        self.assertEqual(u'my label', element.getAttribute('label'))
+
+
+    def test_toElementDescription(self):
+        """
+        Test rendering to a DOM with options.
+        """
+        field = data_form.Field(var='test', desc=u'My desc')
+        element = field.toElement(True)
+
+        self.assertEqual(1, len(element.children))
+        child = element.children[0]
+        self.assertEqual('desc', child.name)
+        self.assertEqual(NS_X_DATA, child.uri)
+        self.assertEqual(u'My desc', unicode(child))
+
+
+    def test_toElementRequired(self):
+        """
+        Test rendering to a DOM with options.
+        """
+        field = data_form.Field(var='test', required=True)
+        element = field.toElement(True)
+
+        self.assertEqual(1, len(element.children))
+        child = element.children[0]
+        self.assertEqual('required', child.name)
+        self.assertEqual(NS_X_DATA, child.uri)
+
+
+    def test_toElementJID(self):
+        field = data_form.Field(fieldType='jid-single', var='test',
+                                value=jid.JID(u'test@example.org'))
+        element = field.toElement()
+        self.assertEqual(u'test@example.org', unicode(element.value))
+
+
+    def test_typeCheckNoFieldName(self):
+        """
+        A field not of type fixed must have a var.
+        """
+        field = data_form.Field(fieldType='list-single')
+        self.assertRaises(data_form.FieldNameRequiredError, field.typeCheck)
+
+
+    def test_typeCheckTooManyValues(self):
+        """
+        Expect an exception if too many values are set, depending on type.
+        """
+        field = data_form.Field(fieldType='list-single', var='test',
+                                values=[u'value1', u'value2'])
+        self.assertRaises(data_form.TooManyValuesError, field.typeCheck)
+
+
+    def test_typeCheckBooleanFalse(self):
+        """
+        Test possible False values for a boolean field.
+        """
+        field = data_form.Field(fieldType='boolean', var='test')
+
+        for value in (False, 0, '0', 'false', 'False', []):
+            field.value = value
+            field.typeCheck()
+            self.assertIsInstance(field.value, bool)
+            self.assertFalse(field.value)
+
+
+    def test_typeCheckBooleanTrue(self):
+        """
+        Test possible True values for a boolean field.
+        """
+        field = data_form.Field(fieldType='boolean', var='test')
+
+        for value in (True, 1, '1', 'true', 'True', ['test']):
+            field.value = value
+            field.typeCheck()
+            self.assertIsInstance(field.value, bool)
+            self.assertTrue(field.value)
+
+
+    def test_typeCheckBooleanBad(self):
+        """
+        A bad value for a boolean field should raise a ValueError
+        """
+        field = data_form.Field(fieldType='boolean', var='test')
+        field.value = 'test'
+        self.assertRaises(ValueError, field.typeCheck)
+
+
+    def test_typeCheckJID(self):
+        """
+        The value of jid field should be a JID or coercable to one.
+        """
+        field = data_form.Field(fieldType='jid-single', var='test',
+                                value=jid.JID('test@example.org'))
+        field.typeCheck()
+
+
+    def test_typeCheckJIDString(self):
+        """
+        The string value of jid field should be coercable into a JID.
+        """
+        field = data_form.Field(fieldType='jid-single', var='test',
+                                value='test@example.org')
+        field.typeCheck()
+        self.assertEquals(jid.JID(u'test@example.org'), field.value)
+
+
+    def test_typeCheckJIDBad(self):
+        """
+        An invalid JID string should raise an exception.
+        """
+        field = data_form.Field(fieldType='jid-single', var='test',
+                                value='test@@example.org')
+        self.assertRaises(jid.InvalidFormat, field.typeCheck)
 
 
@@ -60 +220 @@
         element = domish.Element((NS_X_DATA, 'field'))
         element['type'] = 'fixed'
-        field = Field.fromElement(element)
+        field = data_form.Field.fromElement(element)
         self.assertEquals('fixed', field.fieldType)
 
@@ -66 +226 @@
     def test_fromElementNoType(self):
         element = domish.Element((NS_X_DATA, 'field'))
-        field = Field.fromElement(element)
+        field = data_form.Field.fromElement(element)
         self.assertEquals(None, field.fieldType)
 
 
-    def test_fromElementValue(self):
-        element = domish.Element((NS_X_DATA, 'field'))
-        element.addElement("value", content="text")
-        field = Field.fromElement(element)
+    def test_fromElementValueTextSingle(self):
+        """
+        Parsed text-single field values should be of type C{unicode}.
+        """
+        element = domish.Element((NS_X_DATA, 'field'))
+        element['type'] = 'text-single'
+        element.addElement('value', content=u'text')
+        field = data_form.Field.fromElement(element)
         self.assertEquals('text', field.value)
 
 
+    def test_fromElementValueJID(self):
+        """
+        Parsed jid-single field values should be of type C{unicode}.
+        """
+        element = domish.Element((NS_X_DATA, 'field'))
+        element['type'] = 'jid-single'
+        element.addElement('value', content=u'user@example.org')
+        field = data_form.Field.fromElement(element)
+        self.assertEquals(u'user@example.org', field.value)
+
+    def test_fromElementValueJIDMalformed(self):
+        """
+        Parsed jid-single field values should be of type C{unicode}.
+
+        No validation should be done at this point, so invalid JIDs should
+        also be passed as-is.
+        """
+        element = domish.Element((NS_X_DATA, 'field'))
+        element['type'] = 'jid-single'
+        element.addElement('value', content=u'@@')
+        field = data_form.Field.fromElement(element)
+        self.assertEquals(u'@@', field.value)
+
+
+    def test_fromElementValueBoolean(self):
+        """
+        Parsed boolean field values should be of type C{unicode}.
+        """
+        element = domish.Element((NS_X_DATA, 'field'))
+        element['type'] = 'boolean'
+        element.addElement('value', content=u'false')
+        field = data_form.Field.fromElement(element)
+        self.assertEquals(u'false', field.value)
+
+
 
 class FormTest(unittest.TestCase):
     """
-    Tests for L{Form}.
+    Tests for L{data_form.Form}.
     """
 
@@ -88 +287 @@
         """
 
-        form = Form('result')
+        form = data_form.Form('result')
         self.assertEqual('result', form.formType)
 
@@ -95 +294 @@
         The toElement method returns a form's DOM representation.
         """
-        form = Form('result')
+        form = data_form.Form('result')
         element = form.toElement()
 
@@ -107 +306 @@
     def test_fromElement(self):
         """
-        The fromElement static method creates a L{Form} from a L{DOM.
+        C{fromElement} creates a L{data_form.Form} from a DOM representation.
         """
         element = domish.Element((NS_X_DATA, 'x'))
         element['type'] = 'result'
-        form = Form.fromElement(element)
+        form = data_form.Form.fromElement(element)
 
         self.assertEquals('result', form.formType)
@@ -124 +323 @@
         """
         element = domish.Element((NS_X_DATA, 'form'))
-        self.assertRaises(Exception, Form.fromElement, element)
+        self.assertRaises(Exception, data_form.Form.fromElement, element)
 
 
@@ -132 +331 @@
         """
         element = domish.Element(('myns', 'x'))
-        self.assertRaises(Exception, Form.fromElement, element)
+        self.assertRaises(Exception, data_form.Form.fromElement, element)
 
 
@@ -138 +337 @@
         element = domish.Element((NS_X_DATA, 'x'))
         element.addElement('title', content='My title')
-        form = Form.fromElement(element)
+        form = data_form.Form.fromElement(element)
 
         self.assertEquals('My title', form.title)
@@ -146 +345 @@
         element = domish.Element((NS_X_DATA, 'x'))
         element.addElement('instructions', content='instruction')
-        form = Form.fromElement(element)
+        form = data_form.Form.fromElement(element)
 
         self.assertEquals(['instruction'], form.instructions)
@@ -154 +353 @@
         element.addElement('instructions', content='instruction 1')
         element.addElement('instructions', content='instruction 2')
-        form = Form.fromElement(element)
+        form = data_form.Form.fromElement(element)
 
         self.assertEquals(['instruction 1', 'instruction 2'], form.instructions)
@@ -162 +361 @@
         element = domish.Element((NS_X_DATA, 'x'))
         element.addElement('field')
-        form = Form.fromElement(element)
+        form = data_form.Form.fromElement(element)
 
         self.assertEquals(1, len(form.fieldList))
@@ -172 +371 @@
         element.addElement('field')['var'] = 'field1'
         element.addElement('field')['var'] = 'field2'
-        form = Form.fromElement(element)
+        form = data_form.Form.fromElement(element)
 
         self.assertEquals(2, len(form.fieldList))

wokkel/test/test_disco.py

@@ -1 @@
-# Copyright (c) 2003-2008 Ralph Meijer
+# Copyright (c) 2003-2009 Ralph Meijer
 # See LICENSE for details.
 
@@ -6 +6 @@
 """
 
+from zope.interface import implements
+
 from twisted.internet import defer
 from twisted.trial import unittest
-from twisted.words.xish.xmlstream import XmlStreamFactory
-from zope.interface import implements
-
-from wokkel.subprotocols import XMPPHandler, StreamManager
-
-from wokkel import disco
+from twisted.words.protocols.jabber.jid import JID
+from twisted.words.protocols.jabber.xmlstream import toResponse
+from twisted.words.xish import domish
+
+from wokkel import data_form, disco
+from wokkel.generic import parseXml
+from wokkel.subprotocols import XMPPHandler
+from wokkel.test.helpers import TestableRequestHandlerMixin, XmlStreamStub
 
 NS_DISCO_INFO = 'http://jabber.org/protocol/disco#info'
 NS_DISCO_ITEMS = 'http://jabber.org/protocol/disco#items'
 
-class DiscoResponder(XMPPHandler):
-    implements(disco.IDisco)
-
-    def getDiscoInfo(self, requestor, target, nodeIdentifier):
-        if not nodeIdentifier:
+class DiscoFeatureTest(unittest.TestCase):
+    """
+    Tests for L{disco.DiscoFeature}.
+    """
+
+    def test_init(self):
+        """
+        Test initialization with a with feature namespace URI.
+        """
+        feature = disco.DiscoFeature(u'testns')
+        self.assertEqual(u'testns', feature)
+
+
+    def test_toElement(self):
+        """
+        Test proper rendering to a DOM representation.
+
+        The returned element should be properly named and have a C{var}
+        attribute that holds the feature namespace URI.
+        """
+        feature = disco.DiscoFeature(u'testns')
+        element = feature.toElement()
+        self.assertEqual(NS_DISCO_INFO, element.uri)
+        self.assertEqual(u'feature', element.name)
+        self.assertTrue(element.hasAttribute(u'var'))
+        self.assertEqual(u'testns', element[u'var'])
+
+
+    def test_fromElement(self):
+        """
+        Test creating L{disco.DiscoFeature} from L{domish.Element}.
+        """
+        element = domish.Element((NS_DISCO_INFO, u'feature'))
+        element['var'] = u'testns'
+        feature = disco.DiscoFeature.fromElement(element)
+        self.assertEqual(u'testns', feature)
+
+
+
+class DiscoIdentityTest(unittest.TestCase):
+    """
+    Tests for L{disco.DiscoIdentity}.
+    """
+
+    def test_init(self):
+        """
+        Test initialization with a category, type and name.
+        """
+        identity = disco.DiscoIdentity(u'conference', u'text', u'The chatroom')
+        self.assertEqual(u'conference', identity.category)
+        self.assertEqual(u'text', identity.type)
+        self.assertEqual(u'The chatroom', identity.name)
+
+
+    def test_toElement(self):
+        """
+        Test proper rendering to a DOM representation.
+
+        The returned element should be properly named and have C{conference},
+        C{type}, and C{name} attributes.
+        """
+        identity = disco.DiscoIdentity(u'conference', u'text', u'The chatroom')
+        element = identity.toElement()
+        self.assertEqual(NS_DISCO_INFO, element.uri)
+        self.assertEqual(u'identity', element.name)
+        self.assertEqual(u'conference', element.getAttribute(u'category'))
+        self.assertEqual(u'text', element.getAttribute(u'type'))
+        self.assertEqual(u'The chatroom', element.getAttribute(u'name'))
+
+
+    def test_toElementWithoutName(self):
+        """
+        Test proper rendering to a DOM representation without a name.
+
+        The returned element should be properly named and have C{conference},
+        C{type} attributes, no C{name} attribute.
+        """
+        identity = disco.DiscoIdentity(u'conference', u'text')
+        element = identity.toElement()
+        self.assertEqual(NS_DISCO_INFO, element.uri)
+        self.assertEqual(u'identity', element.name)
+        self.assertEqual(u'conference', element.getAttribute(u'category'))
+        self.assertEqual(u'text', element.getAttribute(u'type'))
+        self.assertFalse(element.hasAttribute(u'name'))
+
+
+    def test_fromElement(self):
+        """
+        Test creating L{disco.DiscoIdentity} from L{domish.Element}.
+        """
+        element = domish.Element((NS_DISCO_INFO, u'identity'))
+        element['category'] = u'conference'
+        element['type'] = u'text'
+        element['name'] = u'The chatroom'
+        identity = disco.DiscoIdentity.fromElement(element)
+        self.assertEqual(u'conference', identity.category)
+        self.assertEqual(u'text', identity.type)
+        self.assertEqual(u'The chatroom', identity.name)
+
+
+    def test_fromElementWithoutName(self):
+        """
+        Test creating L{disco.DiscoIdentity} from L{domish.Element}, no name.
+        """
+        element = domish.Element((NS_DISCO_INFO, u'identity'))
+        element['category'] = u'conference'
+        element['type'] = u'text'
+        identity = disco.DiscoIdentity.fromElement(element)
+        self.assertEqual(u'conference', identity.category)
+        self.assertEqual(u'text', identity.type)
+        self.assertEqual(None, identity.name)
+
+
+
+class DiscoInfoTest(unittest.TestCase):
+    """
+    Tests for L{disco.DiscoInfo}.
+    """
+
+    def test_toElement(self):
+        """
+        Test C{toElement} creates a correctly namespaced element, no node.
+        """
+        info = disco.DiscoInfo()
+        element = info.toElement()
+
+        self.assertEqual(NS_DISCO_INFO, element.uri)
+        self.assertEqual(u'query', element.name)
+        self.assertFalse(element.hasAttribute(u'node'))
+
+
+    def test_toElementNode(self):
+        """
+        Test C{toElement} with a node.
+        """
+        info = disco.DiscoInfo()
+        info.nodeIdentifier = u'test'
+        element = info.toElement()
+
+        self.assertEqual(u'test', element.getAttribute(u'node'))
+
+
+    def test_toElementChildren(self):
+        """
+        Test C{toElement} creates a DOM with proper childs.
+        """
+        info = disco.DiscoInfo()
+        info.append(disco.DiscoFeature(u'jabber:iq:register'))
+        info.append(disco.DiscoIdentity(u'conference', u'text'))
+        info.append(data_form.Form(u'result'))
+        element = info.toElement()
+
+        featureElements = domish.generateElementsQNamed(element.children,
+                                                        u'feature',
+                                                        NS_DISCO_INFO)
+        self.assertEqual(1, len(list(featureElements)))
+
+        identityElements = domish.generateElementsQNamed(element.children,
+                                                         u'identity',
+                                                         NS_DISCO_INFO)
+        self.assertEqual(1, len(list(identityElements)))
+
+        extensionElements = domish.generateElementsQNamed(element.children,
+                                                         u'x',
+                                                         data_form.NS_X_DATA)
+        self.assertEqual(1, len(list(extensionElements)))
+
+
+    def test_fromElement(self):
+        """
+        Test properties when creating L{disco.DiscoInfo} from L{domish.Element}.
+        """
+        xml = """<query xmlns='http://jabber.org/protocol/disco#info'>
+                   <identity category='conference'
+                             type='text'
+                             name='A Dark Cave'/>
+                   <feature var='http://jabber.org/protocol/muc'/>
+                   <feature var='jabber:iq:register'/>
+                   <x xmlns='jabber:x:data' type='result'>
+                     <field var='FORM_TYPE' type='hidden'>
+                       <value>http://jabber.org/protocol/muc#roominfo</value>
+                     </field>
+                   </x>
+                 </query>"""
+
+        element = parseXml(xml)
+        info = disco.DiscoInfo.fromElement(element)
+
+        self.assertIn(u'http://jabber.org/protocol/muc', info.features)
+        self.assertIn(u'jabber:iq:register', info.features)
+
+        self.assertIn((u'conference', u'text'), info.identities)
+        self.assertEqual(u'A Dark Cave',
+                          info.identities[(u'conference', u'text')])
+
+        self.assertIn(u'http://jabber.org/protocol/muc#roominfo',
+                      info.extensions)
+
+
+    def test_fromElementItems(self):
+        """
+        Test items when creating L{disco.DiscoInfo} from L{domish.Element}.
+        """
+        xml = """<query xmlns='http://jabber.org/protocol/disco#info'>
+                   <identity category='conference'
+                             type='text'
+                             name='A Dark Cave'/>
+                   <feature var='http://jabber.org/protocol/muc'/>
+                   <feature var='jabber:iq:register'/>
+                   <x xmlns='jabber:x:data' type='result'>
+                     <field var='FORM_TYPE' type='hidden'>
+                       <value>http://jabber.org/protocol/muc#roominfo</value>
+                     </field>
+                   </x>
+                 </query>"""
+
+        element = parseXml(xml)
+        info = disco.DiscoInfo.fromElement(element)
+
+        info = list(info)
+        self.assertEqual(4, len(info))
+
+        identity = info[0]
+        self.assertEqual(u'conference', identity.category)
+
+        self.assertEqual(u'http://jabber.org/protocol/muc', info[1])
+        self.assertEqual(u'jabber:iq:register', info[2])
+
+        extension = info[3]
+        self.assertEqual(u'http://jabber.org/protocol/muc#roominfo',
+                         extension.formNamespace)
+
+
+    def test_fromElementNoNode(self):
+        """
+        Test creating L{disco.DiscoInfo} from L{domish.Element}, no node.
+        """
+        xml = """<query xmlns='http://jabber.org/protocol/disco#info'/>"""
+
+        element = parseXml(xml)
+        info = disco.DiscoInfo.fromElement(element)
+
+        self.assertEqual(u'', info.nodeIdentifier)
+
+
+    def test_fromElementNode(self):
+        """
+        Test creating L{disco.DiscoInfo} from L{domish.Element}, with node.
+        """
+        xml = """<query xmlns='http://jabber.org/protocol/disco#info'
+                        node='test'>
+                 </query>"""
+
+        element = parseXml(xml)
+        info = disco.DiscoInfo.fromElement(element)
+
+        self.assertEqual(u'test', info.nodeIdentifier)
+
+
+
+class DiscoItemTest(unittest.TestCase):
+    """
+    Tests for L{disco.DiscoItem}.
+    """
+
+    def test_init(self):
+        """
+        Test initialization with a category, type and name.
+        """
+        item = disco.DiscoItem(JID(u'example.org'), u'test', u'The node')
+        self.assertEqual(JID(u'example.org'), item.entity)
+        self.assertEqual(u'test', item.nodeIdentifier)
+        self.assertEqual(u'The node', item.name)
+
+
+    def test_toElement(self):
+        """
+        Test proper rendering to a DOM representation.
+
+        The returned element should be properly named and have C{jid}, C{node},
+        and C{name} attributes.
+        """
+        item = disco.DiscoItem(JID(u'example.org'), u'test', u'The node')
+        element = item.toElement()
+        self.assertEqual(NS_DISCO_ITEMS, element.uri)
+        self.assertEqual(u'item', element.name)
+        self.assertEqual(u'example.org', element.getAttribute(u'jid'))
+        self.assertEqual(u'test', element.getAttribute(u'node'))
+        self.assertEqual(u'The node', element.getAttribute(u'name'))
+
+
+    def test_toElementWithoutName(self):
+        """
+        Test proper rendering to a DOM representation without a name.
+
+        The returned element should be properly named and have C{jid}, C{node}
+        attributes, no C{name} attribute.
+        """
+        item = disco.DiscoItem(JID(u'example.org'), u'test')
+        element = item.toElement()
+        self.assertEqual(NS_DISCO_ITEMS, element.uri)
+        self.assertEqual(u'item', element.name)
+        self.assertEqual(u'example.org', element.getAttribute(u'jid'))
+        self.assertEqual(u'test', element.getAttribute(u'node'))
+        self.assertFalse(element.hasAttribute(u'name'))
+
+
+    def test_fromElement(self):
+        """
+        Test creating L{disco.DiscoItem} from L{domish.Element}.
+        """
+        element = domish.Element((NS_DISCO_ITEMS, u'item'))
+        element[u'jid'] = u'example.org'
+        element[u'node'] = u'test'
+        element[u'name'] = u'The node'
+        item = disco.DiscoItem.fromElement(element)
+        self.assertEqual(JID(u'example.org'), item.entity)
+        self.assertEqual(u'test', item.nodeIdentifier)
+        self.assertEqual(u'The node', item.name)
+
+    def test_fromElementNoNode(self):
+        """
+        Test creating L{disco.DiscoItem} from L{domish.Element}, no node.
+        """
+        element = domish.Element((NS_DISCO_ITEMS, u'item'))
+        element[u'jid'] = u'example.org'
+        element[u'name'] = u'The node'
+        item = disco.DiscoItem.fromElement(element)
+        self.assertEqual(JID(u'example.org'), item.entity)
+        self.assertEqual(u'', item.nodeIdentifier)
+        self.assertEqual(u'The node', item.name)
+
+
+    def test_fromElementNoName(self):
+        """
+        Test creating L{disco.DiscoItem} from L{domish.Element}, no name.
+        """
+        element = domish.Element((NS_DISCO_ITEMS, u'item'))
+        element[u'jid'] = u'example.org'
+        element[u'node'] = u'test'
+        item = disco.DiscoItem.fromElement(element)
+        self.assertEqual(JID(u'example.org'), item.entity)
+        self.assertEqual(u'test', item.nodeIdentifier)
+        self.assertEqual(None, item.name)
+
+    def test_fromElementBadJID(self):
+        """
+        Test creating L{disco.DiscoItem} from L{domish.Element}, bad JID.
+        """
+        element = domish.Element((NS_DISCO_ITEMS, u'item'))
+        element[u'jid'] = u'ex@@@ample.org'
+        item = disco.DiscoItem.fromElement(element)
+        self.assertIdentical(None, item.entity)
+
+
+
+class DiscoItemsTest(unittest.TestCase):
+    """
+    Tests for L{disco.DiscoItems}.
+    """
+
+    def test_toElement(self):
+        """
+        Test C{toElement} creates a correctly namespaced element, no node.
+        """
+        items = disco.DiscoItems()
+        element = items.toElement()
+
+        self.assertEqual(NS_DISCO_ITEMS, element.uri)
+        self.assertEqual(u'query', element.name)
+        self.assertFalse(element.hasAttribute(u'node'))
+
+
+    def test_toElementNode(self):
+        """
+        Test C{toElement} with a node.
+        """
+        items = disco.DiscoItems()
+        items.nodeIdentifier = u'test'
+        element = items.toElement()
+
+        self.assertEqual(u'test', element.getAttribute(u'node'))
+
+
+    def test_toElementChildren(self):
+        """
+        Test C{toElement} creates a DOM with proper childs.
+        """
+        items = disco.DiscoItems()
+        items.append(disco.DiscoItem(JID(u'example.org'), u'test', u'A node'))
+        element = items.toElement()
+
+        itemElements = domish.generateElementsQNamed(element.children,
+                                                     u'item',
+                                                     NS_DISCO_ITEMS)
+        self.assertEqual(1, len(list(itemElements)))
+
+
+    def test_fromElement(self):
+        """
+        Test creating L{disco.DiscoItems} from L{domish.Element}.
+        """
+        xml = """<query xmlns='http://jabber.org/protocol/disco#items'>
+                   <item jid='example.org' node='test' name='A node'/>
+                 </query>"""
+
+        element = parseXml(xml)
+        items = disco.DiscoItems.fromElement(element)
+
+        items = list(items)
+        self.assertEqual(1, len(items))
+        item = items[0]
+
+        self.assertEqual(JID(u'example.org'), item.entity)
+        self.assertEqual(u'test', item.nodeIdentifier)
+        self.assertEqual(u'A node', item.name)
+
+
+    def test_fromElementNoNode(self):
+        """
+        Test creating L{disco.DiscoItems} from L{domish.Element}, no node.
+        """
+        xml = """<query xmlns='http://jabber.org/protocol/disco#items'/>"""
+
+        element = parseXml(xml)
+        items = disco.DiscoItems.fromElement(element)
+
+        self.assertEqual(u'', items.nodeIdentifier)
+
+
+    def test_fromElementNode(self):
+        """
+        Test creating L{disco.DiscoItems} from L{domish.Element}, with node.
+        """
+        xml = """<query xmlns='http://jabber.org/protocol/disco#items'
+                        node='test'>
+                 </query>"""
+
+        element = parseXml(xml)
+        items = disco.DiscoItems.fromElement(element)
+
+        self.assertEqual(u'test', items.nodeIdentifier)
+
+
+
+class DiscoClientProtocolTest(unittest.TestCase):
+    """
+    Tests for L{disco.DiscoClientProtocol}.
+    """
+
+    def setUp(self):
+        """
+        Set up stub and protocol for testing.
+        """
+        self.stub = XmlStreamStub()
+        self.protocol = disco.DiscoClientProtocol()
+        self.protocol.xmlstream = self.stub.xmlstream
+        self.protocol.connectionInitialized()
+
+
+    def test_requestItems(self):
+        """
+        Test request sent out by C{requestItems} and parsing of response.
+        """
+        def cb(items):
+            items = list(items)
+            self.assertEqual(2, len(items))
+            self.assertEqual(JID(u'test.example.org'), items[0].entity)
+
+        d = self.protocol.requestItems(JID(u'example.org'),u"foo")
+        d.addCallback(cb)
+
+        iq = self.stub.output[-1]
+        self.assertEqual(u'example.org', iq.getAttribute(u'to'))
+        self.assertEqual(u'get', iq.getAttribute(u'type'))
+        self.assertEqual(u'foo', iq.query.getAttribute(u'node'))
+        self.assertEqual(NS_DISCO_ITEMS, iq.query.uri)
+
+        response = toResponse(iq, u'result')
+        query = response.addElement((NS_DISCO_ITEMS, u'query'))
+
+        element = query.addElement(u'item')
+        element[u'jid'] = u'test.example.org'
+        element[u'node'] = u'music'
+        element[u'name'] = u'Music from the time of Shakespeare'
+
+        element = query.addElement(u'item')
+        element[u'jid'] = u"test2.example.org"
+
+        self.stub.send(response)
+        return d
+
+
+    def test_requestInfo(self):
+        """
+        Test request sent out by C{requestInfo} and parsing of response.
+        """
+        def cb(info):
+            self.assertIn((u'conference', u'text'), info.identities)
+            self.assertIn(u'http://jabber.org/protocol/disco#info',
+                          info.features)
+            self.assertIn(u'http://jabber.org/protocol/muc',
+                          info.features)
+
+        d = self.protocol.requestInfo(JID(u'example.org'),'foo')
+        d.addCallback(cb)
+
+        iq = self.stub.output[-1]
+        self.assertEqual(u'example.org', iq.getAttribute(u'to'))
+        self.assertEqual(u'get', iq.getAttribute(u'type'))
+        self.assertEqual(u'foo', iq.query.getAttribute(u'node'))
+        self.assertEqual(NS_DISCO_INFO, iq.query.uri)
+
+        response = toResponse(iq, u'result')
+        query = response.addElement((NS_DISCO_INFO, u'query'))
+
+        element = query.addElement(u"identity")
+        element[u'category'] = u'conference' # required
+        element[u'type'] = u'text' # required
+        element[u"name"] = u'Romeo and Juliet, Act II, Scene II' # optional
+
+        element = query.addElement("feature")
+        element[u'var'] = u'http://jabber.org/protocol/disco#info' # required
+
+        element = query.addElement(u"feature")
+        element[u'var'] = u'http://jabber.org/protocol/muc'
+
+        self.stub.send(response)
+        return d
+
+
+
+class DiscoHandlerTest(unittest.TestCase, TestableRequestHandlerMixin):
+    """
+    Tests for L{disco.DiscoHandler}.
+    """
+
+    def setUp(self):
+        self.service = disco.DiscoHandler()
+
+
+    def test_onDiscoInfo(self):
+        """
+        C{onDiscoInfo} should process an info request and return a response.
+
+        The request should be parsed, C{info} called with the extracted
+        parameters, and then the result should be formatted into a proper
+        response element.
+        """
+        xml = """<iq from='test@example.com' to='example.com'
+                     type='get'>
+                   <query xmlns='%s'/>
+                 </iq>""" % NS_DISCO_INFO
+
+        def cb(element):
+            self.assertEqual('query', element.name)
+            self.assertEqual(NS_DISCO_INFO, element.uri)
+            self.assertEqual(NS_DISCO_INFO, element.identity.uri)
+            self.assertEqual('dummy', element.identity['category'])
+            self.assertEqual('generic', element.identity['type'])
+            self.assertEqual('Generic Dummy Entity', element.identity['name'])
+            self.assertEqual(NS_DISCO_INFO, element.feature.uri)
+            self.assertEqual('jabber:iq:version', element.feature['var'])
+
+        def info(requestor, target, nodeIdentifier):
+            self.assertEqual(JID('test@example.com'), requestor)
+            self.assertEqual(JID('example.com'), target)
+            self.assertEqual('', nodeIdentifier)
+
             return defer.succeed([
                 disco.DiscoIdentity('dummy', 'generic', 'Generic Dummy Entity'),
                 disco.DiscoFeature('jabber:iq:version')
             ])
-        else:
-            return defer.succeed([])
-
-class DiscoHandlerTest(unittest.TestCase):
-    def test_DiscoInfo(self):
-        factory = XmlStreamFactory()
-        sm = StreamManager(factory)
-        disco.DiscoHandler().setHandlerParent(sm)
-        DiscoResponder().setHandlerParent(sm)
-        xs = factory.buildProtocol(None)
-        output = []
-        xs.send = output.append
-        xs.connectionMade()
-        xs.dispatch(xs, "//event/stream/authd")
-        xs.dataReceived("<stream>")
-        xs.dataReceived("""<iq from='test@example.com' to='example.com'
-                               type='get'>
-                             <query xmlns='%s'/>
-                           </iq>""" % NS_DISCO_INFO)
-        reply = output[0]
-        self.assertEqual(NS_DISCO_INFO, reply.query.uri)
-        self.assertEqual(NS_DISCO_INFO, reply.query.identity.uri)
-        self.assertEqual('dummy', reply.query.identity['category'])
-        self.assertEqual('generic', reply.query.identity['type'])
-        self.assertEqual('Generic Dummy Entity', reply.query.identity['name'])
-        self.assertEqual(NS_DISCO_INFO, reply.query.feature.uri)
-        self.assertEqual('jabber:iq:version', reply.query.feature['var'])
-
+
+        self.service.info = info
+        d = self.handleRequest(xml)
+        d.addCallback(cb)
+        return d
+
+
+    def test_onDiscoInfoWithNode(self):
+        """
+        An info request for a node should return it in the response.
+        """
+        xml = """<iq from='test@example.com' to='example.com'
+                     type='get'>
+                   <query xmlns='%s' node='test'/>
+                 </iq>""" % NS_DISCO_INFO
+
+        def cb(element):
+            self.assertTrue(element.hasAttribute('node'))
+            self.assertEqual('test', element['node'])
+
+        def info(requestor, target, nodeIdentifier):
+            self.assertEqual('test', nodeIdentifier)
+
+            return defer.succeed([
+                disco.DiscoFeature('jabber:iq:version')
+            ])
+
+        self.service.info = info
+        d = self.handleRequest(xml)
+        d.addCallback(cb)
+        return d
+
+
+    def test_onDiscoItems(self):
+        """
+        C{onDiscoItems} should process an items request and return a response.
+
+        The request should be parsed, C{items} called with the extracted
+        parameters, and then the result should be formatted into a proper
+        response element.
+        """
+        xml = """<iq from='test@example.com' to='example.com'
+                     type='get'>
+                   <query xmlns='%s'/>
+                 </iq>""" % NS_DISCO_ITEMS
+
+        def cb(element):
+            self.assertEqual('query', element.name)
+            self.assertEqual(NS_DISCO_ITEMS, element.uri)
+            self.assertEqual(NS_DISCO_ITEMS, element.item.uri)
+            self.assertEqual('example.com', element.item['jid'])
+            self.assertEqual('test', element.item['node'])
+            self.assertEqual('Test node', element.item['name'])
+
+        def items(requestor, target, nodeIdentifier):
+            self.assertEqual(JID('test@example.com'), requestor)
+            self.assertEqual(JID('example.com'), target)
+            self.assertEqual('', nodeIdentifier)
+
+            return defer.succeed([
+                disco.DiscoItem(JID('example.com'), 'test', 'Test node'),
+            ])
+
+        self.service.items = items
+        d = self.handleRequest(xml)
+        d.addCallback(cb)
+        return d
+
+
+    def test_onDiscoItemsWithNode(self):
+        """
+        An items request for a node should return it in the response.
+        """
+        xml = """<iq from='test@example.com' to='example.com'
+                     type='get'>
+                   <query xmlns='%s' node='test'/>
+                 </iq>""" % NS_DISCO_ITEMS
+
+        def cb(element):
+            self.assertTrue(element.hasAttribute('node'))
+            self.assertEqual('test', element['node'])
+
+        def items(requestor, target, nodeIdentifier):
+            self.assertEqual('test', nodeIdentifier)
+
+            return defer.succeed([
+                disco.DiscoFeature('jabber:iq:version')
+            ])
+
+        self.service.items = items
+        d = self.handleRequest(xml)
+        d.addCallback(cb)
+        return d
+
+
+    def test_info(self):
+        """
+        C{info} should gather disco info from sibling handlers.
+        """
+        discoItems = [disco.DiscoIdentity('dummy', 'generic',
+                                          'Generic Dummy Entity'),
+                      disco.DiscoFeature('jabber:iq:version')
+        ]
+
+        class DiscoResponder(XMPPHandler):
+            implements(disco.IDisco)
+
+            def getDiscoInfo(self, requestor, target, nodeIdentifier):
+                if not nodeIdentifier:
+                    return defer.succeed(discoItems)
+                else:
+                    return defer.succeed([])
+
+        def cb(result):
+            self.assertEquals(discoItems, result)
+
+        self.service.parent = [self.service, DiscoResponder()]
+        d = self.service.info(JID('test@example.com'), JID('example.com'), '')
+        d.addCallback(cb)
+        return d
+
+
+    def test_items(self):
+        """
+        C{info} should gather disco items from sibling handlers.
+        """
+        discoItems = [disco.DiscoItem(JID('example.com'), 'test', 'Test node')]
+
+        class DiscoResponder(XMPPHandler):
+            implements(disco.IDisco)
+
+            def getDiscoItems(self, requestor, target, nodeIdentifier):
+                if not nodeIdentifier:
+                    return defer.succeed(discoItems)
+                else:
+                    return defer.succeed([])
+
+        def cb(result):
+            self.assertEquals(discoItems, result)
+
+        self.service.parent = [self.service, DiscoResponder()]
+        d = self.service.items(JID('test@example.com'), JID('example.com'), '')
+        d.addCallback(cb)
+        return d

wokkel/test/test_generic.py

@@ -49 +49 @@
         self.assertEquals(1, len(elements))
         self.assertEquals('0.1.0', unicode(elements[0]))
+
+
+
+class XmlPipeTest(unittest.TestCase):
+    """
+    Tests for L{wokkel.generic.XmlPipe}.
+    """
+
+    def setUp(self):
+        self.pipe = generic.XmlPipe()
+
+
+    def test_sendFromSource(self):
+        """
+        Send an element from the source and observe it from the sink.
+        """
+        def cb(obj):
+            called.append(obj)
+
+        called = []
+        self.pipe.sink.addObserver('/test[@xmlns="testns"]', cb)
+        element = domish.Element(('testns', 'test'))
+        self.pipe.source.send(element)
+        self.assertEquals([element], called)
+
+
+    def test_sendFromSink(self):
+        """
+        Send an element from the sink and observe it from the source.
+        """
+        def cb(obj):
+            called.append(obj)
+
+        called = []
+        self.pipe.source.addObserver('/test[@xmlns="testns"]', cb)
+        element = domish.Element(('testns', 'test'))
+        self.pipe.sink.send(element)
+        self.assertEquals([element], called)

wokkel/test/test_pubsub.py

@@ -1 @@
-# Copyright (c) 2003-2008 Ralph Meijer
+# Copyright (c) 2003-2009 Ralph Meijer
 # See LICENSE for details.
 
@@ -10 +10 @@
 from twisted.trial import unittest
 from twisted.internet import defer
-from twisted.words.xish import domish, xpath
+from twisted.words.xish import domish
 from twisted.words.protocols.jabber import error
 from twisted.words.protocols.jabber.jid import JID
-
-from wokkel import data_form, iwokkel, pubsub, shim
+from twisted.words.protocols.jabber.xmlstream import toResponse
+
+from wokkel import data_form, disco, iwokkel, pubsub, shim
 from wokkel.generic import parseXml
-from wokkel.test.helpers import XmlStreamStub
-
-try:
-    from twisted.words.protocols.jabber.xmlstream import toResponse
-except ImportError:
-    from wokkel.compat import toResponse
+from wokkel.test.helpers import TestableRequestHandlerMixin, XmlStreamStub
 
 NS_PUBSUB = 'http://jabber.org/protocol/pubsub'
@@ -28 +24 @@
 NS_PUBSUB_EVENT = 'http://jabber.org/protocol/pubsub#event'
 NS_PUBSUB_OWNER = 'http://jabber.org/protocol/pubsub#owner'
+NS_PUBSUB_META_DATA = 'http://jabber.org/protocol/pubsub#meta-data'
 
 def calledAsync(fn):
@@ -116 +113 @@
 
 
-    def test_event_delete(self):
+    def test_eventDelete(self):
         """
         Test receiving a delete event resulting in a call to deleteReceived.
@@ -124 +121 @@
         message['to'] = 'user@example.org/home'
         event = message.addElement((NS_PUBSUB_EVENT, 'event'))
-        items = event.addElement('delete')
-        items['node'] = 'test'
+        delete = event.addElement('delete')
+        delete['node'] = 'test'
 
         def deleteReceived(event):
@@ -131 +128 @@
             self.assertEquals(JID('pubsub.example.org'), event.sender)
             self.assertEquals('test', event.nodeIdentifier)
+
+        d, self.protocol.deleteReceived = calledAsync(deleteReceived)
+        self.stub.send(message)
+        return d
+
+
+    def test_eventDeleteRedirect(self):
+        """
+        Test receiving a delete event with a redirect URI.
+        """
+        message = domish.Element((None, 'message'))
+        message['from'] = 'pubsub.example.org'
+        message['to'] = 'user@example.org/home'
+        event = message.addElement((NS_PUBSUB_EVENT, 'event'))
+        delete = event.addElement('delete')
+        delete['node'] = 'test'
+        uri = 'xmpp:pubsub.example.org?;node=test2'
+        delete.addElement('redirect')['uri'] = uri
+
+        def deleteReceived(event):
+            self.assertEquals(JID('user@example.org/home'), event.recipient)
+            self.assertEquals(JID('pubsub.example.org'), event.sender)
+            self.assertEquals('test', event.nodeIdentifier)
+            self.assertEquals(uri, event.redirectURI)
 
         d, self.protocol.deleteReceived = calledAsync(deleteReceived)
@@ -235 +256 @@
 
 
+    def test_createNodeWithSender(self):
+        """
+        Test sending create request from a specific JID.
+        """
+
+        d = self.protocol.createNode(JID('pubsub.example.org'), 'test',
+                                     sender=JID('user@example.org'))
+
+        iq = self.stub.output[-1]
+        self.assertEquals('user@example.org', iq['from'])
+
+        response = toResponse(iq, 'result')
+        self.stub.send(response)
+        return d
+
+
     def test_deleteNode(self):
         """
@@ -246 +283 @@
         self.assertEquals('set', iq.getAttribute('type'))
         self.assertEquals('pubsub', iq.pubsub.name)
-        self.assertEquals(NS_PUBSUB, iq.pubsub.uri)
+        self.assertEquals(NS_PUBSUB_OWNER, iq.pubsub.uri)
         children = list(domish.generateElementsQNamed(iq.pubsub.children,
-                                                      'delete', NS_PUBSUB))
+                                                      'delete', NS_PUBSUB_OWNER))
         self.assertEquals(1, len(children))
         child = children[0]
         self.assertEquals('test', child['node'])
+
+        response = toResponse(iq, 'result')
+        self.stub.send(response)
+        return d
+
+
+    def test_deleteNodeWithSender(self):
+        """
+        Test sending delete request.
+        """
+
+        d = self.protocol.deleteNode(JID('pubsub.example.org'), 'test',
+                                     sender=JID('user@example.org'))
+
+        iq = self.stub.output[-1]
+        self.assertEquals('user@example.org', iq['from'])
 
         response = toResponse(iq, 'result')
@@ -309 +362 @@
 
 
+    def test_publishWithSender(self):
+        """
+        Test sending publish request from a specific JID.
+        """
+
+        item = pubsub.Item()
+        d = self.protocol.publish(JID('pubsub.example.org'), 'test', [item],
+                                  JID('user@example.org'))
+
+        iq = self.stub.output[-1]
+        self.assertEquals('user@example.org', iq['from'])
+
+        response = toResponse(iq, 'result')
+        self.stub.send(response)
+        return d
+
+
     def test_subscribe(self):
         """
@@ -378 +448 @@
 
 
+    def test_subscribeWithSender(self):
+        """
+        Test sending subscription request from a specific JID.
+        """
+        d = self.protocol.subscribe(JID('pubsub.example.org'), 'test',
+                                      JID('user@example.org'),
+                                      sender=JID('user@example.org'))
+
+        iq = self.stub.output[-1]
+        self.assertEquals('user@example.org', iq['from'])
+
+        response = toResponse(iq, 'result')
+        pubsub = response.addElement((NS_PUBSUB, 'pubsub'))
+        subscription = pubsub.addElement('subscription')
+        subscription['node'] = 'test'
+        subscription['jid'] = 'user@example.org'
+        subscription['subscription'] = 'subscribed'
+        self.stub.send(response)
+        return d
+
+
     def test_unsubscribe(self):
         """
@@ -401 +492 @@
 
 
+    def test_unsubscribeWithSender(self):
+        """
+        Test sending unsubscription request from a specific JID.
+        """
+        d = self.protocol.unsubscribe(JID('pubsub.example.org'), 'test',
+                                      JID('user@example.org'),
+                                      sender=JID('user@example.org'))
+
+        iq = self.stub.output[-1]
+        self.assertEquals('user@example.org', iq['from'])
+        self.stub.send(toResponse(iq, 'result'))
+        return d
+
+
     def test_items(self):
         """
@@ -467 +572 @@
 
 
-
-class PubSubServiceTest(unittest.TestCase):
-    """
-    Tests for L{pubsub.PubSubService}.
-    """
-
-    def setUp(self):
-        self.service = pubsub.PubSubService()
-
-    def handleRequest(self, xml):
-        """
-        Find a handler and call it directly
-        """
-        handler = None
-        iq = parseXml(xml)
-        for queryString, method in self.service.iqHandlers.iteritems():
-            if xpath.internQuery(queryString).matches(iq):
-                handler = getattr(self.service, method)
-
-        if handler:
-            d = defer.maybeDeferred(handler, iq)
-        else:
-            d = defer.fail(NotImplementedError())
-
-        return d
-
-
-    def test_interface(self):
-        """
-        Do instances of L{pubsub.PubSubService} provide L{iwokkel.IPubSubService}?
-        """
-        verify.verifyObject(iwokkel.IPubSubService, self.service)
-
-
-    def test_onPublishNoNode(self):
-        """
-        The root node is always a collection, publishing is a bad request.
+    def test_itemsWithSender(self):
+        """
+        Test sending items request from a specific JID.
+        """
+
+        d = self.protocol.items(JID('pubsub.example.org'), 'test',
+                               sender=JID('user@example.org'))
+
+        iq = self.stub.output[-1]
+        self.assertEquals('user@example.org', iq['from'])
+
+        response = toResponse(iq, 'result')
+        items = response.addElement((NS_PUBSUB, 'pubsub')).addElement('items')
+        items['node'] = 'test'
+
+        self.stub.send(response)
+        return d
+
+
+
+class PubSubRequestTest(unittest.TestCase):
+
+    def test_fromElementPublish(self):
+        """
+        Test parsing a publish request.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <publish node='test'/>
+          </pubsub>
+        </iq>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual('publish', request.verb)
+        self.assertEqual(JID('user@example.org'), request.sender)
+        self.assertEqual(JID('pubsub.example.org'), request.recipient)
+        self.assertEqual('test', request.nodeIdentifier)
+        self.assertEqual([], request.items)
+
+
+    def test_fromElementPublishItems(self):
+        """
+        Test parsing a publish request with items.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <publish node='test'>
+              <item id="item1"/>
+              <item id="item2"/>
+            </publish>
+          </pubsub>
+        </iq>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual(2, len(request.items))
+        self.assertEqual(u'item1', request.items[0]["id"])
+        self.assertEqual(u'item2', request.items[1]["id"])
+
+
+    def test_fromElementPublishNoNode(self):
+        """
+        A publish request to the root node should raise an exception.
         """
         xml = """
@@ -514 +652 @@
         """
 
-        def cb(result):
-            self.assertEquals('bad-request', result.condition)
-
-        d = self.handleRequest(xml)
-        self.assertFailure(d, error.StanzaError)
-        d.addCallback(cb)
-        return d
-
-
-    def test_onPublish(self):
-        """
-        A publish request should result in L{PubSubService.publish} being
-        called.
-        """
-
-        xml = """
-        <iq type='set' to='pubsub.example.org'
-                       from='user@example.org'>
-          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
-            <publish node='test'/>
-          </pubsub>
-        </iq>
-        """
-
-        def publish(requestor, service, nodeIdentifier, items):
-            self.assertEqual(JID('user@example.org'), requestor)
-            self.assertEqual(JID('pubsub.example.org'), service)
-            self.assertEqual('test', nodeIdentifier)
-            self.assertEqual([], items)
-            return defer.succeed(None)
-
-        self.service.publish = publish
-        return self.handleRequest(xml)
-
-
-    def test_onOptionsGet(self):
-        """
-        Subscription options are not supported.
+        err = self.assertRaises(error.StanzaError,
+                                pubsub.PubSubRequest.fromElement,
+                                parseXml(xml))
+        self.assertEqual('bad-request', err.condition)
+        self.assertEqual(NS_PUBSUB_ERRORS, err.appCondition.uri)
+        self.assertEqual('nodeid-required', err.appCondition.name)
+
+
+    def test_fromElementSubscribe(self):
+        """
+        Test parsing a subscription request.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <subscribe node='test' jid='user@example.org/Home'/>
+          </pubsub>
+        </iq>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual('subscribe', request.verb)
+        self.assertEqual(JID('user@example.org'), request.sender)
+        self.assertEqual(JID('pubsub.example.org'), request.recipient)
+        self.assertEqual('test', request.nodeIdentifier)
+        self.assertEqual(JID('user@example.org/Home'), request.subscriber)
+
+
+    def test_fromElementSubscribeEmptyNode(self):
+        """
+        Test parsing a subscription request to the root node.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <subscribe jid='user@example.org/Home'/>
+          </pubsub>
+        </iq>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual('', request.nodeIdentifier)
+
+
+    def test_fromElementSubscribeNoJID(self):
+        """
+        Subscribe requests without a JID should raise a bad-request exception.
+        """
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <subscribe node='test'/>
+          </pubsub>
+        </iq>
+        """
+        err = self.assertRaises(error.StanzaError,
+                                pubsub.PubSubRequest.fromElement,
+                                parseXml(xml))
+        self.assertEqual('bad-request', err.condition)
+        self.assertEqual(NS_PUBSUB_ERRORS, err.appCondition.uri)
+        self.assertEqual('jid-required', err.appCondition.name)
+
+    def test_fromElementUnsubscribe(self):
+        """
+        Test parsing an unsubscription request.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <unsubscribe node='test' jid='user@example.org/Home'/>
+          </pubsub>
+        </iq>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual('unsubscribe', request.verb)
+        self.assertEqual(JID('user@example.org'), request.sender)
+        self.assertEqual(JID('pubsub.example.org'), request.recipient)
+        self.assertEqual('test', request.nodeIdentifier)
+        self.assertEqual(JID('user@example.org/Home'), request.subscriber)
+
+
+    def test_fromElementUnsubscribeNoJID(self):
+        """
+        Unsubscribe requests without a JID should raise a bad-request exception.
+        """
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <unsubscribe node='test'/>
+          </pubsub>
+        </iq>
+        """
+        err = self.assertRaises(error.StanzaError,
+                                pubsub.PubSubRequest.fromElement,
+                                parseXml(xml))
+        self.assertEqual('bad-request', err.condition)
+        self.assertEqual(NS_PUBSUB_ERRORS, err.appCondition.uri)
+        self.assertEqual('jid-required', err.appCondition.name)
+
+
+    def test_fromElementOptionsGet(self):
+        """
+        Test parsing a request for getting subscription options.
         """
 
@@ -558 +770 @@
                        from='user@example.org'>
           <pubsub xmlns='http://jabber.org/protocol/pubsub'>
-            <options/>
-          </pubsub>
-        </iq>
-        """
-
-        def cb(result):
-            self.assertEquals('feature-not-implemented', result.condition)
-            self.assertEquals('unsupported', result.appCondition.name)
-            self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
-
-        d = self.handleRequest(xml)
-        self.assertFailure(d, error.StanzaError)
-        d.addCallback(cb)
-        return d
-
-
-    def test_onDefault(self):
-        """
-        A default request should result in
-        L{PubSubService.getDefaultConfiguration} being called.
+            <options node='test' jid='user@example.org/Home'/>
+          </pubsub>
+        </iq>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual('optionsGet', request.verb)
+
+
+    def test_fromElementOptionsSet(self):
+        """
+        Test parsing a request for setting subscription options.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <options node='test' jid='user@example.org/Home'>
+              <x xmlns='jabber:x:data' type='submit'>
+                <field var='FORM_TYPE' type='hidden'>
+                  <value>http://jabber.org/protocol/pubsub#subscribe_options</value>
+                </field>
+                <field var='pubsub#deliver'><value>1</value></field>
+              </x>
+            </options>
+          </pubsub>
+        </iq>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual('optionsSet', request.verb)
+        self.assertEqual(JID('user@example.org'), request.sender)
+        self.assertEqual(JID('pubsub.example.org'), request.recipient)
+        self.assertEqual('test', request.nodeIdentifier)
+        self.assertEqual(JID('user@example.org/Home'), request.subscriber)
+        self.assertEqual({'pubsub#deliver': '1'}, request.options)
+
+
+    def test_fromElementOptionsSetCancel(self):
+        """
+        Test parsing a request for cancelling setting subscription options.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <options node='test' jid='user@example.org/Home'>
+              <x xmlns='jabber:x:data' type='cancel'/>
+            </options>
+          </pubsub>
+        </iq>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual({}, request.options)
+
+
+    def test_fromElementOptionsSetBadFormType(self):
+        """
+        On a options set request unknown fields should be ignored.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <options node='test' jid='user@example.org/Home'>
+              <x xmlns='jabber:x:data' type='result'>
+                <field var='FORM_TYPE' type='hidden'>
+                  <value>http://jabber.org/protocol/pubsub#node_config</value>
+                </field>
+                <field var='pubsub#deliver'><value>1</value></field>
+              </x>
+            </options>
+          </pubsub>
+        </iq>
+        """
+
+        err = self.assertRaises(error.StanzaError,
+                                pubsub.PubSubRequest.fromElement,
+                                parseXml(xml))
+        self.assertEqual('bad-request', err.condition)
+        self.assertEqual(None, err.appCondition)
+
+
+    def test_fromElementOptionsSetNoForm(self):
+        """
+        On a options set request a form is required.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <options node='test' jid='user@example.org/Home'/>
+          </pubsub>
+        </iq>
+        """
+        err = self.assertRaises(error.StanzaError,
+                                pubsub.PubSubRequest.fromElement,
+                                parseXml(xml))
+        self.assertEqual('bad-request', err.condition)
+        self.assertEqual(None, err.appCondition)
+
+
+    def test_fromElementSubscriptions(self):
+        """
+        Test parsing a request for all subscriptions.
+        """
+
+        xml = """
+        <iq type='get' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <subscriptions/>
+          </pubsub>
+        </iq>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual('subscriptions', request.verb)
+        self.assertEqual(JID('user@example.org'), request.sender)
+        self.assertEqual(JID('pubsub.example.org'), request.recipient)
+
+
+    def test_fromElementAffiliations(self):
+        """
+        Test parsing a request for all affiliations.
+        """
+
+        xml = """
+        <iq type='get' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <affiliations/>
+          </pubsub>
+        </iq>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual('affiliations', request.verb)
+        self.assertEqual(JID('user@example.org'), request.sender)
+        self.assertEqual(JID('pubsub.example.org'), request.recipient)
+
+
+    def test_fromElementCreate(self):
+        """
+        Test parsing a request to create a node.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <create node='mynode'/>
+          </pubsub>
+        </iq>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual('create', request.verb)
+        self.assertEqual(JID('user@example.org'), request.sender)
+        self.assertEqual(JID('pubsub.example.org'), request.recipient)
+        self.assertEqual('mynode', request.nodeIdentifier)
+
+
+    def test_fromElementCreateInstant(self):
+        """
+        Test parsing a request to create an instant node.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <create/>
+          </pubsub>
+        </iq>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertIdentical(None, request.nodeIdentifier)
+
+
+    def test_fromElementDefault(self):
+        """
+        Test parsing a request for the default node configuration.
         """
 
@@ -589 +970 @@
         """
 
-        def getConfigurationOptions():
-            return {
-                "pubsub#persist_items":
-                    {"type": "boolean",
-                     "label": "Persist items to storage"},
-                "pubsub#deliver_payloads":
-                    {"type": "boolean",
-                     "label": "Deliver payloads with event notifications"}
-                }
-
-        def getDefaultConfiguration(requestor, service, nodeType):
-            self.assertEqual(JID('user@example.org'), requestor)
-            self.assertEqual(JID('pubsub.example.org'), service)
-            self.assertEqual('leaf', nodeType)
-            return defer.succeed({})
-
-        def cb(element):
-            self.assertEqual('pubsub', element.name)
-            self.assertEqual(NS_PUBSUB_OWNER, element.uri)
-            self.assertEqual(NS_PUBSUB_OWNER, element.default.uri)
-            form = data_form.Form.fromElement(element.default.x)
-            self.assertEqual(NS_PUBSUB_CONFIG, form.formNamespace)
-
-        self.service.getConfigurationOptions = getConfigurationOptions
-        self.service.getDefaultConfiguration = getDefaultConfiguration
-        d = self.handleRequest(xml)
-        d.addCallback(cb)
-        return d
-
-
-    def test_onConfigureGet(self):
-        """
-        On a node configuration get request L{PubSubService.getConfiguration}
-        is called and results in a data form with the configuration.
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual('default', request.verb)
+        self.assertEqual(JID('user@example.org'), request.sender)
+        self.assertEqual(JID('pubsub.example.org'), request.recipient)
+        self.assertEqual('leaf', request.nodeType)
+
+
+    def test_fromElementDefaultCollection(self):
+        """
+        Parsing a request for the default configuration extracts the node type.
+        """
+
+        xml = """
+        <iq type='get' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'>
+            <default>
+              <x xmlns='jabber:x:data' type='submit'>
+                <field var='FORM_TYPE' type='hidden'>
+                  <value>http://jabber.org/protocol/pubsub#node_config</value>
+                </field>
+                <field var='pubsub#node_type'>
+                  <value>collection</value>
+                </field>
+              </x>
+            </default>
+
+          </pubsub>
+        </iq>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual('collection', request.nodeType)
+
+
+    def test_fromElementConfigureGet(self):
+        """
+        Test parsing a node configuration get request.
         """
 
@@ -634 +1019 @@
         """
 
-        def getConfigurationOptions():
-            return {
-                "pubsub#persist_items":
-                    {"type": "boolean",
-                     "label": "Persist items to storage"},
-                "pubsub#deliver_payloads":
-                    {"type": "boolean",
-                     "label": "Deliver payloads with event notifications"}
-                }
-
-        def getConfiguration(requestor, service, nodeIdentifier):
-            self.assertEqual(JID('user@example.org'), requestor)
-            self.assertEqual(JID('pubsub.example.org'), service)
-            self.assertEqual('test', nodeIdentifier)
-
-            return defer.succeed({'pubsub#deliver_payloads': '0',
-                                  'pubsub#persist_items': '1'})
-
-        def cb(element):
-            self.assertEqual('pubsub', element.name)
-            self.assertEqual(NS_PUBSUB_OWNER, element.uri)
-            self.assertEqual(NS_PUBSUB_OWNER, element.configure.uri)
-            form = data_form.Form.fromElement(element.configure.x)
-            self.assertEqual(NS_PUBSUB_CONFIG, form.formNamespace)
-            fields = form.fields
-
-            self.assertIn('pubsub#deliver_payloads', fields)
-            field = fields['pubsub#deliver_payloads']
-            self.assertEqual('boolean', field.fieldType)
-            self.assertEqual(False, field.value)
-
-            self.assertIn('pubsub#persist_items', fields)
-            field = fields['pubsub#persist_items']
-            self.assertEqual('boolean', field.fieldType)
-            self.assertEqual(True, field.value)
-
-        self.service.getConfigurationOptions = getConfigurationOptions
-        self.service.getConfiguration = getConfiguration
-        d = self.handleRequest(xml)
-        d.addCallback(cb)
-        return d
-
-
-    def test_onConfigureSet(self):
-        """
-        On a node configuration set request the Data Form is parsed and
-        L{PubSubService.setConfiguration} is called with the passed options.
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual('configureGet', request.verb)
+        self.assertEqual(JID('user@example.org'), request.sender)
+        self.assertEqual(JID('pubsub.example.org'), request.recipient)
+        self.assertEqual('test', request.nodeIdentifier)
+
+
+    def test_fromElementConfigureSet(self):
+        """
+        On a node configuration set request the Data Form is parsed.
         """
 
@@ -700 +1048 @@
         """
 
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual('configureSet', request.verb)
+        self.assertEqual(JID('user@example.org'), request.sender)
+        self.assertEqual(JID('pubsub.example.org'), request.recipient)
+        self.assertEqual('test', request.nodeIdentifier)
+        self.assertEqual({'pubsub#deliver_payloads': '0',
+                          'pubsub#persist_items': '1'}, request.options)
+
+
+    def test_fromElementConfigureSetCancel(self):
+        """
+        The node configuration is cancelled, so no options.
+        """
+
+        xml = """
+        <iq type='set' to='pubsub.example.org'
+                       from='user@example.org'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'>
+            <configure node='test'>
+              <x xmlns='jabber:x:data' type='cancel'/>
+            </configure>
+          </pubsub>
+        </iq>
+        """
+
+        request = pubsub.PubSubRequest.fromElement(parseXml(xml))
+        self.assertEqual({}, request.options)
+
+
+    def test_fromElementConfigureSetBadFormType(self):
+        """
+