def items(self, requestor, target, nodeIdentifier):
"""
Gather data for a disco items request.
@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}
"""
xmpp_manager = self.parent.manager
items = []
if not target.user and target.host in xmpp_manager.domains:
items.append(
disco.DiscoItem(JID(
'%s.%s' % (XMPPGatewayConfig.muc_prefix, target.host)),
name='Multi-User Chat'))
return defer.succeed(items)
def getDiscoItems(self, requestor, target, nodeIdentifier):
if nodeIdentifier or self.hideNodes:
return defer.succeed([])
d = self.getNodes(requestor, target)
d.addCallback(lambda nodes: [disco.DiscoItem(target, node)
for node in nodes])
return d
def items(requestor, target, nodeIdentifier):
self.assertEqual(JID('*****@*****.**'), requestor)
self.assertEqual(JID('example.com'), target)
self.assertEqual('', nodeIdentifier)
return defer.succeed([
disco.DiscoItem(JID('example.com'), 'test', 'Test node'),
])
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 getDiscoItems(self, req, target, ni):
group, nick = resolveGroup(target)
if group is None:
# Return list of groups
items = [disco.DiscoItem(gr.groupJid(), name=gr.name)
for gr in self.groupset.values()]
return items
else:
# TODO
return []
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_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 getDiscoItems(self, requestor, target, nodeIdentifier=''):
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])
return d
def test_itemsNotDeferred(self):
"""
C{info} should also collect results not returned via a deferred.
"""
discoItems = [disco.DiscoItem(JID('example.com'), 'test', 'Test node')]
@implementer(disco.IDisco)
class DiscoResponder(XMPPHandler):
def getDiscoItems(self, requestor, target, nodeIdentifier):
if not nodeIdentifier:
return discoItems
else:
return []
def cb(result):
self.assertEquals(discoItems, result)
self.service.parent = [self.service, DiscoResponder()]
d = self.service.items(JID('*****@*****.**'), 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')]
@implementer(disco.IDisco)
class DiscoResponder(XMPPHandler):
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('*****@*****.**'), JID('example.com'), '')
d.addCallback(cb)
return d
def getDiscoItems(self, requestor, target, node):
myjid = jid.internJID(protocol.default_conn.jid)
return defer.succeed([
disco.DiscoItem(myjid, c.node, c.name)
for c in all_commands.values()
])
