Mercurial > libervia-backend
changeset 999:c37a24922f27
plugin XEP_0033: fixes the server part and the tests
| author | souliane <souliane@mailoo.org> |
|---|---|
| date | Fri, 11 Apr 2014 11:02:42 +0200 |
| parents | f5761534e0f3 |
| children | 6f1e03068b5f |
| files | src/core/sat_main.py src/plugins/plugin_xep_0033.py src/test/helpers.py src/test/test_plugin_xep_0033.py |
| diffstat | 4 files changed, 88 insertions(+), 40 deletions(-) [+] |
line wrap: on
line diff
--- a/src/core/sat_main.py Wed Apr 23 12:01:59 2014 +0200 +++ b/src/core/sat_main.py Fri Apr 11 11:02:42 2014 +0200 @@ -58,7 +58,7 @@ history by the trigger, so the rest of the process should be stopped. This should normally be raised by the trigger with the minimal priority """ def __init__(self, reason, mess_data): - Exception(reason) + Exception.__init__(self, reason) self.mess_data = mess_data # added for testing purpose
--- a/src/plugins/plugin_xep_0033.py Wed Apr 23 12:01:59 2014 +0200 +++ b/src/plugins/plugin_xep_0033.py Fri Apr 11 11:02:42 2014 +0200 @@ -82,13 +82,14 @@ if not 'address' in mess_data['extra']: return mess_data - def discoCallback(entity): - if entity is None: + def discoCallback(entities): + if not entities: return Failure(AbortSendMessage(_("XEP-0033 is being used but the server doesn't support it!"))) - if mess_data["to"] != entity: - log.warning(_("Stanzas using XEP-0033 should be addressed to %(expected)s, not %(current)s!") % {'expected': entity, 'current': mess_data["to"]}) - log.warning(_("TODO: addressing has be fixed by the backend... fix it in the frontend!")) - mess_data["to"] = entity + if mess_data["to"] not in entities: + expected = _(' or ').join([entity.userhost() for entity in entities]) + log.warning(_("Stanzas using XEP-0033 should be addressed to %(expected)s, not %(current)s!") % {'expected': expected, 'current': mess_data["to"]}) + log.warning(_("TODO: addressing has been fixed by the backend... fix it in the frontend!")) + mess_data["to"] = list(entities)[0].userhostJID() element = mess_data['xml'].addElement('addresses', NS_ADDRESS) entries = [entry.split(':') for entry in mess_data['extra']['address'].split('\n') if entry != ''] for type_, jid_ in entries: @@ -96,7 +97,7 @@ # when the prosody plugin is completed, we can immediately return mess_data from here self.sendAndStoreMessage(mess_data, entries, profile) return Failure(MessageSentAndStored("XEP-0033 took over", mess_data)) - d = self.host.requestServerDisco(NS_ADDRESS, profile_key=profile) + d = self.host.findFeaturesSet([NS_ADDRESS], profile_key=profile) d.addCallbacks(discoCallback, lambda dummy: discoCallback(None)) return d @@ -116,19 +117,22 @@ - redesign the database to save only one entry to the database - change the newMessage signal to eventually pass more than one recipient """ - def discoCallback(entity, to_jid): - new_data = copy.deepcopy(mess_data) - new_data['to'] = JID(to_jid) - new_data['xml']['to'] = to_jid - if entity: - if entity not in self.internal_data[timestamp]: - self.host.sendAndStoreMessage(mess_data, False, profile) - self.internal_data[timestamp].append(entity) + def discoCallback(entities, to_jid_s): + history_data = copy.deepcopy(mess_data) + history_data['to'] = JID(to_jid_s) + history_data['xml']['to'] = to_jid_s + if entities: + if entities not in self.internal_data[timestamp]: + sent_data = copy.deepcopy(mess_data) + sent_data['to'] = JID(JID(to_jid_s).host) + sent_data['xml']['to'] = JID(to_jid_s).host + self.host.sendAndStoreMessage(sent_data, False, profile) + self.internal_data[timestamp].append(entities) # we still need to fill the history and signal the echo... - self.host.sendAndStoreMessage(new_data, True, profile) + self.host.sendAndStoreMessage(history_data, True, profile) else: # target server misses the addressing feature - self.host.sendAndStoreMessage(new_data, False, profile) + self.host.sendAndStoreMessage(history_data, False, profile) def errback(failure, to_jid): discoCallback(None, to_jid) @@ -138,9 +142,9 @@ defer_list = [] for type_, jid_ in entries: d = defer.Deferred() - d.addCallback(self.host.requestServerDisco, JID(JID(jid_).host), profile_key=profile) + d.addCallback(self.host.findFeaturesSet, jid_=JID(JID(jid_).host), profile_key=profile) d.addCallbacks(discoCallback, errback, callbackArgs=[jid_], errbackArgs=[jid_]) - d.callback(NS_ADDRESS) + d.callback([NS_ADDRESS]) defer_list.append(d) d = defer.Deferred().addCallback(lambda dummy: self.internal_data.pop(timestamp)) defer.DeferredList(defer_list).chainDeferred(d)
--- a/src/test/helpers.py Wed Apr 23 12:01:59 2014 +0200 +++ b/src/test/helpers.py Fri Apr 11 11:02:42 2014 +0200 @@ -93,7 +93,6 @@ if not skip_send: self.sent_messages.append(mess_data["to"]) self.stored_messages.append(mess_data["to"]) - pass def getClient(self, profile_key): """Convenient method to get client from profile key @@ -131,6 +130,33 @@ entry = self.getSentMessageRaw(profile_index) return entry.toXml() if entry else None + def findFeaturesSet(self, features, category=None, type_=None, jid_=None, profile_key=None): + """Call self.addFeature from your tests to change the return value. + + @return: a set of entities + """ + client = self.getClient(profile_key) + if jid_ is None: + jid_ = JID(client.jid.host) + try: + if set(features).issubset(client.features[jid_]): + return defer.succeed(set([jid_])) + except (TypeError, AttributeError, KeyError): + pass + return defer.succeed(set()) + + def addFeature(self, jid_, feature, profile_key): + """Add a feature to an entity. + + To be called from your tests when needed. + """ + client = self.getClient(profile_key) + if not hasattr(client, 'features'): + client.features = {} + if jid_ not in client.features: + client.features[jid_] = set() + client.features[jid_].add(feature) + class FakeBridge(object): """Class to simulate and test bridge calls"""
--- a/src/test/test_plugin_xep_0033.py Wed Apr 23 12:01:59 2014 +0200 +++ b/src/test/test_plugin_xep_0033.py Fri Apr 11 11:02:42 2014 +0200 @@ -31,9 +31,15 @@ from twisted.words.protocols.jabber.jid import JID from logging import ERROR +PROFILE = Const.PROFILE[0] +JID_STR_FROM = Const.JID_STR[1] +JID_STR_TO = Const.PROFILE_DICT[PROFILE].host +JID_STR_X_TO = Const.JID_STR[0] +JID_STR_X_CC = Const.JID_STR[1] +JID_STR_X_BCC = Const.JID_STR[2] + class XEP_0033Test(helpers.SatTestCase): - skip = "Must be fixed after disco changes" def setUp(self): self.host = helpers.FakeSAT() @@ -50,15 +56,14 @@ <address type='bcc' jid='%s'/> </addresses> </message> - """ % (Const.JID_STR[1], self.host.getClientHostJid(Const.PROFILE[0]), - Const.JID_STR[0], Const.JID_STR[1], Const.JID_STR[2]) + """ % (JID_STR_FROM, JID_STR_TO, JID_STR_X_TO, JID_STR_X_CC, JID_STR_X_BCC) stanza = parseXml(xml.encode("utf-8")) treatments = defer.Deferred() - self.plugin.messageReceivedTrigger(stanza, treatments, Const.PROFILE[0]) + self.plugin.messageReceivedTrigger(stanza, treatments, PROFILE) data = {'extra': {}} def cb(data): - expected = ('to', Const.JID_STR[0], 'cc', Const.JID_STR[1], 'bcc', Const.JID_STR[2]) + expected = ('to', JID_STR_X_TO, 'cc', JID_STR_X_CC, 'bcc', JID_STR_X_BCC) msg = 'Expected: %s\nGot: %s' % (expected, data['extra']['addresses']) self.assertEqual(data['extra']['addresses'], '%s:%s\n%s:%s\n%s:%s\n' % expected, msg) @@ -66,18 +71,18 @@ treatments.callback(data) def test_sendMessageTrigger(self): - mess_data = {"to": self.host.getClientHostJid(Const.PROFILE[0]), + mess_data = {"to": JID(JID_STR_TO), "type": "chat", "message": "content", "extra": {} } - addresses = ('to', Const.JID_STR[0], 'cc', Const.JID_STR[1], 'bcc', Const.JID_STR[2]) + addresses = ('to', JID_STR_X_TO, 'cc', JID_STR_X_CC, 'bcc', JID_STR_X_BCC) mess_data["extra"]["address"] = '%s:%s\n%s:%s\n%s:%s\n' % addresses original_stanza = u""" <message type="chat" from="%s" to="%s" id="test_1"> <body>content</body> </message> - """ % (Const.JID_STR[1], self.host.getClientHostJid(Const.PROFILE[0])) + """ % (JID_STR_FROM, JID_STR_TO) mess_data['xml'] = parseXml(original_stanza.encode("utf-8")) expected = deepcopy(mess_data['xml']) addresses_extra = """ @@ -97,29 +102,28 @@ def sendMessageErrback(failure, exception_class): """If the failure does encapsulate the expected exception, it will be silently trapped, otherwise it will be re-raised and will make the test fail""" + failure.trap(exception_class) if exception_class == MessageSentAndStored: assertAddresses(failure.value.mess_data) - failure.trap(exception_class) def checkSentAndStored(): """Check that all the recipients got their messages and that the history has been filled. /!\ see the comments in XEP_0033.sendAndStoreMessage""" sent = [] stored = [] - cache = set() - for to_s in [addresses[1], addresses[3], addresses[5]]: + for to_s in (JID_STR_X_TO, JID_STR_X_CC, JID_STR_X_BCC): to_jid = JID(to_s) host = JID(to_jid.host) logger = getLogger() level = logger.getEffectiveLevel() logger.setLevel(ERROR) # remove log.warning pollution - if self.host.memory.hasServerFeature(plugin.NS_ADDRESS, host, Const.PROFILE[0]): - if host not in cache: + entities = yield self.host.findFeaturesSet([plugin.NS_ADDRESS], jid_=host, profile_key=PROFILE) + if host in entities: + if host not in sent: # send the message to the entity offering the feature sent.append(host) stored.append(host) - cache.add(host) - stored.append(to_jid) - else: + stored.append(to_jid) # store in history for each recipient + else: # feature not supported, use normal behavior sent.append(to_jid) stored.append(to_jid) logger.setLevel(level) @@ -140,7 +144,7 @@ logger.setLevel(ERROR) # remove log.warning pollution pre_treatments = defer.Deferred() post_treatments = defer.Deferred() - self.plugin.sendMessageTrigger(data, pre_treatments, post_treatments, Const.PROFILE[0]) + self.plugin.sendMessageTrigger(data, pre_treatments, post_treatments, PROFILE) post_treatments.callback(data) logger.setLevel(level) post_treatments.addCallbacks(assertAddresses, lambda failure: sendMessageErrback(failure, exception)) @@ -150,9 +154,20 @@ data = deepcopy(mess_data) trigger(data, AbortSendMessage) - # feature is supported + # feature is supported by the main target server self.host.init() self.host.memory.init() + self.host.addFeature(JID(JID_STR_TO), plugin.NS_ADDRESS, PROFILE) + data = deepcopy(mess_data) + trigger(data, MessageSentAndStored) + checkSentAndStored() + + # feature is supported by all target servers + self.host.init() + self.host.memory.init() + self.host.addFeature(JID(JID_STR_TO), plugin.NS_ADDRESS, PROFILE) + for dest in (JID_STR_X_TO, JID_STR_X_CC, JID_STR_X_BCC): + self.host.addFeature(JID(JID(dest).host), plugin.NS_ADDRESS, PROFILE) data = deepcopy(mess_data) trigger(data, MessageSentAndStored) checkSentAndStored() @@ -160,7 +175,10 @@ # check that a wrong recipient entity is fixed by the backend self.host.init() self.host.memory.init() + self.host.addFeature(JID(JID_STR_TO), plugin.NS_ADDRESS, PROFILE) + for dest in (JID_STR_X_TO, JID_STR_X_CC, JID_STR_X_BCC): + self.host.addFeature(JID(JID(dest).host), plugin.NS_ADDRESS, PROFILE) data = deepcopy(mess_data) - data["to"] = Const.JID[0] + data["to"] = JID(JID_STR_X_TO) trigger(data, MessageSentAndStored) checkSentAndStored()