Changeset 172:ea2774e1c71c for wokkel/test/test_xmppim.py

Timestamp:

May 9, 2012, 2:24:28 PM (10 years ago)

Author:

Ralph Meijer <ralphm@…>

Branch:

default

Message:

Clean up of RosterItem? and RosterClientProtocol?.

RosterItem:

• Renamed attributes jid and ask to entity and pendingOut respectively.
• Can represent roster items to be removed or that have been removed.
• Now has fromElement and toElement methods.

RosterRequest is a new class to represent roster request stanzas.

RosterClientProtocol:

• Roster returned from getRoster is now indexed by JIDs (instead of the unicode representation of the JID).
• Outgoing requests are now done using RosterRequest.
• onRosterSet and onRosterRemove are deprecated in favor of setReceived and removeReceived, respectively. These are called with a RosterRequest to have access to addressing and roster version information.

RosterPushIgnored can be raised to return a service-unavailable stanza
error for unwanted pushes.

This also fixes a problem with checking the sender address for roster pushes.

Author: ralphm.
Fixes: #71.

File:

• wokkel/test/test_xmppim.py (modified) (5 diffs)

wokkel/test/test_xmppim.py

@@ -8 +8 @@
 from twisted.internet import defer
 from twisted.trial import unittest
+from twisted.words.protocols.jabber import error
 from twisted.words.protocols.jabber.jid import JID
 from twisted.words.protocols.jabber.xmlstream import toResponse
@@ -14 +15 @@
 from wokkel import xmppim
 from wokkel.generic import ErrorStanza, parseXml
-from wokkel.test.helpers import XmlStreamStub
+from wokkel.test.helpers import TestableRequestHandlerMixin, XmlStreamStub
 
 NS_XML = 'http://www.w3.org/XML/1998/namespace'
@@ -450 +451 @@
 
 
-class RosterClientProtocolTest(unittest.TestCase):
+class RosterItemTest(unittest.TestCase):
+    """
+    Tests for L{xmppim.RosterItem}.
+    """
+
+    def test_toElement(self):
+        """
+        A roster item has the correct namespace/name, lacks unset attributes.
+        """
+        item = xmppim.RosterItem(JID('user@example.org'))
+        element = item.toElement()
+        self.assertEqual('item', element.name)
+        self.assertEqual(NS_ROSTER, element.uri)
+        self.assertFalse(element.hasAttribute('subscription'))
+        self.assertFalse(element.hasAttribute('ask'))
+        self.assertEqual(u"", element.getAttribute('name', u""))
+        self.assertFalse(element.hasAttribute('approved'))
+        self.assertEquals(0, len(list(element.elements())))
+
+
+    def test_toElementMinimal(self):
+        """
+        A bare roster item only has a jid attribute.
+        """
+        item = xmppim.RosterItem(JID('user@example.org'))
+        element = item.toElement()
+        self.assertEqual(u'user@example.org', element.getAttribute('jid'))
+
+
+    def test_toElementSubscriptionNone(self):
+        """
+        A roster item with no subscription has no subscription attribute.
+        """
+        item = xmppim.RosterItem(JID('user@example.org'),
+                                 subscriptionTo=False,
+                                 subscriptionFrom=False)
+        element = item.toElement()
+        self.assertIdentical(None, element.getAttribute('subscription'))
+
+
+    def test_toElementSubscriptionTo(self):
+        """
+        A roster item with subscriptionTo set has subscription 'to'.
+        """
+        item = xmppim.RosterItem(JID('user@example.org'),
+                                 subscriptionTo=True,
+                                 subscriptionFrom=False)
+        element = item.toElement()
+        self.assertEqual('to', element.getAttribute('subscription'))
+
+
+    def test_toElementSubscriptionFrom(self):
+        """
+        A roster item with subscriptionFrom set has subscription 'to'.
+        """
+        item = xmppim.RosterItem(JID('user@example.org'),
+                                 subscriptionTo=False,
+                                 subscriptionFrom=True)
+        element = item.toElement()
+        self.assertEqual('from', element.getAttribute('subscription'))
+
+
+    def test_toElementSubscriptionBoth(self):
+        """
+        A roster item with mutual subscription has subscription 'both'.
+        """
+        item = xmppim.RosterItem(JID('user@example.org'),
+                                 subscriptionTo=True,
+                                 subscriptionFrom=True)
+        element = item.toElement()
+        self.assertEqual('both', element.getAttribute('subscription'))
+
+
+    def test_toElementSubscriptionRemove(self):
+        """
+        A roster item with remove set has subscription 'remove'.
+        """
+        item = xmppim.RosterItem(JID('user@example.org'))
+        item.remove = True
+        element = item.toElement()
+        self.assertEqual('remove', element.getAttribute('subscription'))
+
+
+    def test_toElementAsk(self):
+        """
+        A roster item with pendingOut set has subscription 'ask'.
+        """
+        item = xmppim.RosterItem(JID('user@example.org'))
+        item.pendingOut = True
+        element = item.toElement()
+        self.assertEqual('subscribe', element.getAttribute('ask'))
+
+
+    def test_toElementName(self):
+        """
+        A roster item's name is rendered to the 'name' attribute.
+        """
+        item = xmppim.RosterItem(JID('user@example.org'),
+                                 name='Joe User')
+        element = item.toElement()
+        self.assertEqual(u'Joe User', element.getAttribute('name'))
+
+
+    def test_toElementGroups(self):
+        """
+        A roster item's groups are rendered as 'group' child elements.
+        """
+        groups = set(['Friends', 'Jabber'])
+        item = xmppim.RosterItem(JID('user@example.org'),
+                                 groups=groups)
+
+        element = item.toElement()
+        foundGroups = set()
+        for child in element.elements():
+            if child.uri == NS_ROSTER and child.name == 'group':
+                foundGroups.add(unicode(child))
+
+        self.assertEqual(groups, foundGroups)
+
+
+    def test_toElementApproved(self):
+        """
+        A pre-approved subscription for a roster item has an 'approved' flag.
+        """
+        item = xmppim.RosterItem(JID('user@example.org'))
+        item.approved = True
+        element = item.toElement()
+        self.assertEqual(u'true', element.getAttribute('approved'))
+
+
+    def test_fromElementMinimal(self):
+        """
+        A minimal roster item has a reference to the JID of the contact.
+        """
+
+        xml = """
+            <item xmlns="jabber:iq:roster"
+                  jid="test@example.org"/>
+        """
+
+        item = xmppim.RosterItem.fromElement(parseXml(xml))
+        self.assertEqual(JID(u"test@example.org"), item.entity)
+        self.assertEqual(u"", item.name)
+        self.assertFalse(item.subscriptionTo)
+        self.assertFalse(item.subscriptionFrom)
+        self.assertFalse(item.pendingOut)
+        self.assertFalse(item.approved)
+        self.assertEqual(set(), item.groups)
+
+
+    def test_fromElementName(self):
+        """
+        A roster item may have an optional name.
+        """
+
+        xml = """
+            <item xmlns="jabber:iq:roster"
+                  jid="test@example.org"
+                  name="Test User"/>
+        """
+
+        item = xmppim.RosterItem.fromElement(parseXml(xml))
+        self.assertEqual(u"Test User", item.name)
+
+
+    def test_fromElementGroups(self):
+        """
+        A roster item may have one or more groups.
+        """
+
+        xml = """
+            <item xmlns="jabber:iq:roster"
+                  jid="test@example.org">
+              <group>Friends</group>
+              <group>Twisted</group>
+            </item>
+        """
+
+        item = xmppim.RosterItem.fromElement(parseXml(xml))
+        self.assertIn(u"Twisted", item.groups)
+        self.assertIn(u"Friends", item.groups)
+
+
+    def test_fromElementSubscriptionNone(self):
+        """
+        Subscription 'none' sets both attributes to False.
+        """
+
+        xml = """
+            <item xmlns="jabber:iq:roster"
+                  jid="test@example.org"
+                  subscription="none"/>
+        """
+
+        item = xmppim.RosterItem.fromElement(parseXml(xml))
+        self.assertFalse(item.remove)
+        self.assertFalse(item.subscriptionTo)
+        self.assertFalse(item.subscriptionFrom)
+
+
+    def test_fromElementSubscriptionTo(self):
+        """
+        Subscription 'to' sets the corresponding attribute to True.
+        """
+
+        xml = """
+            <item xmlns="jabber:iq:roster"
+                  jid="test@example.org"
+                  subscription="to"/>
+        """
+
+        item = xmppim.RosterItem.fromElement(parseXml(xml))
+        self.assertFalse(item.remove)
+        self.assertTrue(item.subscriptionTo)
+        self.assertFalse(item.subscriptionFrom)
+
+
+    def test_fromElementSubscriptionFrom(self):
+        """
+        Subscription 'from' sets the corresponding attribute to True.
+        """
+
+        xml = """
+            <item xmlns="jabber:iq:roster"
+                  jid="test@example.org"
+                  subscription="from"/>
+        """
+
+        item = xmppim.RosterItem.fromElement(parseXml(xml))
+        self.assertFalse(item.remove)
+        self.assertFalse(item.subscriptionTo)
+        self.assertTrue(item.subscriptionFrom)
+
+
+    def test_fromElementSubscriptionBoth(self):
+        """
+        Subscription 'both' sets both attributes to True.
+        """
+
+        xml = """
+            <item xmlns="jabber:iq:roster"
+                  jid="test@example.org"
+                  subscription="both"/>
+        """
+
+        item = xmppim.RosterItem.fromElement(parseXml(xml))
+        self.assertFalse(item.remove)
+        self.assertTrue(item.subscriptionTo)
+        self.assertTrue(item.subscriptionFrom)
+
+
+    def test_fromElementSubscriptionRemove(self):
+        """
+        Subscription 'remove' sets the remove attribute.
+        """
+
+        xml = """
+            <item xmlns="jabber:iq:roster"
+                  jid="test@example.org"
+                  subscription="remove"/>
+        """
+
+        item = xmppim.RosterItem.fromElement(parseXml(xml))
+        self.assertTrue(item.remove)
+
+
+    def test_fromElementPendingOut(self):
+        """
+        The ask attribute, if set to 'subscription', means pending out.
+        """
+
+        xml = """
+            <item xmlns="jabber:iq:roster"
+                  jid="test@example.org"
+                  ask="subscribe"/>
+        """
+
+        item = xmppim.RosterItem.fromElement(parseXml(xml))
+        self.assertTrue(item.pendingOut)
+
+
+    def test_fromElementApprovedTrue(self):
+        """
+        The approved attribute (true) signals a pre-approved subscription.
+        """
+
+        xml = """
+            <item xmlns="jabber:iq:roster"
+                  jid="test@example.org"
+                  approved="true"/>
+        """
+
+        item = xmppim.RosterItem.fromElement(parseXml(xml))
+        self.assertTrue(item.approved)
+
+
+    def test_fromElementApproved1(self):
+        """
+        The approved attribute (1) signals a pre-approved subscription.
+        """
+
+        xml = """
+            <item xmlns="jabber:iq:roster"
+                  jid="test@example.org"
+                  approved="1"/>
+        """
+
+        item = xmppim.RosterItem.fromElement(parseXml(xml))
+        self.assertTrue(item.approved)
+
+
+    def test_jidDeprecationGet(self):
+        """
+        Getting the jid attribute works as entity and warns deprecation.
+        """
+        item = xmppim.RosterItem(JID('user@example.org'))
+        entity = self.assertWarns(DeprecationWarning,
+                                  "wokkel.xmppim.RosterItem.jid is deprecated. "
+                                  "Use RosterItem.entity instead.",
+                                  xmppim.__file__,
+                                  getattr, item, 'jid')
+        self.assertIdentical(entity, item.entity)
+
+
+    def test_jidDeprecationSet(self):
+        """
+        Setting the jid attribute works as entity and warns deprecation.
+        """
+        item = xmppim.RosterItem(JID('user@example.org'))
+        self.assertWarns(DeprecationWarning,
+                         "wokkel.xmppim.RosterItem.jid is deprecated. "
+                         "Use RosterItem.entity instead.",
+                         xmppim.__file__,
+                         setattr, item, 'jid',
+                         JID('other@example.org'))
+        self.assertEqual(JID('other@example.org'), item.entity)
+
+
+    def test_askDeprecationGet(self):
+        """
+        Getting the ask attribute works as entity and warns deprecation.
+        """
+        item = xmppim.RosterItem(JID('user@example.org'))
+        item.pendingOut = True
+        ask = self.assertWarns(DeprecationWarning,
+                               "wokkel.xmppim.RosterItem.ask is deprecated. "
+                               "Use RosterItem.pendingOut instead.",
+                               xmppim.__file__,
+                               getattr, item, 'ask')
+        self.assertTrue(ask)
+
+
+    def test_askDeprecationSet(self):
+        """
+        Setting the ask attribute works as entity and warns deprecation.
+        """
+        item = xmppim.RosterItem(JID('user@example.org'))
+        self.assertWarns(DeprecationWarning,
+                         "wokkel.xmppim.RosterItem.ask is deprecated. "
+                         "Use RosterItem.pendingOut instead.",
+                         xmppim.__file__,
+                         setattr, item, 'ask',
+                         True)
+        self.assertTrue(item.pendingOut)
+
+
+
+class RosterRequestTest(unittest.TestCase):
+    """
+    Tests for L{xmppim.RosterRequest}.
+    """
+
+    def test_fromElement(self):
+        """
+        A bare roster request is parsed and missing information is None.
+        """
+        xml = """
+            <iq type='get' to='this@example.org/Home' from='this@example.org'>
+              <query xmlns='jabber:iq:roster'/>
+            </iq>
+        """
+
+        request = xmppim.RosterRequest.fromElement(parseXml(xml))
+        self.assertEqual('get', request.stanzaType)
+        self.assertEqual(JID('this@example.org/Home'), request.recipient)
+        self.assertEqual(JID('this@example.org'), request.sender)
+        self.assertEqual(None, request.item)
+
+
+    def test_fromElementItem(self):
+        """
+        If an item is present, parse it and put it in the request item.
+        """
+        xml = """
+            <iq type='set' to='this@example.org/Home' from='this@example.org'>
+              <query xmlns='jabber:iq:roster'>
+                <item jid='user@example.org'/>
+              </query>
+            </iq>
+        """
+
+        request = xmppim.RosterRequest.fromElement(parseXml(xml))
+        self.assertNotIdentical(None, request.item)
+        self.assertEqual(JID('user@example.org'), request.item.entity)
+
+
+    def test_toElement(self):
+        """
+        A roster request has a query element in the roster namespace.
+        """
+        request = xmppim.RosterRequest()
+        element = request.toElement()
+        children = element.elements()
+        child = children.next()
+        self.assertEqual(NS_ROSTER, child.uri)
+        self.assertEqual('query', child.name)
+
+
+    def test_toElementItem(self):
+        """
+        If an item is set, it is rendered as a child of the query.
+        """
+        request = xmppim.RosterRequest()
+        request.item = xmppim.RosterItem(JID('user@example.org'))
+        element = request.toElement()
+        children = element.query.elements()
+        child = children.next()
+        self.assertEqual(NS_ROSTER, child.uri)
+        self.assertEqual('item', child.name)
+
+
+
+class FakeClient(object):
+    """
+    Fake client stream manager for roster tests.
+    """
+
+    def __init__(self, xmlstream, jid):
+        self.xmlstream = xmlstream
+        self.jid = jid
+
+
+    def request(self, request):
+        element = request.toElement()
+        self.xmlstream.send(element)
+        return defer.Deferred()
+
+
+    def addHandler(self, handler):
+        handler.makeConnection(self.xmlstream)
+        handler.connectionInitialized()
+
+
+
+class RosterClientProtocolTest(unittest.TestCase, TestableRequestHandlerMixin):
     """
     Tests for L{xmppim.RosterClientProtocol}.
@@ -457 +912 @@
     def setUp(self):
         self.stub = XmlStreamStub()
-        self.protocol = xmppim.RosterClientProtocol()
-        self.protocol.xmlstream = self.stub.xmlstream
-        self.protocol.connectionInitialized()
+        self.client = FakeClient(self.stub.xmlstream, JID('this@example.org'))
+        self.service = xmppim.RosterClientProtocol()
+        self.service.setHandlerParent(self.client)
 
 
@@ -466 +921 @@
         Removing a roster item is setting an item with subscription C{remove}.
         """
-        d = self.protocol.removeItem(JID('test@example.org'))
+        d = self.service.removeItem(JID('test@example.org'))
 
         # Inspect outgoing iq request
 
         iq = self.stub.output[-1]
-        self.assertEquals('set', iq.getAttribute('type'))
+        self.assertEqual('set', iq.getAttribute('type'))
         self.assertNotIdentical(None, iq.query)
-        self.assertEquals(NS_ROSTER, iq.query.uri)
+        self.assertEqual(NS_ROSTER, iq.query.uri)
 
         children = list(domish.generateElementsQNamed(iq.query.children,
                                                       'item', NS_ROSTER))
-        self.assertEquals(1, len(children))
+        self.assertEqual(1, len(children))
         child = children[0]
-        self.assertEquals('test@example.org', child['jid'])
-        self.assertEquals('remove', child['subscription'])
+        self.assertEqual('test@example.org', child['jid'])
+        self.assertEqual('remove', child.getAttribute('subscription'))
 
         # Fake successful response
 
         response = toResponse(iq, 'result')
-        self.stub.send(response)
-        return d
+        d.callback(response)
+        return d
+
+
+    def test_getRoster(self):
+        """
+        A request for the roster is sent out and the response is parsed.
+        """
+        def cb(roster):
+            self.assertIn(JID('user@example.org'), roster)
+
+        d = self.service.getRoster()
+        d.addCallback(cb)
+
+        # Inspect outgoing iq request
+
+        iq = self.stub.output[-1]
+        self.assertEqual('get', iq.getAttribute('type'))
+        self.assertNotIdentical(None, iq.query)
+        self.assertEqual(NS_ROSTER, iq.query.uri)
+
+        # Fake successful response
+        response = toResponse(iq, 'result')
+        query = response.addElement((NS_ROSTER, 'query'))
+        item = query.addElement('item')
+        item['jid'] = 'user@example.org'
+
+        d.callback(response)
+        return d
+
+
+    def test_onRosterSet(self):
+        """
+        A roster push causes onRosterSet to be called with the parsed item.
+        """
+        xml = """
+          <iq type='set'>
+            <query xmlns='jabber:iq:roster'>
+              <item jid='user@example.org'/>
+            </query>
+          </iq>
+        """
+
+        items = []
+
+        def onRosterSet(item):
+            items.append(item)
+
+        def cb(result):
+            self.assertEqual(1, len(items))
+            self.assertEqual(JID('user@example.org'), items[0].entity)
+
+        self.service.onRosterSet = onRosterSet
+
+        d = self.assertWarns(DeprecationWarning,
+                             "wokkel.xmppim.RosterClientProtocol.onRosterSet "
+                             "is deprecated. "
+                             "Use RosterClientProtocol.setReceived instead.",
+                             xmppim.__file__,
+                             self.handleRequest, xml)
+        d.addCallback(cb)
+        return d
+
+
+    def test_onRosterRemove(self):
+        """
+        A roster push causes onRosterSet to be called with the parsed item.
+        """
+        xml = """
+          <iq type='set'>
+            <query xmlns='jabber:iq:roster'>
+              <item jid='user@example.org' subscription='remove'/>
+            </query>
+          </iq>
+        """
+
+        entities = []
+
+        def onRosterRemove(entity):
+            entities.append(entity)
+
+        def cb(result):
+            self.assertEqual([JID('user@example.org')], entities)
+
+        self.service.onRosterRemove = onRosterRemove
+
+        d = self.assertWarns(DeprecationWarning,
+                             "wokkel.xmppim.RosterClientProtocol.onRosterRemove "
+                             "is deprecated. "
+                             "Use RosterClientProtocol.removeReceived instead.",
+                             xmppim.__file__,
+                             self.handleRequest, xml)
+        d.addCallback(cb)
+        return d
+
+
+    def test_setReceived(self):
+        """
+        A roster set push causes setReceived.
+        """
+        xml = """
+          <iq type='set'>
+            <query xmlns='jabber:iq:roster'>
+              <item jid='user@example.org'/>
+            </query>
+          </iq>
+        """
+
+        requests = []
+
+        def setReceived(request):
+            requests.append(request)
+
+        def cb(result):
+            self.assertEqual(1, len(requests), "setReceived was not called")
+            self.assertEqual(JID('user@example.org'), requests[0].item.entity)
+
+        self.service.setReceived = setReceived
+
+        d = self.handleRequest(xml)
+        d.addCallback(cb)
+        return d
+
+
+    def test_setReceivedOtherSource(self):
+        """
+        Roster pushes can be sent from other entities, too, ignore them.
+        """
+        xml = """
+          <iq type='set' to='this@example.org/Home' from='other@example.org'>
+            <query xmlns='jabber:iq:roster'>
+              <item jid='user@example.org'/>
+            </query>
+          </iq>
+        """
+
+        def cb(result):
+            self.assertEquals('service-unavailable', result.condition)
+
+        d = self.handleRequest(xml)
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d
+
+
+    def test_setReceivedOtherSourceAllowed(self):
+        """
+        Roster pushes can be sent from other entities, allow them.
+        """
+        xml = """
+          <iq type='set' to='this@example.org/Home' from='other@example.org'>
+            <query xmlns='jabber:iq:roster'>
+              <item jid='user@example.org'/>
+            </query>
+          </iq>
+        """
+
+        self.service.allowAnySender = True
+        requests = []
+
+        def setReceived(request):
+            requests.append(request)
+
+        def cb(result):
+            self.assertEqual(1, len(requests), "setReceived was not called")
+
+        self.service.setReceived = setReceived
+
+        d = self.handleRequest(xml)
+        d.addCallback(cb)
+        return d
+
+
+    def test_setReceivedOtherSourceIgnored(self):
+        """
+        Roster pushes can be sent from other entities, allow them.
+        """
+        xml = """
+          <iq type='set' to='this@example.org/Home' from='bad@example.org'>
+            <query xmlns='jabber:iq:roster'>
+              <item jid='user@example.org'/>
+            </query>
+          </iq>
+        """
+
+        self.service.allowAnySender = True
+
+        def setReceived(request):
+            if request.sender == JID('bad@example.org'):
+                raise xmppim.RosterPushIgnored()
+
+        def cb(result):
+            self.assertEquals('service-unavailable', result.condition)
+
+        self.service.setReceived = setReceived
+
+
+        d = self.handleRequest(xml)
+        self.assertFailure(d, error.StanzaError)
+        d.addCallback(cb)
+        return d
+
+
+    def test_removeReceived(self):
+        """
+        A roster remove push causes removeReceived.
+        """
+        xml = """
+          <iq type='set'>
+            <query xmlns='jabber:iq:roster'>
+              <item jid='user@example.org' subscription='remove'/>
+            </query>
+          </iq>
+        """
+
+        requests = []
+
+        def removeReceived(request):
+            requests.append(request)
+
+        def cb(result):
+            self.assertEqual(1, len(requests), "removeReceived was not called")
+            self.assertEqual(JID('user@example.org'), requests[0].item.entity)
+
+        self.service.removeReceived = removeReceived
+
+        d = self.handleRequest(xml)
+        d.addCallback(cb)
+        return d