Ignore:
Timestamp:
Jul 7, 2008, 4:29:02 PM (13 years ago)
Author:
Ralph Meijer <ralphm@…>
Branch:
default
Convert:
svn:b33ecbfc-034c-dc11-8662-000475d9059e/trunk@55
Message:

Refactor Data Forms.

Author: ralphm.
Fixes #13.

This refactoring provides an abstract representation of Forms, Fields and
Options and each of those can be parsed from or unparsed to XML. This change
also simplifies testing in test_pubsub, by allowing the 'received' requests
to be represented as an XML snippit.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • wokkel/test/test_pubsub.py

    r24 r25  
    55Tests for L{wokkel.pubsub}
    66"""
     7
    78from zope.interface import verify
    89
     
    1314from twisted.words.protocols.jabber.jid import JID
    1415
    15 from wokkel import iwokkel, pubsub
     16from wokkel import data_form, iwokkel, pubsub
    1617from wokkel.generic import parseXml
    1718from wokkel.test.helpers import XmlStreamStub
     
    2324
    2425NS_PUBSUB = 'http://jabber.org/protocol/pubsub'
     26NS_PUBSUB_CONFIG = 'http://jabber.org/protocol/pubsub#node_config'
    2527NS_PUBSUB_ERRORS = 'http://jabber.org/protocol/pubsub#errors'
    2628NS_PUBSUB_EVENT = 'http://jabber.org/protocol/pubsub#event'
     29NS_PUBSUB_OWNER = 'http://jabber.org/protocol/pubsub#owner'
    2730
    2831def calledAsync(fn):
     
    445448    """
    446449
    447     def handleRequest(self, handler, iq):
     450    def setUp(self):
     451        self.service = pubsub.PubSubService()
     452
     453    def handleRequest(self, xml):
    448454        """
    449455        Find a handler and call it directly
    450456        """
    451         for queryString, method in handler.iqHandlers.iteritems():
     457        handler = None
     458        iq = parseXml(xml)
     459        for queryString, method in self.service.iqHandlers.iteritems():
    452460            if xpath.internQuery(queryString).matches(iq):
    453                 handler = getattr(handler, method)
     461                handler = getattr(self.service, method)
    454462
    455463        if handler:
     
    465473        Do instances of L{pubsub.PubSubService} provide L{iwokkel.IPubSubService}?
    466474        """
    467         verify.verifyObject(iwokkel.IPubSubService, pubsub.PubSubService())
     475        verify.verifyObject(iwokkel.IPubSubService, self.service)
    468476
    469477
     
    484492            self.assertEquals('bad-request', result.condition)
    485493
    486         handler = pubsub.PubSubService()
    487         d = self.handleRequest(handler, parseXml(xml))
     494        d = self.handleRequest(xml)
    488495        self.assertFailure(d, error.StanzaError)
    489496        d.addCallback(cb)
    490497        return d
     498
    491499
    492500    def test_onPublish(self):
     
    495503        called.
    496504        """
    497         class Handler(pubsub.PubSubService):
    498             def publish(self, requestor, service, nodeIdentifier, items):
    499                 return defer.succeed((requestor, service,nodeIdentifier,
    500                                       items))
    501505
    502506        xml = """
     
    509513        """
    510514
    511         def cb(result):
    512             self.assertEqual((JID('user@example.org'),
    513                               JID('pubsub.example.org'),'test', []), result)
    514 
    515         handler = Handler()
    516         d = self.handleRequest(handler, parseXml(xml))
    517         d.addCallback(cb)
    518         return d
     515        def publish(requestor, service, nodeIdentifier, items):
     516            self.assertEqual(JID('user@example.org'), requestor)
     517            self.assertEqual(JID('pubsub.example.org'), service)
     518            self.assertEqual('test', nodeIdentifier)
     519            self.assertEqual([], items)
     520            return defer.succeed(None)
     521
     522        self.service.publish = publish
     523        return self.handleRequest(xml)
    519524
    520525
     
    524529        """
    525530
    526         handler = pubsub.PubSubService()
    527531        xml = """
    528532        <iq type='get' to='pubsub.example.org'
     
    539543            self.assertEquals(NS_PUBSUB_ERRORS, result.appCondition.uri)
    540544
    541         handler = pubsub.PubSubService()
    542         d = self.handleRequest(handler, parseXml(xml))
     545        d = self.handleRequest(xml)
    543546        self.assertFailure(d, error.StanzaError)
    544547        d.addCallback(cb)
     
    546549
    547550
     551    def test_onDefault(self):
     552        """
     553        A default request should result in
     554        L{PubSubService.getDefaultConfiguration} being called.
     555        """
     556
     557        xml = """
     558        <iq type='get' to='pubsub.example.org'
     559                       from='user@example.org'>
     560          <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'>
     561            <default/>
     562          </pubsub>
     563        </iq>
     564        """
     565
     566        def getConfigurationOptions():
     567            return {
     568                "pubsub#persist_items":
     569                    {"type": "boolean",
     570                     "label": "Persist items to storage"},
     571                "pubsub#deliver_payloads":
     572                    {"type": "boolean",
     573                     "label": "Deliver payloads with event notifications"}
     574                }
     575
     576        def getDefaultConfiguration(requestor, service):
     577            self.assertEqual(JID('user@example.org'), requestor)
     578            self.assertEqual(JID('pubsub.example.org'), service)
     579            return defer.succeed({})
     580
     581        def cb(element):
     582            self.assertEqual('pubsub', element.name)
     583            self.assertEqual(NS_PUBSUB_OWNER, element.uri)
     584            self.assertEqual(NS_PUBSUB_OWNER, element.default.uri)
     585            form = data_form.Form.fromElement(element.default.x)
     586            self.assertEqual(NS_PUBSUB_CONFIG, form.formNamespace)
     587
     588        self.service.getConfigurationOptions = getConfigurationOptions
     589        self.service.getDefaultConfiguration = getDefaultConfiguration
     590        d = self.handleRequest(xml)
     591        d.addCallback(cb)
     592        return d
     593
     594
     595    def test_onConfigureGet(self):
     596        """
     597        On a node configuration get request L{PubSubService.getConfiguration}
     598        is called and results in a data form with the configuration.
     599        """
     600
     601        xml = """
     602        <iq type='get' to='pubsub.example.org'
     603                       from='user@example.org'>
     604          <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'>
     605            <configure node='test'/>
     606          </pubsub>
     607        </iq>
     608        """
     609
     610        def getConfigurationOptions():
     611            return {
     612                "pubsub#persist_items":
     613                    {"type": "boolean",
     614                     "label": "Persist items to storage"},
     615                "pubsub#deliver_payloads":
     616                    {"type": "boolean",
     617                     "label": "Deliver payloads with event notifications"}
     618                }
     619
     620        def getConfiguration(requestor, service, nodeIdentifier):
     621            self.assertEqual(JID('user@example.org'), requestor)
     622            self.assertEqual(JID('pubsub.example.org'), service)
     623            self.assertEqual('test', nodeIdentifier)
     624
     625            return defer.succeed({'pubsub#deliver_payloads': '0',
     626                                  'pubsub#persist_items': '1'})
     627
     628        def cb(element):
     629            self.assertEqual('pubsub', element.name)
     630            self.assertEqual(NS_PUBSUB_OWNER, element.uri)
     631            self.assertEqual(NS_PUBSUB_OWNER, element.configure.uri)
     632            form = data_form.Form.fromElement(element.configure.x)
     633            self.assertEqual(NS_PUBSUB_CONFIG, form.formNamespace)
     634            fields = dict([(field.var, field) for field in form.fields])
     635
     636            self.assertIn('pubsub#deliver_payloads', fields)
     637            field = fields['pubsub#deliver_payloads']
     638            self.assertEqual('boolean', field.fieldType)
     639            self.assertEqual(True, field.value)
     640
     641            self.assertIn('pubsub#persist_items', fields)
     642            field = fields['pubsub#persist_items']
     643            self.assertEqual('boolean', field.fieldType)
     644            self.assertEqual(True, field.value)
     645
     646        self.service.getConfigurationOptions = getConfigurationOptions
     647        self.service.getConfiguration = getConfiguration
     648        d = self.handleRequest(xml)
     649        d.addCallback(cb)
     650        return d
     651
     652
     653    def test_onConfigureSet(self):
     654        """
     655        On a node configuration set request the Data Form is parsed and
     656        L{PubSubService.setConfiguration} is called with the passed options.
     657        """
     658
     659        xml = """
     660        <iq type='set' to='pubsub.example.org'
     661                       from='user@example.org'>
     662          <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'>
     663            <configure node='test'>
     664              <x xmlns='jabber:x:data' type='submit'>
     665                <field var='FORM_TYPE' type='hidden'>
     666                  <value>http://jabber.org/protocol/pubsub#node_config</value>
     667                </field>
     668                <field var='pubsub#deliver_payloads'><value>0</value></field>
     669                <field var='pubsub#persist_items'><value>1</value></field>
     670              </x>
     671            </configure>
     672          </pubsub>
     673        </iq>
     674        """
     675
     676        def setConfiguration(requestor, service, nodeIdentifier, options):
     677            self.assertEqual(JID('user@example.org'), requestor)
     678            self.assertEqual(JID('pubsub.example.org'), service)
     679            self.assertEqual('test', nodeIdentifier)
     680            self.assertEqual({'pubsub#deliver_payloads': '0',
     681                              'pubsub#persist_items': '1'}, options)
     682            return defer.succeed(None)
     683
     684        self.service.setConfiguration = setConfiguration
     685        return self.handleRequest(xml)
     686
     687
     688    def test_onConfigureSetCancel(self):
     689        """
     690        The node configuration is cancelled, L{PubSubService.setConfiguration}
     691        not called.
     692        """
     693
     694        xml = """
     695        <iq type='set' to='pubsub.example.org'
     696                       from='user@example.org'>
     697          <pubsub xmlns='http://jabber.org/protocol/pubsub#owner'>
     698            <configure node='test'>
     699              <x xmlns='jabber:x:data' type='cancel'>
     700                <field var='FORM_TYPE' type='hidden'>
     701                  <value>http://jabber.org/protocol/pubsub#node_config</value>
     702                </field>
     703              </x>
     704            </configure>
     705          </pubsub>
     706        </iq>
     707        """
     708
     709        def setConfiguration(requestor, service, nodeIdentifier, options):
     710            self.fail("Unexpected call to setConfiguration")
     711
     712        self.service.setConfiguration = setConfiguration
     713        return self.handleRequest(xml)
     714
     715
    548716    def test_onItems(self):
    549717        """
    550718        On a items request, return all items for the given node.
    551719        """
    552         class Handler(pubsub.PubSubService):
    553             def items(self, *args, **kwargs):
    554                 self.args = args
    555                 self.kwargs = kwargs
    556                 return defer.succeed([pubsub.Item('current')])
    557 
    558720        xml = """
    559721        <iq type='get' to='pubsub.example.org'
     
    565727        """
    566728
     729        def items(requestor, service, nodeIdentifier, maxItems, items):
     730            self.assertEqual(JID('user@example.org'), requestor)
     731            self.assertEqual(JID('pubsub.example.org'), service)
     732            self.assertEqual('test', nodeIdentifier)
     733            self.assertIdentical(None, maxItems)
     734            self.assertEqual([], items)
     735            return defer.succeed([pubsub.Item('current')])
     736
    567737        def cb(element):
    568             self.assertEqual((JID('user@example.org'),
    569                               JID('pubsub.example.org'), 'test', None, []),
    570                              handler.args)
    571 
    572738            self.assertEqual(NS_PUBSUB, element.uri)
    573739            self.assertEqual(NS_PUBSUB, element.items.uri)
     
    579745            self.assertEqual('current', item['id'])
    580746
    581         handler = Handler()
    582         d = self.handleRequest(handler, parseXml(xml))
    583         d.addCallback(cb)
    584         return d
     747        self.service.items = items
     748        d = self.handleRequest(xml)
     749        d.addCallback(cb)
     750        return d
Note: See TracChangeset for help on using the changeset viewer.