Split all the e2e tests in their own files

Some duplication is avoided, but most importantly: it’s much much cleaner,
easier to find, functions have been cleaned up (functools.partial usages are
now hidden), etc.

tests/end_to_end/functions.py

+from functools import partial
+import collections
+import datetime
+import asyncio
+import time
+import lxml
+import io
+
+common_replacements = {
+    'irc_server_one': 'irc.localhost@biboumi.localhost',
+    'irc_server_two': 'localhost@biboumi.localhost',
+    'irc_host_one': 'irc.localhost',
+    'irc_host_two': 'localhost',
+    'biboumi_host': 'biboumi.localhost',
+    'resource_one': 'resource1',
+    'resource_two': 'resource2',
+    'nick_one': 'Nick',
+    'jid_one': 'first@example.com',
+    'jid_two': 'second@example.com',
+    'jid_admin': 'admin@example.com',
+    'nick_two': 'Bobby',
+    'nick_three': 'Bernard',
+    'lower_nick_one': 'nick',
+    'lower_nick_two': 'bobby',
+}
+
+class SkipStepError(Exception):
+    """
+    Raised by a step when it needs to be skiped, by running
+    the next available step immediately.
+    """
+    pass
+
+class StanzaError(Exception):
+    """
+    Raised when a step fails.
+    """
+    pass
+
+def match(stanza, xpath):
+    tree = lxml.etree.parse(io.StringIO(str(stanza)))
+    matched = tree.xpath(xpath, namespaces={'re': 'http://exslt.org/regular-expressions',
+                                            'muc_user': 'http://jabber.org/protocol/muc#user',
+                                            'muc_owner': 'http://jabber.org/protocol/muc#owner',
+                                            'muc': 'http://jabber.org/protocol/muc',
+                                            'disco_info': 'http://jabber.org/protocol/disco#info',
+                                            'muc_traffic': 'http://jabber.org/protocol/muc#traffic',
+                                            'disco_items': 'http://jabber.org/protocol/disco#items',
+                                            'commands': 'http://jabber.org/protocol/commands',
+                                            'dataform': 'jabber:x:data',
+                                            'version': 'jabber:iq:version',
+                                            'mam': 'urn:xmpp:mam:2',
+                                            'rms': 'http://jabber.org/protocol/rsm',
+                                            'delay': 'urn:xmpp:delay',
+                                            'forward': 'urn:xmpp:forward:0',
+                                            'client': 'jabber:client',
+                                            'rsm': 'http://jabber.org/protocol/rsm',
+                                            'carbon': 'urn:xmpp:carbons:2',
+                                            'hints': 'urn:xmpp:hints',
+                                            'stanza': 'urn:ietf:params:xml:ns:xmpp-stanzas',
+                                            'stable_id': 'urn:xmpp:sid:0'})
+    return matched
+
+def check_xpath(xpaths, xmpp, after, stanza):
+    for xpath in xpaths:
+        expected = True
+        real_xpath = xpath
+        # We can check that a stanza DOESN’T match, by adding a ! before it.
+        if xpath.startswith('!'):
+            expected = False
+            xpath = xpath[1:]
+        matched = match(stanza, xpath)
+        if (expected and not matched) or (not expected and matched):
+            raise StanzaError("Received stanza\n%s\ndid not match expected xpath\n%s" % (stanza, real_xpath))
+    if after:
+        if isinstance(after, collections.Iterable):
+            for af in after:
+                af(stanza, xmpp)
+        else:
+            after(stanza, xmpp)
+
+def check_xpath_optional(xpaths, xmpp, after, stanza):
+    try:
+        check_xpath(xpaths, xmpp, after, stanza)
+    except StanzaError:
+        raise SkipStepError()
+
+def all_xpaths_match(stanza, xpaths):
+    try:
+        check_xpath(xpaths, None, None, stanza)
+    except StanzaError:
+        return False
+    return True
+
+def check_list_of_xpath(list_of_xpaths, xmpp, stanza):
+    found = False
+    for i, xpaths in enumerate(list_of_xpaths):
+        if all_xpaths_match(stanza, xpaths):
+            found = True
+            list_of_xpaths.pop(i)
+            break
+
+    if not found:
+        raise StanzaError("Received stanza “%s” did not match any of the expected xpaths:\n%s" % (stanza, list_of_xpaths))
+
+    if list_of_xpaths:
+        step = partial(expect_unordered_already_formatted, list_of_xpaths)
+        xmpp.scenario.steps.insert(0, step)
+
+def extract_attribute(xpath, name):
+    def f(xpath, name, stanza):
+        matched = match(stanza, xpath)
+        return matched[0].get(name)
+    return partial(f, xpath, name)
+
+def extract_text(xpath, stanza):
+    matched = match(stanza, xpath)
+    return matched[0].text
+
+def save_value(name, func):
+    def f(name, func, stanza, xmpp):
+        xmpp.saved_values[name] = func(stanza)
+    return partial(f, name, func)
+
+def expect_stanza(*args, optional=False, after=None):
+    def f(*xpaths, xmpp, biboumi, optional, after):
+        replacements = common_replacements
+        replacements.update(xmpp.saved_values)
+        check_func = check_xpath if not optional else check_xpath_optional
+        xmpp.stanza_checker = partial(check_func, [xpath.format_map(replacements) for xpath in xpaths], xmpp, after)
+    return partial(f, *args, optional=optional, after=after)
+
+def send_stanza(stanza):
+    def internal(stanza, xmpp, biboumi):
+        replacements = common_replacements
+        replacements.update(xmpp.saved_values)
+        xmpp.send_raw(stanza.format_map(replacements))
+        asyncio.get_event_loop().call_soon(xmpp.run_scenario)
+    return partial(internal, stanza)
+
+def expect_unordered(*args):
+    def f(*lists_of_xpaths, xmpp, biboumi):
+        formatted_list_of_xpaths = []
+        for list_of_xpaths in lists_of_xpaths:
+            formatted_xpaths = []
+            for xpath in list_of_xpaths:
+                formatted_xpath = xpath.format_map(common_replacements)
+                formatted_xpaths.append(formatted_xpath)
+            formatted_list_of_xpaths.append(tuple(formatted_xpaths))
+        expect_unordered_already_formatted(formatted_list_of_xpaths, xmpp, biboumi)
+    return partial(f, *args)
+
+def expect_unordered_already_formatted(formatted_list_of_xpaths, xmpp, biboumi):
+    xmpp.stanza_checker = partial(check_list_of_xpath, formatted_list_of_xpaths, xmpp)
+
+def sleep_for(duration):
+    def f(duration, xmpp, biboumi):
+        time.sleep(duration)
+        asyncio.get_event_loop().call_soon(xmpp.run_scenario)
+    return partial(f, duration)
+
+def save_current_timestamp_plus_delta(key, delta):
+    def f(key, delta, message, xmpp):
+        now_plus_delta = datetime.datetime.utcnow() + delta
+        xmpp.saved_values[key] = now_plus_delta.strftime("%FT%T.967Z")
+    return partial(f, key, delta)

tests/end_to_end/scenarios/__init__.py

+# Do "from scenarios import *" instead of repeating these imports everytime in every scenario
+
+from functions import expect_stanza, send_stanza, expect_unordered, save_value, extract_attribute, extract_text, sleep_for, save_current_timestamp_plus_delta
+import datetime
+import sequences
+import scenarios.simple_channel_join
+import scenarios.channel_join_with_two_users
+import scenarios.simple_channel_join_fixed
+import scenarios.channel_join_on_fixed_irc_server
+import scenarios.multiple_channels_join

tests/end_to_end/scenarios/basic_handshake_success.py

+from scenarios import *
+
+scenario = (
+    sequences.handshake(),
+)

tests/end_to_end/scenarios/basic_subscribe_unsubscribe.py

+from scenarios import *
+
+scenario = (
+    sequences.handshake(),
+
+    # Mutual subscription exchange
+    send_stanza("<presence from='{jid_one}' to='{biboumi_host}' type='subscribe' id='subid1' />"),
+    expect_stanza("/presence[@type='subscribed'][@id='subid1']"),
+
+    # Get the current presence of the biboumi gateway
+    expect_stanza("/presence"),
+
+    expect_stanza("/presence[@type='subscribe']"),
+    send_stanza("<presence from='{jid_one}' to='{biboumi_host}' type='subscribed' />"),
+
+    # Unsubscribe
+    send_stanza("<presence from='{jid_one}' to='{biboumi_host}' type='unsubscribe' id='unsubid1' />"),
+    expect_stanza("/presence[@type='unavailable']"),
+    expect_stanza("/presence[@type='unsubscribed']"),
+    expect_stanza("/presence[@type='unsubscribe']"),
+    send_stanza("<presence from='{jid_one}' to='{biboumi_host}' type='unavailable' />"),
+    send_stanza("<presence from='{jid_one}' to='{biboumi_host}' type='unsubscribed' />"),
+)

tests/end_to_end/scenarios/channel_custom_topic.py

+from scenarios import *
+
+import scenarios.simple_channel_join
+
+scenario = (
+    scenarios.simple_channel_join.scenario,
+
+    # First user sets the topic
+    send_stanza("<message from='{jid_one}/{resource_one}' to='#foo%{irc_server_one}' type='groupchat'><subject>TOPIC TEST</subject></message>"),
+    expect_stanza("/message[@from='#foo%{irc_server_one}/{nick_one}'][@type='groupchat'][@to='{jid_one}/{resource_one}']/subject[text()='TOPIC TEST']"),
+
+    # Second user joins
+    send_stanza("<presence from='{jid_two}/{resource_one}' to='#foo%{irc_server_one}/{nick_two}' />"),
+    sequences.connection("irc.localhost", '{jid_two}/{resource_one}'),
+    expect_unordered(
+        [
+            "/presence[@to='{jid_one}/{resource_one}'][@from='#foo%{irc_server_one}/{nick_two}']/muc_user:x/muc_user:item[@affiliation='none'][@jid='{lower_nick_two}%{irc_server_one}/~{nick_two}@localhost'][@role='participant']"
+        ],
+        [
+            "/presence[@to='{jid_two}/{resource_one}'][@from='#foo%{irc_server_one}/{nick_one}']/muc_user:x/muc_user:item[@affiliation='admin'][@role='moderator']"
+        ],
+        [
+            "/presence[@to='{jid_two}/{resource_one}'][@from='#foo%{irc_server_one}/{nick_two}']/muc_user:x/muc_user:item[@affiliation='none'][@jid='{lower_nick_two}%{irc_server_one}/~{nick_two}@localhost'][@role='participant']",
+            "/presence/muc_user:x/muc_user:status[@code='110']"
+        ],
+        [
+            "/message[@from='#foo%{irc_server_one}/{nick_one}'][@type='groupchat']/subject[text()='TOPIC TEST']"
+        ]
+    )
+)

tests/end_to_end/scenarios/channel_force_join.py

+from scenarios import *
+
+import scenarios.channel_join_with_two_users
+
+scenario = (
+    scenarios.channel_join_with_two_users.scenario,
+    # Here we simulate a desynchronization of a client: The client thinks it’s
+    # disconnected from the room, but biboumi still thinks it’s in the room. The
+    # client thus sends a join presence, and biboumi should send everything
+    # (user list, history, etc) in response.
+    send_stanza("<presence from='{jid_one}/{resource_one}' to='#foo%{irc_server_one}/{nick_three}'><x xmlns='http://jabber.org/protocol/muc'/></presence>"),
+    expect_unordered(
+             [
+                  "/presence[@to='{jid_one}/{resource_one}'][@from='#foo%{irc_server_one}/{nick_two}']/muc_user:x/muc_user:item[@affiliation='none'][@role='participant'][@jid='{lower_nick_two}%{irc_server_one}/~{nick_two}@localhost']"
+             ],
+             [
+                  "/presence[@to='{jid_one}/{resource_one}'][@from='#foo%{irc_server_one}/{nick_one}']/muc_user:x/muc_user:item[@affiliation='admin'][@role='moderator']",
+                  "/presence/muc_user:x/muc_user:status[@code='110']"
+             ],
+             [
+                  "/message[@from='#foo%{irc_server_one}'][@type='groupchat']/subject[not(text())]"
+             ]
+    ),
+
+    # And also, that was not the same nickname, so everyone receives a nick change
+    expect_unordered(
+             [
+                  "/presence[@from='#foo%{irc_server_one}/{nick_one}'][@to='{jid_two}/{resource_one}'][@type='unavailable']/muc_user:x/muc_user:item[@nick='Bernard']",
+                  "/presence/muc_user:x/muc_user:status[@code='303']",
+             ],
+             [
+                  "/presence[@from='#foo%{irc_server_one}/{nick_three}'][@to='{jid_two}/{resource_one}']",
+             ],
+             [
+                  "/presence[@from='#foo%{irc_server_one}/{nick_one}'][@to='{jid_one}/{resource_one}'][@type='unavailable']/muc_user:x/muc_user:item[@nick='Bernard']",
+                  "/presence/muc_user:x/muc_user:status[@code='303']",
+                  "/presence/muc_user:x/muc_user:status[@code='110']",
+             ],
+             [
+                  "/presence[@from='#foo%{irc_server_one}/{nick_three}'][@to='{jid_one}/{resource_one}']",
+                  "/presence/muc_user:x/muc_user:status[@code='110']",
+             ],
+    ),
+)
+

tests/end_to_end/scenarios/channel_history.py

+from scenarios import *
+
+scenario = (
+    scenarios.simple_channel_join.scenario,
+
+    # Send one channel message
+    send_stanza("<message from='{jid_one}/{resource_one}' to='#foo%{irc_server_one}' type='groupchat'><body>coucou</body></message>"),
+    expect_stanza("/message[@from='#foo%{irc_server_one}/{nick_one}'][@to='{jid_one}/{resource_one}'][@type='groupchat']/body[text()='coucou']"),
+
+    # Second user joins
+    send_stanza("<presence from='{jid_one}/{resource_two}' to='#foo%{irc_server_one}/{nick_one}' />"),
+    expect_stanza("/presence[@to='{jid_one}/{resource_two}'][@from='#foo%{irc_server_one}/{nick_one}']/muc_user:x/muc_user:item[@affiliation='admin'][@jid='{lower_nick_one}%{irc_server_one}/~{nick_one}@localhost'][@role='moderator']",
+                  "/presence/muc_user:x/muc_user:status[@code='110']"),
+    # Receive the history message
+    expect_stanza("/message[@from='#foo%{irc_server_one}/{nick_one}']/body[text()='coucou']",
+                  "/message/delay:delay[@from='#foo%{irc_server_one}']"),
+    expect_stanza("/message[@from='#foo%{irc_server_one}'][@type='groupchat']/subject[not(text())]"),
+)

tests/end_to_end/scenarios/channel_history_on_fixed_server.py

+from scenarios import *
+
+conf = 'fixed_server'
+
+scenario = (
+    scenarios.channel_join_on_fixed_irc_server.scenario,
+
+    # Send one channel message
+    send_stanza("<message from='{jid_one}/{resource_one}' to='#foo@{biboumi_host}' type='groupchat'><body>coucou</body></message>"),
+    expect_stanza("/message[@from='#foo@{biboumi_host}/{nick_one}'][@to='{jid_one}/{resource_one}'][@type='groupchat']/body[text()='coucou']"),
+
+    # Second user joins
+    send_stanza("<presence from='{jid_one}/{resource_two}' to='#foo@{biboumi_host}/{nick_one}' />"),
+    expect_stanza("/presence[@to='{jid_one}/{resource_two}'][@from='#foo@{biboumi_host}/{nick_one}']/muc_user:x/muc_user:item[@affiliation='admin'][@jid='{lower_nick_one}@{biboumi_host}/~{nick_one}@localhost'][@role='moderator']",
+                  "/presence/muc_user:x/muc_user:status[@code='110']"),
+    # Receive the history message
+    expect_stanza("/message[@from='#foo@{biboumi_host}/{nick_one}']/body[text()='coucou']",
+                  "/message/delay:delay[@from='#foo@{biboumi_host}']"),
+    expect_stanza("/message[@from='#foo@{biboumi_host}'][@type='groupchat']/subject[not(text())]"),
+)

tests/end_to_end/scenarios/channel_join_on_fixed_irc_server.py

+from scenarios import *
+
+conf = "fixed_server"
+
+scenario = (
+    sequences.handshake(),
+    send_stanza("<presence from='{jid_one}/{resource_one}' to='#foo@{biboumi_host}/{nick_one}' />"),
+    sequences.connection("irc.localhost", '{jid_one}/{resource_one}', fixed_irc_server=True),
+    expect_stanza("/message/body[text()='Mode #foo [+nt] by {irc_host_one}']"),
+    expect_stanza("/presence[@to='{jid_one}/{resource_one}'][@from='#foo@{biboumi_host}/{nick_one}']/muc_user:x/muc_user:item[@affiliation='admin'][@role='moderator']",
+                  "/presence/muc_user:x/muc_user:status[@code='110']"),
+    expect_stanza("/message[@from='#foo@{biboumi_host}'][@type='groupchat']/subject[not(text())]"),
+)

tests/end_to_end/scenarios/channel_join_with_different_nick.py

+from scenarios import *
+
+from scenarios.simple_channel_join import expect_self_join_presence
+
+scenario = (
+    sequences.handshake(),
+    send_stanza("<presence from='{jid_one}/{resource_one}' to='#foo%{irc_server_one}/{nick_one}' />"),
+    sequences.connection("irc.localhost", '{jid_one}/{resource_one}'),
+    expect_self_join_presence(jid = '{jid_one}/{resource_one}', chan = "#foo", nick = "{nick_one}"),
+
+    # The same resource joins a different channel with a different nick
+    send_stanza("<presence from='{jid_one}/{resource_one}' to='#bar%{irc_server_one}/{nick_two}' />"),
+    # We must receive a join presence in response, without any nick change (nick_two) must be ignored
+    expect_self_join_presence(jid = '{jid_one}/{resource_one}', chan = "#bar", nick = "{nick_one}"),
+)

tests/end_to_end/scenarios/channel_join_with_password.py

+from scenarios import *
+
+import scenarios.simple_channel_join
+
+scenario = (
+    scenarios.simple_channel_join.scenario,
+
+    # Set a password in the room, by using /mode +k
+    send_stanza("<message from='{jid_one}/{resource_one}' to='#foo%{irc_server_one}' type='groupchat'><body>/mode +k SECRET</body></message>"),
+    expect_stanza("/message[@from='#foo%{irc_server_one}'][@to='{jid_one}/{resource_one}'][@type='groupchat']/body[text()='Mode #foo [+k SECRET] by {nick_one}']"),
+
+    # Second user tries to join, without a password (error ensues)
+    send_stanza("<presence from='{jid_two}/{resource_one}' to='#foo%{irc_server_one}/{nick_two}'/>"),
+    sequences.connection("irc.localhost", '{jid_two}/{resource_one}'),
+    expect_stanza("/message/body[text()='{irc_host_one}: #foo: Cannot join channel (+k) - bad key']"),
+    expect_stanza("/presence[@type='error'][@from='#foo%{irc_server_one}/{nick_two}']/error[@type='auth']/stanza:not-authorized"),
+
+    # Second user joins, with the correct password (success)
+    send_stanza("<presence from='{jid_two}/{resource_one}' to='#foo%{irc_server_one}/{nick_two}'>  <x xmlns='http://jabber.org/protocol/muc'><password>SECRET</password></x></presence>"),
+    expect_unordered(
+        [
+            "/presence[@to='{jid_one}/{resource_one}'][@from='#foo%{irc_server_one}/{nick_two}']/muc_user:x/muc_user:item[@affiliation='none'][@role='participant'][@jid='{lower_nick_two}%{irc_server_one}/~{nick_two}@localhost']"
+        ],
+        [
+            "/presence[@to='{jid_two}/{resource_one}'][@from='#foo%{irc_server_one}/{nick_one}']/muc_user:x/muc_user:item[@affiliation='admin'][@role='moderator']"
+        ],
+        [
+            "/presence[@to='{jid_two}/{resource_one}'][@from='#foo%{irc_server_one}/{nick_two}']/muc_user:x/muc_user:item[@affiliation='none'][@jid='{lower_nick_two}%{irc_server_one}/~{nick_two}@localhost'][@role='participant']",
+            "/presence/muc_user:x/muc_user:status[@code='110']"
+        ],
+        [
+            "/message[@from='#foo%{irc_server_one}'][@type='groupchat']/subject[not(text())]"
+        ]
+    )
+)

tests/end_to_end/scenarios/channel_join_with_two_users.py

+from scenarios import *
+
+scenario = (
+    scenarios.simple_channel_join.scenario,
+
+    # Second user joins
+    send_stanza("<presence from='{jid_two}/{resource_one}' to='#foo%{irc_server_one}/{nick_two}' />"),
+    sequences.connection("irc.localhost", '{jid_two}/{resource_one}'),
+    expect_unordered(
+             [
+                 "/presence[@to='{jid_one}/{resource_one}'][@from='#foo%{irc_server_one}/{nick_two}']/muc_user:x/muc_user:item[@affiliation='none'][@role='participant'][@jid='{lower_nick_two}%{irc_server_one}/~{nick_two}@localhost']"
+             ],
+             [
+                 "/presence[@to='{jid_two}/{resource_one}'][@from='#foo%{irc_server_one}/{nick_one}']/muc_user:x/muc_user:item[@affiliation='admin'][@role='moderator']"
+             ],
+             [
+                 "/presence[@to='{jid_two}/{resource_one}'][@from='#foo%{irc_server_one}/{nick_two}']/muc_user:x/muc_user:item[@affiliation='none'][@jid='{lower_nick_two}%{irc_server_one}/~{nick_two}@localhost'][@role='participant']",
+                 "/presence/muc_user:x/muc_user:status[@code='110']"
+             ],
+             [
+                 "/message[@from='#foo%{irc_server_one}'][@type='groupchat']/subject[not(text())]"
+             ]
+    )
+)
+

tests/end_to_end/scenarios/channel_list_escaping.py

+from scenarios import *
+
+scenario = (
+    sequences.handshake(),
+
+    send_stanza("<presence from='{jid_one}/{resource_one}' to='#true\\2ffalse%{irc_server_one}/{nick_one}' />"),
+    sequences.connection("irc.localhost", '{jid_one}/{resource_one}'),
+    expect_stanza("/message/body[text()='Mode #true/false [+nt] by {irc_host_one}']"),
+    expect_stanza("/presence[@to='{jid_one}/{resource_one}'][@from='#true\\2ffalse%{irc_server_one}/{nick_one}']/muc_user:x/muc_user:item[@affiliation='admin'][@role='moderator']",
+                  "/presence/muc_user:x/muc_user:status[@code='110']"),
+    expect_stanza("/message[@from='#true\\2ffalse%{irc_server_one}'][@type='groupchat']/subject[not(text())]"),
+)

tests/end_to_end/scenarios/channel_list_with_rsm.py

+from scenarios import *
+
+scenario = (
+    scenarios.simple_channel_join.scenario,
+
+    send_stanza("<presence from='{jid_one}/{resource_one}' to='#bar%{irc_server_one}/{nick_one}' />"),
+    expect_stanza("/message/body[text()='Mode #bar [+nt] by {irc_host_one}']"),
+    expect_stanza("/presence"),
+    expect_stanza("/message[@from='#bar%{irc_server_one}'][@type='groupchat']/subject[not(text())]"),
+
+    send_stanza("<presence from='{jid_one}/{resource_one}' to='#coucou%{irc_server_one}/{nick_one}' />"),
+    expect_stanza("/message/body[text()='Mode #coucou [+nt] by {irc_host_one}']"),
+    expect_stanza("/presence"),
+    expect_stanza("/message[@from='#coucou%{irc_server_one}'][@type='groupchat']/subject[not(text())]"),
+
+    # Ask for 0 item
+    send_stanza("<iq from='{jid_one}/{resource_one}' id='id1' to='{irc_server_one}' type='get'><query xmlns='http://jabber.org/protocol/disco#items'><set xmlns='http://jabber.org/protocol/rsm'><max>0</max></set></query></iq>"),
+
+    # Get 0 item
+    expect_stanza("/iq[@type='result']/disco_items:query"),
+
+    # Ask for 2 (of 3) items We don’t have the count,
+    # because biboumi doesn’t have the complete list when
+    # it sends us the 2 items
+    send_stanza("<iq from='{jid_one}/{resource_one}' id='id1' to='{irc_server_one}' type='get'><query xmlns='http://jabber.org/protocol/disco#items'><set xmlns='http://jabber.org/protocol/rsm'><max>2</max></set></query></iq>"),
+    expect_stanza("/iq[@type='result']/disco_items:query",
+                  "/iq/disco_items:query/disco_items:item[@jid='#bar%{irc_server_one}']",
+                  "/iq/disco_items:query/disco_items:item[@jid='#coucou%{irc_server_one}']",
+                  "/iq/disco_items:query/rsm:set/rsm:first[text()='#bar%{irc_server_one}'][@index='0']",
+                  "/iq/disco_items:query/rsm:set/rsm:last[text()='#coucou%{irc_server_one}']"),
+
+    # Ask for 12 (of 3) items. We get the whole list, and thus we have the count included.
+    send_stanza("<iq from='{jid_one}/{resource_one}' id='id1' to='{irc_server_one}' type='get'><query xmlns='http://jabber.org/protocol/disco#items'><set xmlns='http://jabber.org/protocol/rsm'><max>12</max></set></query></iq>"),
+    expect_stanza("/iq[@type='result']/disco_items:query",
+                  "/iq/disco_items:query/disco_items:item[@jid='#bar%{irc_server_one}']",
+                  "/iq/disco_items:query/disco_items:item[@jid='#coucou%{irc_server_one}']",
+                  "/iq/disco_items:query/disco_items:item[@jid='#foo%{irc_server_one}']",
+                  "/iq/disco_items:query/rsm:set/rsm:first[text()='#bar%{irc_server_one}'][@index='0']",
+                  "/iq/disco_items:query/rsm:set/rsm:last[text()='#foo%{irc_server_one}']",
+                  "/iq/disco_items:query/rsm:set/rsm:count[text()='3']"),
+
+    # Ask for 1 item, AFTER the first item (so,
+    # the second). Since we don’t invalidate the cache
+    # with this request, we should have the count
+    # included.
+    send_stanza("<iq from='{jid_one}/{resource_one}' id='id1' to='{irc_server_one}' type='get'><query xmlns='http://jabber.org/protocol/disco#items'><set xmlns='http://jabber.org/protocol/rsm'><after>#bar%{irc_server_one}</after><max>1</max></set></query></iq>"),
+    expect_stanza("/iq[@type='result']/disco_items:query",
+                  "/iq/disco_items:query/disco_items:item[@jid='#coucou%{irc_server_one}']",
+                  "/iq/disco_items:query/rsm:set/rsm:first[text()='#coucou%{irc_server_one}'][@index='1']",
+                  "/iq/disco_items:query/rsm:set/rsm:last[text()='#coucou%{irc_server_one}']",
+                  "/iq/disco_items:query/rsm:set/rsm:count[text()='3']"),
+
+    # Ask for 1 item, AFTER the second item (so,
+    # the third).
+    send_stanza("<iq from='{jid_one}/{resource_one}' id='id1' to='{irc_server_one}' type='get'><query xmlns='http://jabber.org/protocol/disco#items'><set xmlns='http://jabber.org/protocol/rsm'><after>#coucou%{irc_server_one}</after><max>1</max></set></query></iq>"),
+    expect_stanza("/iq[@type='result']/disco_items:query",
+                  "/iq/disco_items:query/disco_items:item[@jid='#foo%{irc_server_one}']",
+                  "/iq/disco_items:query/rsm:set/rsm:first[text()='#foo%{irc_server_one}'][@index='2']",
+                  "/iq/disco_items:query/rsm:set/rsm:last[text()='#foo%{irc_server_one}']",
+                  "/iq/disco_items:query/rsm:set/rsm:count[text()='3']"),
+
+    # Ask for 1 item, AFTER the third item (so,
+    # the fourth). Since it doesn't exist, we get 0 item
+    send_stanza("<iq from='{jid_one}/{resource_one}' id='id1' to='{irc_server_one}' type='get'><query xmlns='http://jabber.org/protocol/disco#items'><set xmlns='http://jabber.org/protocol/rsm'><after>#foo%{irc_server_one}</after><max>1</max></set></query></iq>"),
+    expect_stanza("/iq[@type='result']/disco_items:query",
+                  "/iq/disco_items:query/rsm:set/rsm:count[text()='3']"),
+)

tests/end_to_end/scenarios/channel_messages.py

+from scenarios import *
+
+import scenarios.simple_channel_join
+
+scenario = (
+    scenarios.simple_channel_join.scenario,
+
+    # Second user joins
+    send_stanza("<presence from='{jid_two}/{resource_one}' to='#foo%{irc_server_one}/{nick_two}' />"),
+    sequences.connection("irc.localhost", '{jid_two}/{resource_one}'),
+
+    # Our presence, sent to the other user, and ourself
+    expect_unordered(
+        ["/presence[@to='{jid_one}/{resource_one}'][@from='#foo%{irc_server_one}/{nick_two}']/muc_user:x/muc_user:item[@affiliation='none'][@jid='{lower_nick_two}%{irc_server_one}/~{nick_two}@localhost'][@role='participant']"],
+        ["/presence[@to='{jid_two}/{resource_one}'][@from='#foo%{irc_server_one}/{nick_one}']/muc_user:x/muc_user:item[@affiliation='admin'][@role='moderator']"],
+        [
+            "/presence[@to='{jid_two}/{resource_one}'][@from='#foo%{irc_server_one}/{nick_two}']/muc_user:x/muc_user:item[@affiliation='none'][@jid='{lower_nick_two}%{irc_server_one}/~{nick_two}@localhost'][@role='participant']",
+            "/presence/muc_user:x/muc_user:status[@code='110']"
+        ],
+        ["/message[@from='#foo%{irc_server_one}'][@type='groupchat']/subject[not(text())]"],
+    ),
+
+    # Send a channel message
+    send_stanza("<message from='{jid_one}/{resource_one}' to='#foo%{irc_server_one}' type='groupchat'><body>coucou</body></message>"),
+    # Receive the message, forwarded to the two users
+    expect_unordered(
+        [
+            "/message[@from='#foo%{irc_server_one}/{nick_one}'][@to='{jid_one}/{resource_one}'][@type='groupchat']/body[text()='coucou']",
+            "/message/stable_id:stanza-id[@by='#foo%{irc_server_one}'][@id]"
+        ],
+        [
+            "/message[@from='#foo%{irc_server_one}/{nick_one}'][@to='{jid_two}/{resource_one}'][@type='groupchat']/body[text()='coucou']",
+            "/message/stable_id:stanza-id[@by='#foo%{irc_server_one}'][@id]"
+        ]
+    ),
+
+    # Send a private message, to a in-room JID
+    send_stanza("<message from='{jid_one}/{resource_one}' to='#foo%{irc_server_one}/{nick_two}' type='chat'><body>coucou in private</body></message>"),
+    # Message is received with a server-wide JID
+    expect_stanza("/message[@from='{lower_nick_one}%{irc_server_one}'][@to='{jid_two}/{resource_one}'][@type='chat']/body[text()='coucou in private']"),
+    # Respond to the message, to the server-wide JID
+    send_stanza("<message from='{jid_two}/{resource_one}' to='{lower_nick_one}%{irc_server_one}' type='chat'><body>yes</body></message>"),
+    # The response is received from the in-room JID
+    expect_stanza("/message[@from='#foo%{irc_server_one}/{nick_two}'][@to='{jid_one}/{resource_one}'][@type='chat']/body[text()='yes']",
+                  "/message/muc_user:x"),
+    # Do the exact same thing, from a different chan,
+    # to check if the response comes from the right JID
+    send_stanza("<presence from='{jid_one}/{resource_one}' to='#dummy%{irc_server_one}/{nick_one}' />"),
+    expect_stanza("/message"),
+    expect_stanza("/presence/muc_user:x/muc_user:status[@code='110']"),
+    expect_stanza("/message[@from='#dummy%{irc_server_one}'][@type='groupchat']/subject"),
+    # Send a private message, to a in-room JID
+    send_stanza("<message from='{jid_one}/{resource_one}' to='#dummy%{irc_server_one}/{nick_two}' type='chat'><body>re in private</body></message>"),
+
+    # Message is received with a server-wide JID
+    expect_stanza("/message[@from='{lower_nick_one}%{irc_server_one}'][@to='{jid_two}/{resource_one}'][@type='chat']/body[text()='re in private']"),
+
+    # Respond to the message, to the server-wide JID
+    send_stanza("<message from='{jid_two}/{resource_one}' to='{lower_nick_one}%{irc_server_one}' type='chat'><body>re</body></message>"),
+    # The response is received from the in-room JID
+    expect_stanza("/message[@from='#dummy%{irc_server_one}/{nick_two}'][@to='{jid_one}/{resource_one}'][@type='chat']/body[text()='re']"),
+
+    # Now we leave the room, to check if the subsequent private messages are still received properly
+    send_stanza("<presence from='{jid_one}/{resource_one}' to='#dummy%{irc_server_one}/{nick_one}' type='unavailable' />"),
+    expect_stanza("/presence[@type='unavailable']/muc_user:x/muc_user:status[@code='110']"),
+
+    # The private messages from this nick should now come (again) from the server-wide JID
+    send_stanza("<message from='{jid_two}/{resource_one}' to='{lower_nick_one}%{irc_server_one}' type='chat'><body>hihihoho</body></message>"),
+    expect_stanza("/message[@from='{lower_nick_two}%{irc_server_one}'][@to='{jid_one}/{resource_one}']"),
+)

tests/end_to_end/scenarios/client_error.py

+from scenarios import *
+
+scenario = (
+    scenarios.simple_channel_join.scenario,
+    # Second resource, same channel
+    send_stanza("<presence from='{jid_one}/{resource_two}' to='#foo%{irc_server_one}/{nick_one}' />"),
+    expect_stanza("/presence[@to='{jid_one}/{resource_two}'][@from='#foo%{irc_server_one}/{nick_one}']/muc_user:x/muc_user:item[@affiliation='admin'][@role='moderator']",