def test_getNotificationsMultipleNodes(self):
"""
Ensure that entities that subscribe to a leaf node as well as the
root node get exactly one notification.
"""
item = pubsub.Item()
sub = pubsub.Subscription('test', OWNER, 'subscribed')
subRoot = pubsub.Subscription('', OWNER, 'subscribed')
class TestNode:
def getSubscriptions(self, state=None):
return [sub]
class TestRootNode:
def getSubscriptions(self, state=None):
return [subRoot]
def cb(result):
self.assertEquals(1, len(result))
subscriber, subscriptions, items = result[-1]
self.assertEquals(OWNER, subscriber)
self.assertEquals(set([sub, subRoot]), subscriptions)
self.assertEquals([item], items)
self.storage = self.NodeStore({'test': TestNode(), '': TestRootNode()})
self.backend = backend.BackendService(self.storage)
d = self.backend.getNotifications('test', [item])
d.addCallback(cb)
return d
def test_publishNoID(self):
"""
Test publish request with an item without a node identifier.
"""
class TestNode:
nodeType = 'leaf'
nodeIdentifier = 'node'
def getAffiliation(self, entity):
if entity.userhostJID() == OWNER:
return defer.succeed('owner')
def getConfiguration(self):
return {
'pubsub#deliver_payloads': True,
'pubsub#persist_items': False
}
class TestStorage:
def getNode(self, nodeIdentifier):
return defer.succeed(TestNode())
def checkID(notification):
self.assertNotIdentical(None, notification['items'][0]['id'])
self.storage = TestStorage()
self.backend = backend.BackendService(self.storage)
self.storage.backend = self.backend
self.backend.registerNotifier(checkID)
items = [pubsub.Item()]
d = self.backend.publish('node', items, OWNER_FULL)
return d
def test_getNotificationsRoot(self):
"""
Ensure subscribers to the root node show up in the notification list
for leaf nodes.
This assumes a flat node relationship model with exactly one collection
node: the root node. Each leaf node is automatically a child node
of the root node.
"""
item = pubsub.Item()
subRoot = pubsub.Subscription('', OWNER, 'subscribed')
class TestNode:
def getSubscriptions(self, state=None):
return []
class TestRootNode:
def getSubscriptions(self, state=None):
return [subRoot]
def cb(result):
self.assertEquals(1, len(result))
subscriber, subscriptions, items = result[-1]
self.assertEquals(OWNER, subscriber)
self.assertEquals(set([subRoot]), subscriptions)
self.assertEquals([item], items)
self.storage = self.NodeStore({'test': TestNode(), '': TestRootNode()})
self.backend = backend.BackendService(self.storage)
d = self.backend.getNotifications('test', [item])
d.addCallback(cb)
return d
def items(requestor, service, nodeIdentifier, maxItems, items):
self.assertEqual(JID('*****@*****.**'), requestor)
self.assertEqual(JID('pubsub.example.org'), service)
self.assertEqual('test', nodeIdentifier)
self.assertIdentical(None, maxItems)
self.assertEqual([], items)
return defer.succeed([pubsub.Item('current')])
def test_publish(self):
"""
Test sending publish request.
"""
item = pubsub.Item()
d = self.protocol.publish(JID('pubsub.example.org'), 'test', [item])
iq = self.stub.output[-1]
self.assertEquals('pubsub.example.org', iq.getAttribute('to'))
self.assertEquals('set', iq.getAttribute('type'))
self.assertEquals('pubsub', iq.pubsub.name)
self.assertEquals(NS_PUBSUB, iq.pubsub.uri)
children = list(
domish.generateElementsQNamed(iq.pubsub.children, 'publish',
NS_PUBSUB))
self.assertEquals(1, len(children))
child = children[0]
self.assertEquals('test', child['node'])
items = list(
domish.generateElementsQNamed(child.children, 'item', NS_PUBSUB))
self.assertEquals(1, len(items))
self.assertIdentical(item, items[0])
response = toResponse(iq, 'result')
self.stub.send(response)
return d
def entriesDiscovered(self, handle, feed, entries):
log.msg("%s: publishing items" % handle)
node = self._getNode(handle)
items = []
for entry in entries:
try:
entryDoc = self.writer.generate(feed, entry)
except domish.ParserError:
log.err(
None,
'%s: Error processing entry: %r' % (handle, entry.title))
else:
items.append(pubsub.Item(entry.id, entryDoc))
if items:
return self.protocol.publish(self.service, node, items)
else:
return defer.succeed(None)
def test_getNotifications(self):
"""
Ensure subscribers show up in the notification list.
"""
item = pubsub.Item()
sub = pubsub.Subscription('test', OWNER, 'subscribed')
class TestNode:
def getSubscriptions(self, state=None):
return [sub]
def cb(result):
self.assertEquals(1, len(result))
subscriber, subscriptions, items = result[-1]
self.assertEquals(OWNER, subscriber)
self.assertEquals(set([sub]), subscriptions)
self.assertEquals([item], items)
self.storage = self.NodeStore({'test': TestNode()})
self.backend = backend.BackendService(self.storage)
d = self.backend.getNotifications('test', [item])
d.addCallback(cb)
return d