Changeset 49:50a84c44cbf1 for wokkel

Timestamp:

Jan 12, 2009, 9:00:30 PM (13 years ago)

Author:

Ralph Meijer <ralphm@…>

Branch:

default

Convert:

svn:b33ecbfc-034c-dc11-8662-000475d9059e/trunk@157

Message:

Add Service Discovery client protocol and overhaul data classes.

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

Location:

wokkel

Files:

• disco.py (modified) (5 diffs)
• pubsub.py (modified) (1 diff)
• test/test_disco.py (modified) (4 diffs)

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.
 
@@ -12 +12 @@
 
 from twisted.internet import defer
-from twisted.words.protocols.jabber import error, jid
+from twisted.words.protocols.jabber import error, jid, xmlstream
 from twisted.words.xish import domish
 
+from wokkel import data_form
 from wokkel.iwokkel import IDisco
 from wokkel.subprotocols import IQHandlerMixin, XMPPHandler
@@ -26 +27 @@
 DISCO_ITEMS = IQ_GET + '/query[@xmlns="' + NS_DISCO_ITEMS + '"]'
 
-class DiscoFeature(domish.Element):
-    """
-    Element representing an XMPP service discovery feature.
-    """
-
-    def __init__(self, feature):
-        domish.Element.__init__(self, (NS_DISCO_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_DISCO_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_DISCO_ITEMS, 'item'),
-                                attribs={'jid': jid.full()})
-        if node:
-            self['node'] = node
-
-        if name:
-            self['name'] = name
+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
 
 
@@ -97 +441 @@
                 raise error.StanzaError('item-not-found')
             else:
-                response = domish.Element((NS_DISCO_INFO, 'query'))
-                if nodeIdentifier:
-                    response['node'] = nodeIdentifier
+                response = DiscoInfo()
+                response.nodeIdentifier = nodeIdentifier
 
                 for item in info:
-                    response.addChild(item)
-
-            return response
+                    response.append(item)
+
+            return response.toElement()
 
         d = self.info(requestor, target, nodeIdentifier)
@@ -123 +466 @@
 
         def toResponse(items):
-            response = domish.Element((NS_DISCO_ITEMS, 'query'))
-            if nodeIdentifier:
-                response['node'] = nodeIdentifier
+            response = DiscoItems()
+            response.nodeIdentifier = nodeIdentifier
 
             for item in items:
-                response.addChild(item)
-
-            return response
+                response.append(item)
+
+            return response.toElement()
 
         d = self.items(requestor, target, nodeIdentifier)

wokkel/pubsub.py

@@ -541 +541 @@
 
         if not nodeIdentifier:
-            info.append(disco.DiscoIdentity(**self.discoIdentity))
+            category, idType, name = self.discoIdentity
+            info.append(disco.DiscoIdentity(category, idType, name))
 
             info.append(disco.DiscoFeature(disco.NS_DISCO_ITEMS))

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.protocols.jabber.jid import JID
-from zope.interface import implements
-
-from wokkel import disco
+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
-
+from wokkel.test.helpers import TestableRequestHandlerMixin, XmlStreamStub
+
+try:
+    from twisted.words.protocols.jabber.xmlstream import toResponse
+except ImportError:
+    from wokkel.compat import toResponse
 
 NS_DISCO_INFO = 'http://jabber.org/protocol/disco#info'
 NS_DISCO_ITEMS = 'http://jabber.org/protocol/disco#items'
+
+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
+
 
 
@@ -67 +605 @@
         return d
 
+
     def test_onDiscoInfoWithNode(self):
         """
@@ -128 +667 @@
         return d
 
+
     def test_onDiscoItemsWithNode(self):
         """