im-changing.ru
/
converse.js
miroir de https://github.com/conversejs/converse.js.git


			
							12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139
							(function (root, factory) {
    define(["jasmine", "mock", "test-utils"], factory);
} (this, function (jasmine, mock, test_utils) {
    "use strict";
    const _ = converse.env._;
    const Backbone = converse.env.Backbone;
    const Strophe = converse.env.Strophe;
    const $iq = converse.env.$iq;
    const $msg = converse.env.$msg;
    const dayjs = converse.env.dayjs;
    const u = converse.env.utils;
    const sizzle = converse.env.sizzle;
    // See: https://xmpp.org/rfcs/rfc3921.html

    // Implements the protocol defined in https://xmpp.org/extensions/xep-0313.html#config
    describe("Message Archive Management", function () {

        describe("The XEP-0313 Archive", function () {

            it("is queried when the user enters a new MUC",
                mock.initConverse(
                    null, ['discoInitialized'], {'archived_messages_page_size': 2},
                    async function (done, _converse) {

                spyOn(_converse.ChatBox.prototype, 'fetchArchivedMessages').and.callThrough();
                const sent_IQs = _converse.connection.IQ_stanzas;
                const muc_jid = 'orchard@chat.shakespeare.lit';
                await test_utils.openAndEnterChatRoom(_converse, muc_jid, 'romeo');
                let view = _converse.chatboxviews.get(muc_jid);
                let iq_get = await u.waitUntil(() => sent_IQs.filter(iq => iq.querySelector(`iq query[xmlns="${Strophe.NS.MAM}"]`)).pop());
                expect(Strophe.serialize(iq_get)).toBe(
                    `<iq id="${iq_get.getAttribute('id')}" to="${muc_jid}" type="set" xmlns="jabber:client">`+
                        `<query queryid="${iq_get.querySelector('query').getAttribute('queryid')}" xmlns="${Strophe.NS.MAM}">`+
                            `<x type="submit" xmlns="jabber:x:data">`+
                                `<field type="hidden" var="FORM_TYPE"><value>urn:xmpp:mam:2</value></field>`+
                            `</x>`+
                            `<set xmlns="http://jabber.org/protocol/rsm"><max>2</max><before></before></set>`+
                        `</query>`+
                    `</iq>`);

                let first_msg_id = _converse.connection.getUniqueId();
                let last_msg_id = _converse.connection.getUniqueId();
                let message = u.toStanza(
                    `<message xmlns="jabber:client"
                            to="romeo@montague.lit/orchard"
                            from="${muc_jid}">
                        <result xmlns="urn:xmpp:mam:2" queryid="${iq_get.querySelector('query').getAttribute('queryid')}" id="${first_msg_id}">
                            <forwarded xmlns="urn:xmpp:forward:0">
                                <delay xmlns="urn:xmpp:delay" stamp="2018-01-09T06:15:23Z"/>
                                <message from="${muc_jid}/some1" type="groupchat">
                                    <body>2nd Message</body>
                                </message>
                            </forwarded>
                        </result>
                    </message>`);
                _converse.connection._dataRecv(test_utils.createRequest(message));

                message = u.toStanza(
                    `<message xmlns="jabber:client"
                            to="romeo@montague.lit/orchard"
                            from="${muc_jid}">
                        <result xmlns="urn:xmpp:mam:2" queryid="${iq_get.querySelector('query').getAttribute('queryid')}" id="${last_msg_id}">
                            <forwarded xmlns="urn:xmpp:forward:0">
                                <delay xmlns="urn:xmpp:delay" stamp="2018-01-09T06:16:23Z"/>
                                <message from="${muc_jid}/some1" type="groupchat">
                                    <body>3rd Message</body>
                                </message>
                            </forwarded>
                        </result>
                    </message>`);
                _converse.connection._dataRecv(test_utils.createRequest(message));

                // Clear so that we don't match the older query
                while (sent_IQs.length) { sent_IQs.pop(); }

                // XXX: Even though the count is 3, when fetching messages for
                // the first time, we don't paginate, so that message
                // is not fetched. The user needs to manually load older
                // messages for it to be fetched.
                // TODO: we need to add a clickable link to load older messages
                let result = u.toStanza(
                    `<iq type='result' id='${iq_get.getAttribute('id')}'>
                        <fin xmlns='urn:xmpp:mam:2'>
                            <set xmlns='http://jabber.org/protocol/rsm'>
                                <first index='0'>${first_msg_id}</first>
                                <last>${last_msg_id}</last>
                                <count>3</count>
                            </set>
                        </fin>
                    </iq>`);
                _converse.connection._dataRecv(test_utils.createRequest(result));
                await u.waitUntil(() => view.model.messages.length === 2);
                view.close();
                // Clear so that we don't match the older query
                while (sent_IQs.length) { sent_IQs.pop(); }

                await u.waitUntil(() => _converse.chatboxes.length === 1);
                await test_utils.openAndEnterChatRoom(_converse, muc_jid, 'romeo');
                view = _converse.chatboxviews.get(muc_jid);
                await u.waitUntil(() => view.model.messages.length);

                iq_get = await u.waitUntil(() => sent_IQs.filter(iq => iq.querySelector(`iq query[xmlns="${Strophe.NS.MAM}"]`)).pop());
                expect(Strophe.serialize(iq_get)).toBe(
                    `<iq id="${iq_get.getAttribute('id')}" to="${muc_jid}" type="set" xmlns="jabber:client">`+
                        `<query queryid="${iq_get.querySelector('query').getAttribute('queryid')}" xmlns="${Strophe.NS.MAM}">`+
                            `<x type="submit" xmlns="jabber:x:data">`+
                                `<field type="hidden" var="FORM_TYPE"><value>urn:xmpp:mam:2</value></field>`+
                            `</x>`+
                            `<set xmlns="http://jabber.org/protocol/rsm"><max>2</max><after>${message.querySelector('result').getAttribute('id')}</after></set>`+
                        `</query>`+
                    `</iq>`);

                first_msg_id = _converse.connection.getUniqueId();
                last_msg_id = _converse.connection.getUniqueId();
                message = u.toStanza(
                    `<message xmlns="jabber:client"
                            to="romeo@montague.lit/orchard"
                            from="${muc_jid}">
                        <result xmlns="urn:xmpp:mam:2" queryid="${iq_get.querySelector('query').getAttribute('queryid')}" id="${first_msg_id}">
                            <forwarded xmlns="urn:xmpp:forward:0">
                                <delay xmlns="urn:xmpp:delay" stamp="2018-01-09T06:17:23Z"/>
                                <message from="${muc_jid}/some1" type="groupchat">
                                    <body>4th Message</body>
                                </message>
                            </forwarded>
                        </result>
                    </message>`);
                _converse.connection._dataRecv(test_utils.createRequest(message));

                message = u.toStanza(
                    `<message xmlns="jabber:client"
                            to="romeo@montague.lit/orchard"
                            from="${muc_jid}">
                        <result xmlns="urn:xmpp:mam:2" queryid="${iq_get.querySelector('query').getAttribute('queryid')}" id="${last_msg_id}">
                            <forwarded xmlns="urn:xmpp:forward:0">
                                <delay xmlns="urn:xmpp:delay" stamp="2018-01-09T06:18:23Z"/>
                                <message from="${muc_jid}/some1" type="groupchat">
                                    <body>5th Message</body>
                                </message>
                            </forwarded>
                        </result>
                    </message>`);
                _converse.connection._dataRecv(test_utils.createRequest(message));

                // Clear so that we don't match the older query
                while (sent_IQs.length) { sent_IQs.pop(); }

                result = u.toStanza(
                    `<iq type='result' id='${iq_get.getAttribute('id')}'>
                        <fin xmlns='urn:xmpp:mam:2'>
                            <set xmlns='http://jabber.org/protocol/rsm'>
                                <first index='0'>${first_msg_id}</first>
                                <last>${last_msg_id}</last>
                                <count>5</count>
                            </set>
                        </fin>
                    </iq>`);
                _converse.connection._dataRecv(test_utils.createRequest(result));
                await u.waitUntil(() => view.model.messages.length === 4);

                iq_get = await u.waitUntil(() => sent_IQs.filter(iq => iq.querySelector(`iq query[xmlns="${Strophe.NS.MAM}"]`)).pop());
                expect(Strophe.serialize(iq_get)).toBe(
                    `<iq id="${iq_get.getAttribute('id')}" to="orchard@chat.shakespeare.lit" type="set" xmlns="jabber:client">`+
                        `<query queryid="${iq_get.querySelector('query').getAttribute('queryid')}" xmlns="urn:xmpp:mam:2">`+
                            `<x type="submit" xmlns="jabber:x:data">`+
                                `<field type="hidden" var="FORM_TYPE"><value>urn:xmpp:mam:2</value></field>`+
                            `</x>`+
                            `<set xmlns="http://jabber.org/protocol/rsm">`+
                                `<max>2</max><after>${last_msg_id}</after>`+
                            `</set>`+
                        `</query>`+
                    `</iq>`);

                const msg_id = _converse.connection.getUniqueId();
                message = u.toStanza(
                    `<message xmlns="jabber:client"
                            to="romeo@montague.lit/orchard"
                            from="${muc_jid}">
                        <result xmlns="urn:xmpp:mam:2" queryid="${iq_get.querySelector('query').getAttribute('queryid')}" id="${msg_id}">
                            <forwarded xmlns="urn:xmpp:forward:0">
                                <delay xmlns="urn:xmpp:delay" stamp="2018-01-09T06:19:23Z"/>
                                <message from="${muc_jid}/some1" type="groupchat">
                                    <body>6th Message</body>
                                </message>
                            </forwarded>
                        </result>
                    </message>`);
                _converse.connection._dataRecv(test_utils.createRequest(message));

                result = u.toStanza(
                    `<iq type='result' id='${iq_get.getAttribute('id')}'>
                        <fin xmlns="urn:xmpp:mam:2" complete="true">
                            <set xmlns="http://jabber.org/protocol/rsm">
                                <first index="0">${msg_id}</first>
                                <last>${msg_id}</last>
                                <count>6</count>
                            </set>
                        </fin>
                    </iq>`);
                _converse.connection._dataRecv(test_utils.createRequest(result));
                await u.waitUntil(() => view.model.messages.length === 5);
                expect(view.model.fetchArchivedMessages.calls.count()).toBe(3);
                const msg_els = view.content.querySelectorAll('.chat-msg__text');
                expect(Array.from(msg_els).map(e => e.textContent).join(' ')).toBe("2nd Message 3rd Message 4th Message 5th Message 6th Message");
                done();
            }));
        });

        describe("An archived message", function () {

            describe("when recieved", function () {

                it("is discarded if it doesn't come from the right sender",
                    mock.initConverse(
                        null, ['discoInitialized'], {},
                        async function (done, _converse) {

                    await test_utils.waitForRoster(_converse, 'current', 1);
                    const contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@montague.lit';
                    await test_utils.openChatBoxFor(_converse, contact_jid);
                    await test_utils.waitUntilDiscoConfirmed(_converse, _converse.bare_jid, null, [Strophe.NS.MAM]);
                    const sent_IQs = _converse.connection.IQ_stanzas;
                    const stanza = await u.waitUntil(() => sent_IQs.filter(iq => iq.querySelector(`iq[type="set"] query[xmlns="${Strophe.NS.MAM}"]`)).pop());
                    const queryid = stanza.querySelector('query').getAttribute('queryid');
                    let msg = $msg({'id': _converse.connection.getUniqueId(), 'from': 'impersonator@capulet.lit', 'to': _converse.bare_jid})
                                .c('result',  {'xmlns': 'urn:xmpp:mam:2', 'queryid':queryid, 'id': _converse.connection.getUniqueId()})
                                    .c('forwarded', {'xmlns':'urn:xmpp:forward:0'})
                                        .c('delay', {'xmlns':'urn:xmpp:delay', 'stamp':'2010-07-10T23:08:25Z'}).up()
                                        .c('message', {
                                            'xmlns':'jabber:client',
                                            'to': _converse.bare_jid,
                                            'id': _converse.connection.getUniqueId(),
                                            'from': contact_jid,
                                            'type':'chat'
                                        }).c('body').t("Meet me at the dance");
                    spyOn(_converse, 'log');
                    _converse.connection._dataRecv(test_utils.createRequest(msg));
                    expect(_converse.log).toHaveBeenCalledWith(`Ignoring alleged MAM message from ${msg.nodeTree.getAttribute('from')}`, Strophe.LogLevel.WARN);

                    msg = $msg({'id': _converse.connection.getUniqueId(), 'to': _converse.bare_jid})
                                .c('result',  {'xmlns': 'urn:xmpp:mam:2', 'queryid':queryid, 'id': _converse.connection.getUniqueId()})
                                    .c('forwarded', {'xmlns':'urn:xmpp:forward:0'})
                                        .c('delay', {'xmlns':'urn:xmpp:delay', 'stamp':'2010-07-10T23:08:25Z'}).up()
                                        .c('message', {
                                            'xmlns':'jabber:client',
                                            'to': _converse.bare_jid,
                                            'id': _converse.connection.getUniqueId(),
                                            'from': contact_jid,
                                            'type':'chat'
                                        }).c('body').t("Thrice the brinded cat hath mew'd.");
                    _converse.connection._dataRecv(test_utils.createRequest(msg));

                    const iq_result = $iq({'type': 'result', 'id': stanza.getAttribute('id')})
                        .c('fin', {'xmlns': 'urn:xmpp:mam:2'})
                            .c('set',  {'xmlns': 'http://jabber.org/protocol/rsm'})
                                .c('first', {'index': '0'}).t('23452-4534-1').up()
                                .c('last').t('09af3-cc343-b409f').up()
                                .c('count').t('16');
                    _converse.connection._dataRecv(test_utils.createRequest(iq_result));

                    const view = _converse.chatboxviews.get(contact_jid);
                    await new Promise((resolve, reject) => view.once('messageInserted', resolve));
                    expect(view.model.messages.length).toBe(1);
                    expect(view.model.messages.at(0).get('message')).toBe("Thrice the brinded cat hath mew'd.");
                    done();
                }));


                it("updates the is_archived value of an already cached version",
                    mock.initConverse(
                        null, ['discoInitialized'], {},
                        async function (done, _converse) {

                    await test_utils.openAndEnterChatRoom(_converse, 'trek-radio@conference.lightwitch.org', 'romeo');

                    const view = _converse.chatboxviews.get('trek-radio@conference.lightwitch.org');
                    let stanza = u.toStanza(
                        `<message xmlns="jabber:client" to="romeo@montague.lit/orchard" type="groupchat" from="trek-radio@conference.lightwitch.org/some1">
                            <body>Hello</body>
                            <stanza-id xmlns="urn:xmpp:sid:0" id="45fbbf2a-1059-479d-9283-c8effaf05621" by="trek-radio@conference.lightwitch.org"/>
                        </message>`);
                    _converse.connection._dataRecv(test_utils.createRequest(stanza));
                    await u.waitUntil(() => view.content.querySelectorAll('.chat-msg').length);
                    expect(view.model.messages.length).toBe(1);
                    expect(view.model.messages.at(0).get('is_archived')).toBe(false);
                    expect(view.model.messages.at(0).get('stanza_id trek-radio@conference.lightwitch.org')).toBe('45fbbf2a-1059-479d-9283-c8effaf05621');

                    stanza = u.toStanza(
                        `<message xmlns="jabber:client"
                                to="romeo@montague.lit/orchard"
                                from="trek-radio@conference.lightwitch.org">
                            <result xmlns="urn:xmpp:mam:2" queryid="82d9db27-6cf8-4787-8c2c-5a560263d823" id="45fbbf2a-1059-479d-9283-c8effaf05621">
                                <forwarded xmlns="urn:xmpp:forward:0">
                                    <delay xmlns="urn:xmpp:delay" stamp="2018-01-09T06:17:23Z"/>
                                    <message from="trek-radio@conference.lightwitch.org/some1" type="groupchat">
                                        <body>Hello</body>
                                    </message>
                                </forwarded>
                            </result>
                        </message>`);
                    spyOn(view.model, 'findDuplicateFromArchiveID').and.callThrough();
                    spyOn(view.model, 'updateMessage').and.callThrough();
                    view.model.onMessage(stanza);
                    await u.waitUntil(() => view.model.findDuplicateFromArchiveID.calls.count());
                    expect(view.model.findDuplicateFromArchiveID.calls.count()).toBe(1);
                    const result = await view.model.findDuplicateFromArchiveID.calls.all()[0].returnValue
                    expect(result instanceof _converse.Message).toBe(true);
                    expect(view.content.querySelectorAll('.chat-msg').length).toBe(1);

                    await u.waitUntil(() => view.model.updateMessage.calls.count());
                    expect(view.model.messages.length).toBe(1);
                    expect(view.model.messages.at(0).get('is_archived')).toBe(true);
                    expect(view.model.messages.at(0).get('stanza_id trek-radio@conference.lightwitch.org')).toBe('45fbbf2a-1059-479d-9283-c8effaf05621');
                    done();
                }));

                it("isn't shown as duplicate by comparing its stanza id or archive id",
                    mock.initConverse(
                        null, ['discoInitialized'], {},
                        async function (done, _converse) {

                    await test_utils.openAndEnterChatRoom(_converse, 'trek-radio@conference.lightwitch.org', 'jcbrand');
                    const view = _converse.chatboxviews.get('trek-radio@conference.lightwitch.org');
                    let stanza = u.toStanza(
                        `<message xmlns="jabber:client" to="jcbrand@lightwitch.org/converse.js-73057452" type="groupchat" from="trek-radio@conference.lightwitch.org/comndrdukath#0805 (STO)">
                            <body>negan</body>
                            <stanza-id xmlns="urn:xmpp:sid:0" id="45fbbf2a-1059-479d-9283-c8effaf05621" by="trek-radio@conference.lightwitch.org"/>
                        </message>`);
                    _converse.connection._dataRecv(test_utils.createRequest(stanza));
                    await u.waitUntil(() => view.content.querySelectorAll('.chat-msg').length);
                    // Not sure whether such a race-condition might pose a problem
                    // in "real-world" situations.
                    stanza = u.toStanza(
                        `<message xmlns="jabber:client"
                                to="jcbrand@lightwitch.org/converse.js-73057452"
                                from="trek-radio@conference.lightwitch.org">
                            <result xmlns="urn:xmpp:mam:2" queryid="82d9db27-6cf8-4787-8c2c-5a560263d823" id="45fbbf2a-1059-479d-9283-c8effaf05621">
                                <forwarded xmlns="urn:xmpp:forward:0">
                                    <delay xmlns="urn:xmpp:delay" stamp="2018-01-09T06:17:23Z"/>
                                    <message from="trek-radio@conference.lightwitch.org/comndrdukath#0805 (STO)" type="groupchat">
                                        <body>negan</body>
                                    </message>
                                </forwarded>
                            </result>
                        </message>`);
                    spyOn(view.model, 'findDuplicateFromArchiveID').and.callThrough();
                    view.model.onMessage(stanza);
                    await u.waitUntil(() => view.model.findDuplicateFromArchiveID.calls.count());
                    expect(view.model.findDuplicateFromArchiveID.calls.count()).toBe(1);
                    const result = await view.model.findDuplicateFromArchiveID.calls.all()[0].returnValue
                    expect(result instanceof _converse.Message).toBe(true);
                    expect(view.content.querySelectorAll('.chat-msg').length).toBe(1);
                    done();
                }));

                it("isn't shown as duplicate by comparing only the archive id",
                    mock.initConverse(
                        null, ['discoInitialized'], {},
                        async function (done, _converse) {

                    await test_utils.openAndEnterChatRoom(_converse, 'discuss@conference.conversejs.org', 'romeo');
                    const view = _converse.chatboxviews.get('discuss@conference.conversejs.org');
                    let stanza = u.toStanza(
                        `<message xmlns="jabber:client" to="romeo@montague.lit/orchard" from="discuss@conference.conversejs.org">
                            <result xmlns="urn:xmpp:mam:2" queryid="06fea9ca-97c9-48c4-8583-009ff54ea2e8" id="7a9fde91-4387-4bf8-b5d3-978dab8f6bf3">
                                <forwarded xmlns="urn:xmpp:forward:0">
                                    <delay xmlns="urn:xmpp:delay" stamp="2018-12-05T04:53:12Z"/>
                                    <message xmlns="jabber:client" to="discuss@conference.conversejs.org" type="groupchat" xml:lang="en" from="discuss@conference.conversejs.org/prezel">
                                        <body>looks like omemo fails completely with "bundle is undefined" when there is a device in the devicelist that has no keys published</body>
                                        <x xmlns="http://jabber.org/protocol/muc#user">
                                            <item affiliation="none" jid="prezel@blubber.im" role="participant"/>
                                        </x>
                                    </message>
                                </forwarded>
                            </result>
                        </message>`);
                    view.model.onMessage(stanza);
                    await u.waitUntil(() => view.content.querySelectorAll('.chat-msg').length);
                    expect(view.content.querySelectorAll('.chat-msg').length).toBe(1);

                    stanza = u.toStanza(
                        `<message xmlns="jabber:client" to="romeo@montague.lit/orchard" from="discuss@conference.conversejs.org">
                            <result xmlns="urn:xmpp:mam:2" queryid="06fea9ca-97c9-48c4-8583-009ff54ea2e8" id="7a9fde91-4387-4bf8-b5d3-978dab8f6bf3">
                                <forwarded xmlns="urn:xmpp:forward:0">
                                    <delay xmlns="urn:xmpp:delay" stamp="2018-12-05T04:53:12Z"/>
                                    <message xmlns="jabber:client" to="discuss@conference.conversejs.org" type="groupchat" xml:lang="en" from="discuss@conference.conversejs.org/prezel">
                                        <body>looks like omemo fails completely with "bundle is undefined" when there is a device in the devicelist that has no keys published</body>
                                        <x xmlns="http://jabber.org/protocol/muc#user">
                                            <item affiliation="none" jid="prezel@blubber.im" role="participant"/>
                                        </x>
                                    </message>
                                </forwarded>
                            </result>
                        </message>`);

                    spyOn(view.model, 'findDuplicateFromArchiveID').and.callThrough();
                    view.model.onMessage(stanza);
                    await u.waitUntil(() => view.model.findDuplicateFromArchiveID.calls.count());
                    expect(view.model.findDuplicateFromArchiveID.calls.count()).toBe(1);
                    const result = await view.model.findDuplicateFromArchiveID.calls.all()[0].returnValue
                    expect(result instanceof _converse.Message).toBe(true);
                    expect(view.content.querySelectorAll('.chat-msg').length).toBe(1);
                    done();
                }))
            });
        });

        describe("The archive.query API", function () {

           it("can be used to query for all archived messages",
                mock.initConverse(
                    null, ['discoInitialized'], {},
                    async function (done, _converse) {

                const sendIQ = _converse.connection.sendIQ;
                await test_utils.waitUntilDiscoConfirmed(_converse, _converse.bare_jid, null, [Strophe.NS.MAM]);
                let sent_stanza, IQ_id;
                spyOn(_converse.connection, 'sendIQ').and.callFake(function (iq, callback, errback) {
                    sent_stanza = iq;
                    IQ_id = sendIQ.bind(this)(iq, callback, errback);
                });
                _converse.api.archive.query();
                await u.waitUntil(() => sent_stanza);
                const queryid = sent_stanza.nodeTree.querySelector('query').getAttribute('queryid');
                expect(sent_stanza.toString()).toBe(
                    `<iq id="${IQ_id}" type="set" xmlns="jabber:client"><query queryid="${queryid}" xmlns="urn:xmpp:mam:2"/></iq>`);
                done();
            }));

           it("can be used to query for all messages to/from a particular JID",
                mock.initConverse(
                    null, [], {},
                    async function (done, _converse) {

                await test_utils.waitUntilDiscoConfirmed(_converse, _converse.bare_jid, null, [Strophe.NS.MAM]);
                let sent_stanza, IQ_id;
                const sendIQ = _converse.connection.sendIQ;
                spyOn(_converse.connection, 'sendIQ').and.callFake(function (iq, callback, errback) {
                    sent_stanza = iq;
                    IQ_id = sendIQ.bind(this)(iq, callback, errback);
                });
                _converse.api.archive.query({'with':'juliet@capulet.lit'});
                await u.waitUntil(() => sent_stanza);
                const queryid = sent_stanza.nodeTree.querySelector('query').getAttribute('queryid');
                expect(sent_stanza.toString()).toBe(
                    `<iq id="${IQ_id}" type="set" xmlns="jabber:client">`+
                        `<query queryid="${queryid}" xmlns="urn:xmpp:mam:2">`+
                            `<x type="submit" xmlns="jabber:x:data">`+
                            `<field type="hidden" var="FORM_TYPE">`+
                                `<value>urn:xmpp:mam:2</value>`+
                            `</field>`+
                            `<field var="with">`+
                                `<value>juliet@capulet.lit</value>`+
                            `</field>`+
                            `</x>`+
                        `</query>`+
                    `</iq>`);
                done();
            }));

           it("can be used to query for archived messages from a chat room",
                mock.initConverse(
                    null, [], {},
                    async function (done, _converse) {

                const room_jid = 'coven@chat.shakespeare.lit';
                _converse.api.archive.query({'with': room_jid, 'groupchat': true});
                await test_utils.waitUntilDiscoConfirmed(_converse, room_jid, null, [Strophe.NS.MAM]);

                const sent_stanzas = _converse.connection.sent_stanzas;
                const stanza = await u.waitUntil(
                    () => sent_stanzas.filter(s => sizzle(`[xmlns="${Strophe.NS.MAM}"]`, s).length).pop());

                const queryid = stanza.querySelector('query').getAttribute('queryid');
                expect(Strophe.serialize(stanza)).toBe(
                    `<iq id="${stanza.getAttribute('id')}" to="coven@chat.shakespeare.lit" type="set" xmlns="jabber:client">`+
                        `<query queryid="${queryid}" xmlns="urn:xmpp:mam:2">`+
                            `<x type="submit" xmlns="jabber:x:data">`+
                                `<field type="hidden" var="FORM_TYPE">`+
                                    `<value>urn:xmpp:mam:2</value>`+
                                `</field>`+
                            `</x>`+
                        `</query>`+
                    `</iq>`);
                done();
           }));

            it("checks whether returned MAM messages from a MUC room are from the right JID",
                mock.initConverse(
                    null, [], {},
                    async function (done, _converse) {

                const room_jid = 'coven@chat.shakespeare.lit';
                const promise = _converse.api.archive.query({'with': room_jid, 'groupchat': true, 'max':'10'});

                await test_utils.waitUntilDiscoConfirmed(_converse, room_jid, null, [Strophe.NS.MAM]);

                const sent_stanzas = _converse.connection.sent_stanzas;
                const sent_stanza = await u.waitUntil(
                    () => sent_stanzas.filter(s => sizzle(`[xmlns="${Strophe.NS.MAM}"]`, s).length).pop());
                const queryid = sent_stanza.querySelector('query').getAttribute('queryid');

                /* <message id='iasd207' from='coven@chat.shakespeare.lit' to='hag66@shakespeare.lit/pda'>
                 *     <result xmlns='urn:xmpp:mam:2' queryid='g27' id='34482-21985-73620'>
                 *         <forwarded xmlns='urn:xmpp:forward:0'>
                 *         <delay xmlns='urn:xmpp:delay' stamp='2002-10-13T23:58:37Z'/>
                 *         <message xmlns="jabber:client"
                 *             from='coven@chat.shakespeare.lit/firstwitch'
                 *             id='162BEBB1-F6DB-4D9A-9BD8-CFDCC801A0B2'
                 *             type='groupchat'>
                 *             <body>Thrice the brinded cat hath mew'd.</body>
                 *             <x xmlns='http://jabber.org/protocol/muc#user'>
                 *             <item affiliation='none'
                 *                     jid='witch1@shakespeare.lit'
                 *                     role='participant' />
                 *             </x>
                 *         </message>
                 *         </forwarded>
                 *     </result>
                 * </message>
                 */
                const msg1 = $msg({'id':'iasd207', 'from': 'other@chat.shakespear.lit', 'to': 'romeo@montague.lit'})
                            .c('result',  {'xmlns': 'urn:xmpp:mam:2', 'queryid':queryid, 'id':'34482-21985-73620'})
                                .c('forwarded', {'xmlns':'urn:xmpp:forward:0'})
                                    .c('delay', {'xmlns':'urn:xmpp:delay', 'stamp':'2010-07-10T23:08:25Z'}).up()
                                    .c('message', {
                                        'xmlns':'jabber:client',
                                        'to':'romeo@montague.lit',
                                        'id':'162BEBB1-F6DB-4D9A-9BD8-CFDCC801A0B2',
                                        'from':'coven@chat.shakespeare.lit/firstwitch',
                                        'type':'groupchat' })
                                    .c('body').t("Thrice the brinded cat hath mew'd.");
                _converse.connection._dataRecv(test_utils.createRequest(msg1));

                /* Send an <iq> stanza to indicate the end of the result set.
                 *
                 * <iq type='result' id='juliet1'>
                 *     <fin xmlns='urn:xmpp:mam:2'>
                 *     <set xmlns='http://jabber.org/protocol/rsm'>
                 *         <first index='0'>28482-98726-73623</first>
                 *         <last>09af3-cc343-b409f</last>
                 *         <count>20</count>
                 *     </set>
                 * </iq>
                 */
                const stanza = $iq({'type': 'result', 'id': sent_stanza.getAttribute('id')})
                    .c('fin', {'xmlns': 'urn:xmpp:mam:2'})
                        .c('set',  {'xmlns': 'http://jabber.org/protocol/rsm'})
                            .c('first', {'index': '0'}).t('23452-4534-1').up()
                            .c('last').t('09af3-cc343-b409f').up()
                            .c('count').t('16');
                _converse.connection._dataRecv(test_utils.createRequest(stanza));

                const result = await promise;
                expect(result.messages.length).toBe(0);
                done();
           }));

           it("can be used to query for all messages in a certain timespan",
                mock.initConverse(
                    null, [], {},
                    async function (done, _converse) {

                await test_utils.waitUntilDiscoConfirmed(_converse, _converse.bare_jid, null, [Strophe.NS.MAM]);
                let sent_stanza, IQ_id;
                const sendIQ = _converse.connection.sendIQ;
                spyOn(_converse.connection, 'sendIQ').and.callFake(function (iq, callback, errback) {
                    sent_stanza = iq;
                    IQ_id = sendIQ.bind(this)(iq, callback, errback);
                });
                const start = '2010-06-07T00:00:00Z';
                const end = '2010-07-07T13:23:54Z';
                _converse.api.archive.query({
                    'start': start,
                    'end': end
                });
                await u.waitUntil(() => sent_stanza);
                const queryid = sent_stanza.nodeTree.querySelector('query').getAttribute('queryid');
                expect(sent_stanza.toString()).toBe(
                    `<iq id="${IQ_id}" type="set" xmlns="jabber:client">`+
                        `<query queryid="${queryid}" xmlns="urn:xmpp:mam:2">`+
                            `<x type="submit" xmlns="jabber:x:data">`+
                            `<field type="hidden" var="FORM_TYPE">`+
                                `<value>urn:xmpp:mam:2</value>`+
                            `</field>`+
                            `<field var="start">`+
                                `<value>${dayjs(start).toISOString()}</value>`+
                            `</field>`+
                            `<field var="end">`+
                                `<value>${dayjs(end).toISOString()}</value>`+
                            `</field>`+
                            `</x>`+
                        `</query>`+
                    `</iq>`
                );
                done();
           }));

           it("throws a TypeError if an invalid date is provided",
                mock.initConverse(
                    null, [], {},
                    async function (done, _converse) {

                await test_utils.waitUntilDiscoConfirmed(_converse, _converse.bare_jid, null, [Strophe.NS.MAM]);
                try {
                    await _converse.api.archive.query({'start': 'not a real date'});
                } catch (e) {
                    expect(() => {throw e}).toThrow(new TypeError('archive.query: invalid date provided for: start'));
                }
                done();
           }));

           it("can be used to query for all messages after a certain time",
                mock.initConverse(
                    null, [], {},
                    async function (done, _converse) {

                await test_utils.waitUntilDiscoConfirmed(_converse, _converse.bare_jid, null, [Strophe.NS.MAM]);
                let sent_stanza, IQ_id;
                const sendIQ = _converse.connection.sendIQ;
                spyOn(_converse.connection, 'sendIQ').and.callFake(function (iq, callback, errback) {
                    sent_stanza = iq;
                    IQ_id = sendIQ.bind(this)(iq, callback, errback);
                });
                if (!_converse.disco_entities.get(_converse.domain).features.findWhere({'var': Strophe.NS.MAM})) {
                    _converse.disco_entities.get(_converse.domain).features.create({'var': Strophe.NS.MAM});
                }
                const start = '2010-06-07T00:00:00Z';
                _converse.api.archive.query({'start': start});
                await u.waitUntil(() => sent_stanza);
                const queryid = sent_stanza.nodeTree.querySelector('query').getAttribute('queryid');
                expect(sent_stanza.toString()).toBe(
                    `<iq id="${IQ_id}" type="set" xmlns="jabber:client">`+
                        `<query queryid="${queryid}" xmlns="urn:xmpp:mam:2">`+
                            `<x type="submit" xmlns="jabber:x:data">`+
                            `<field type="hidden" var="FORM_TYPE">`+
                                `<value>urn:xmpp:mam:2</value>`+
                            `</field>`+
                            `<field var="start">`+
                                `<value>${dayjs(start).toISOString()}</value>`+
                            `</field>`+
                            `</x>`+
                        `</query>`+
                    `</iq>`
                );
                done();
           }));

           it("can be used to query for a limited set of results",
                mock.initConverse(
                    null, [], {},
                    async function (done, _converse) {

                await test_utils.waitUntilDiscoConfirmed(_converse, _converse.bare_jid, null, [Strophe.NS.MAM]);
                let sent_stanza, IQ_id;
                const sendIQ = _converse.connection.sendIQ;
                spyOn(_converse.connection, 'sendIQ').and.callFake(function (iq, callback, errback) {
                    sent_stanza = iq;
                    IQ_id = sendIQ.bind(this)(iq, callback, errback);
                });
                const start = '2010-06-07T00:00:00Z';
                _converse.api.archive.query({'start': start, 'max':10});
                await u.waitUntil(() => sent_stanza);
                const queryid = sent_stanza.nodeTree.querySelector('query').getAttribute('queryid');
                expect(sent_stanza.toString()).toBe(
                    `<iq id="${IQ_id}" type="set" xmlns="jabber:client">`+
                        `<query queryid="${queryid}" xmlns="urn:xmpp:mam:2">`+
                            `<x type="submit" xmlns="jabber:x:data">`+
                                `<field type="hidden" var="FORM_TYPE">`+
                                    `<value>urn:xmpp:mam:2</value>`+
                                `</field>`+
                                `<field var="start">`+
                                    `<value>${dayjs(start).toISOString()}</value>`+
                                `</field>`+
                            `</x>`+
                            `<set xmlns="http://jabber.org/protocol/rsm">`+
                                `<max>10</max>`+
                            `</set>`+
                        `</query>`+
                    `</iq>`
                );
                done();
           }));

           it("can be used to page through results",
                mock.initConverse(
                    null, [], {},
                    async function (done, _converse) {

                await test_utils.waitUntilDiscoConfirmed(_converse, _converse.bare_jid, null, [Strophe.NS.MAM]);
                let sent_stanza, IQ_id;
                const sendIQ = _converse.connection.sendIQ;
                spyOn(_converse.connection, 'sendIQ').and.callFake(function (iq, callback, errback) {
                    sent_stanza = iq;
                    IQ_id = sendIQ.bind(this)(iq, callback, errback);
                });
                const start = '2010-06-07T00:00:00Z';
                _converse.api.archive.query({
                    'start': start,
                    'after': '09af3-cc343-b409f',
                    'max':10
                });
                await u.waitUntil(() => sent_stanza);
                const queryid = sent_stanza.nodeTree.querySelector('query').getAttribute('queryid');
                expect(sent_stanza.toString()).toBe(
                    `<iq id="${IQ_id}" type="set" xmlns="jabber:client">`+
                        `<query queryid="${queryid}" xmlns="urn:xmpp:mam:2">`+
                            `<x type="submit" xmlns="jabber:x:data">`+
                                `<field type="hidden" var="FORM_TYPE">`+
                                    `<value>urn:xmpp:mam:2</value>`+
                                `</field>`+
                                `<field var="start">`+
                                    `<value>${dayjs(start).toISOString()}</value>`+
                                `</field>`+
                            `</x>`+
                            `<set xmlns="http://jabber.org/protocol/rsm">`+
                                `<max>10</max>`+
                                `<after>09af3-cc343-b409f</after>`+
                            `</set>`+
                        `</query>`+
                    `</iq>`);
                done();
           }));

           it("accepts \"before\" with an empty string as value to reverse the order",
                mock.initConverse(
                    null, [], {},
                    async function (done, _converse) {

                await test_utils.waitUntilDiscoConfirmed(_converse, _converse.bare_jid, null, [Strophe.NS.MAM]);
                let sent_stanza, IQ_id;
                const sendIQ = _converse.connection.sendIQ;
                spyOn(_converse.connection, 'sendIQ').and.callFake(function (iq, callback, errback) {
                    sent_stanza = iq;
                    IQ_id = sendIQ.bind(this)(iq, callback, errback);
                });
                _converse.api.archive.query({'before': '', 'max':10});
                await u.waitUntil(() => sent_stanza);
                const queryid = sent_stanza.nodeTree.querySelector('query').getAttribute('queryid');
                expect(sent_stanza.toString()).toBe(
                    `<iq id="${IQ_id}" type="set" xmlns="jabber:client">`+
                        `<query queryid="${queryid}" xmlns="urn:xmpp:mam:2">`+
                            `<x type="submit" xmlns="jabber:x:data">`+
                                `<field type="hidden" var="FORM_TYPE">`+
                                    `<value>urn:xmpp:mam:2</value>`+
                                `</field>`+
                            `</x>`+
                            `<set xmlns="http://jabber.org/protocol/rsm">`+
                                `<max>10</max>`+
                                `<before></before>`+
                            `</set>`+
                        `</query>`+
                    `</iq>`);
                done();
           }));

           it("accepts a _converse.RSM object for the query options",
                mock.initConverse(
                    null, [], {},
                    async function (done, _converse) {

                await test_utils.waitUntilDiscoConfirmed(_converse, _converse.bare_jid, null, [Strophe.NS.MAM]);
                let sent_stanza, IQ_id;
                const sendIQ = _converse.connection.sendIQ;
                spyOn(_converse.connection, 'sendIQ').and.callFake(function (iq, callback, errback) {
                    sent_stanza = iq;
                    IQ_id = sendIQ.bind(this)(iq, callback, errback);
                });
                // Normally the user wouldn't manually make a _converse.RSM object
                // and pass it in. However, in the callback method an RSM object is
                // returned which can be reused for easy paging. This test is
                // more for that usecase.
                const rsm =  new _converse.RSM({'max': '10'});
                rsm['with'] = 'romeo@montague.lit'; // eslint-disable-line dot-notation
                rsm.start = '2010-06-07T00:00:00Z';
                _converse.api.archive.query(rsm);
                await u.waitUntil(() => sent_stanza);
                const queryid = sent_stanza.nodeTree.querySelector('query').getAttribute('queryid');
                expect(sent_stanza.toString()).toBe(
                    `<iq id="${IQ_id}" type="set" xmlns="jabber:client">`+
                        `<query queryid="${queryid}" xmlns="urn:xmpp:mam:2">`+
                            `<x type="submit" xmlns="jabber:x:data">`+
                                `<field type="hidden" var="FORM_TYPE">`+
                                    `<value>urn:xmpp:mam:2</value>`+
                                `</field>`+
                                `<field var="with">`+
                                    `<value>romeo@montague.lit</value>`+
                                `</field>`+
                                `<field var="start">`+
                                    `<value>${dayjs(rsm.start).toISOString()}</value>`+
                                `</field>`+
                            `</x>`+
                            `<set xmlns="http://jabber.org/protocol/rsm">`+
                                `<max>10</max>`+
                            `</set>`+
                        `</query>`+
                    `</iq>`);
                done();
           }));

           it("returns an object which includes the messages and a _converse.RSM object",
                mock.initConverse(
                    null, [], {},
                    async function (done, _converse) {

                await test_utils.waitUntilDiscoConfirmed(_converse, _converse.bare_jid, null, [Strophe.NS.MAM]);
                let sent_stanza, IQ_id;
                const sendIQ = _converse.connection.sendIQ;
                spyOn(_converse.connection, 'sendIQ').and.callFake(function (iq, callback, errback) {
                    sent_stanza = iq;
                    IQ_id = sendIQ.bind(this)(iq, callback, errback);
                });
                const promise = _converse.api.archive.query({'with': 'romeo@capulet.lit', 'max':'10'});
                await u.waitUntil(() => sent_stanza);
                const queryid = sent_stanza.nodeTree.querySelector('query').getAttribute('queryid');

                /*  <message id='aeb213' to='juliet@capulet.lit/chamber'>
                 *  <result xmlns='urn:xmpp:mam:2' queryid='f27' id='28482-98726-73623'>
                 *      <forwarded xmlns='urn:xmpp:forward:0'>
                 *      <delay xmlns='urn:xmpp:delay' stamp='2010-07-10T23:08:25Z'/>
                 *      <message xmlns='jabber:client'
                 *          to='juliet@capulet.lit/balcony'
                 *          from='romeo@montague.lit/orchard'
                 *          type='chat'>
                 *          <body>Call me but love, and I'll be new baptized; Henceforth I never will be Romeo.</body>
                 *      </message>
                 *      </forwarded>
                 *  </result>
                 *  </message>
                 */
                const msg1 = $msg({'id':'aeb212', 'to':'juliet@capulet.lit/chamber'})
                            .c('result',  {'xmlns': 'urn:xmpp:mam:2', 'queryid':queryid, 'id':'28482-98726-73623'})
                                .c('forwarded', {'xmlns':'urn:xmpp:forward:0'})
                                    .c('delay', {'xmlns':'urn:xmpp:delay', 'stamp':'2010-07-10T23:08:25Z'}).up()
                                    .c('message', {
                                        'xmlns':'jabber:client',
                                        'to':'juliet@capulet.lit/balcony',
                                        'from':'romeo@montague.lit/orchard',
                                        'type':'chat' })
                                    .c('body').t("Call me but love, and I'll be new baptized;");
                _converse.connection._dataRecv(test_utils.createRequest(msg1));

                const msg2 = $msg({'id':'aeb213', 'to':'juliet@capulet.lit/chamber'})
                            .c('result',  {'xmlns': 'urn:xmpp:mam:2', 'queryid':queryid, 'id':'28482-98726-73624'})
                                .c('forwarded', {'xmlns':'urn:xmpp:forward:0'})
                                    .c('delay', {'xmlns':'urn:xmpp:delay', 'stamp':'2010-07-10T23:08:25Z'}).up()
                                    .c('message', {
                                        'xmlns':'jabber:client',
                                        'to':'juliet@capulet.lit/balcony',
                                        'from':'romeo@montague.lit/orchard',
                                        'type':'chat' })
                                    .c('body').t("Henceforth I never will be Romeo.");
                _converse.connection._dataRecv(test_utils.createRequest(msg2));

                /* Send an <iq> stanza to indicate the end of the result set.
                 *
                 * <iq type='result' id='juliet1'>
                 *     <fin xmlns='urn:xmpp:mam:2'>
                 *     <set xmlns='http://jabber.org/protocol/rsm'>
                 *         <first index='0'>28482-98726-73623</first>
                 *         <last>09af3-cc343-b409f</last>
                 *         <count>20</count>
                 *     </set>
                 * </iq>
                 */
                const stanza = $iq({'type': 'result', 'id': IQ_id})
                    .c('fin', {'xmlns': 'urn:xmpp:mam:2'})
                        .c('set',  {'xmlns': 'http://jabber.org/protocol/rsm'})
                            .c('first', {'index': '0'}).t('23452-4534-1').up()
                            .c('last').t('09af3-cc343-b409f').up()
                            .c('count').t('16');
                _converse.connection._dataRecv(test_utils.createRequest(stanza));

                const result = await promise;
                expect(result.messages.length).toBe(2);
                expect(result.messages[0].outerHTML).toBe(msg1.nodeTree.outerHTML);
                expect(result.messages[1].outerHTML).toBe(msg2.nodeTree.outerHTML);
                expect(result.rsm['with']).toBe('romeo@capulet.lit'); // eslint-disable-line dot-notation
                expect(result.rsm.max).toBe('10');
                expect(result.rsm.count).toBe('16');
                expect(result.rsm.first).toBe('23452-4534-1');
                expect(result.rsm.last).toBe('09af3-cc343-b409f');
                done()
           }));
        });

        describe("The default preference", function () {

            it("is set once server support for MAM has been confirmed",
                mock.initConverse(
                    null, [], {},
                    async function (done, _converse) {

                const entity = await _converse.api.disco.entities.get(_converse.domain);
                let  sent_stanza, IQ_id;
                const sendIQ = _converse.connection.sendIQ;
                spyOn(_converse.connection, 'sendIQ').and.callFake(function (iq, callback, errback) {
                    sent_stanza = iq;
                    IQ_id = sendIQ.bind(this)(iq, callback, errback);
                });
                spyOn(_converse, 'onMAMPreferences').and.callThrough();
                _converse.message_archiving = 'never';

                const feature = new Backbone.Model({
                    'var': Strophe.NS.MAM
                });
                spyOn(feature, 'save').and.callFake(feature.set); // Save will complain about a url not being set

                entity.onFeatureAdded(feature);

                expect(_converse.connection.sendIQ).toHaveBeenCalled();
                expect(sent_stanza.toLocaleString()).toBe(
                    `<iq id="${IQ_id}" type="get" xmlns="jabber:client">`+
                        `<prefs xmlns="urn:xmpp:mam:2"/>`+
                    `</iq>`);

                /* Example 20. Server responds with current preferences
                 *
                 * <iq type='result' id='juliet2'>
                 *   <prefs xmlns='urn:xmpp:mam:0' default='roster'>
                 *     <always/>
                 *     <never/>
                 *   </prefs>
                 * </iq>
                 */
                let stanza = $iq({'type': 'result', 'id': IQ_id})
                    .c('prefs', {'xmlns': Strophe.NS.MAM, 'default':'roster'})
                    .c('always').c('jid').t('romeo@montague.lit').up().up()
                    .c('never').c('jid').t('montague@montague.lit');
                _converse.connection._dataRecv(test_utils.createRequest(stanza));

                await u.waitUntil(() => _converse.onMAMPreferences.calls.count());
                expect(_converse.onMAMPreferences).toHaveBeenCalled();

                expect(sent_stanza.toString()).toBe(
                    `<iq id="${IQ_id}" type="set" xmlns="jabber:client">`+
                        `<prefs default="never" xmlns="urn:xmpp:mam:2">`+
                            `<always><jid>romeo@montague.lit</jid></always>`+
                            `<never><jid>montague@montague.lit</jid></never>`+
                        `</prefs>`+
                    `</iq>`
                );

                expect(feature.get('preference')).toBe(undefined);
                /* <iq type='result' id='juliet3'>
                 *   <prefs xmlns='urn:xmpp:mam:0' default='always'>
                 *       <always>
                 *          <jid>romeo@montague.lit</jid>
                 *       </always>
                 *       <never>
                 *          <jid>montague@montague.lit</jid>
                 *       </never>
                 *   </prefs>
                 * </iq>
                 */
                stanza = $iq({'type': 'result', 'id': IQ_id})
                    .c('prefs', {'xmlns': Strophe.NS.MAM, 'default':'always'})
                        .c('always').up()
                        .c('never');
                _converse.connection._dataRecv(test_utils.createRequest(stanza));
                await u.waitUntil(() => feature.save.calls.count());
                expect(feature.save).toHaveBeenCalled();
                expect(feature.get('preferences')['default']).toBe('never'); // eslint-disable-line dot-notation
                done();
            }));
        });
    });

    describe("Chatboxes", function () {
        describe("A Chatbox", function () {

            it("will fetch archived messages once it's opened",
                mock.initConverse(
                    null, ['discoInitialized'], {},
                    async function (done, _converse) {

                await test_utils.waitForRoster(_converse, 'current', 1);
                const contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@montague.lit';
                await test_utils.openChatBoxFor(_converse, contact_jid);
                await test_utils.waitUntilDiscoConfirmed(_converse, _converse.bare_jid, null, [Strophe.NS.MAM]);

                let sent_stanza, IQ_id;
                const sendIQ = _converse.connection.sendIQ;
                spyOn(_converse.connection, 'sendIQ').and.callFake(function (iq, callback, errback) {
                    sent_stanza = iq;
                    IQ_id = sendIQ.bind(this)(iq, callback, errback);
                });
                await u.waitUntil(() => sent_stanza);
                const stanza_el = sent_stanza.root().nodeTree;
                const queryid = stanza_el.querySelector('query').getAttribute('queryid');
                expect(sent_stanza.toString()).toBe(
                    `<iq id="${stanza_el.getAttribute('id')}" type="set" xmlns="jabber:client">`+
                        `<query queryid="${queryid}" xmlns="urn:xmpp:mam:2">`+
                            `<x type="submit" xmlns="jabber:x:data">`+
                                `<field type="hidden" var="FORM_TYPE"><value>urn:xmpp:mam:2</value></field>`+
                                `<field var="with"><value>mercutio@montague.lit</value></field>`+
                            `</x>`+
                            `<set xmlns="http://jabber.org/protocol/rsm"><max>50</max><before></before></set>`+
                        `</query>`+
                    `</iq>`
                );
                const msg1 = $msg({'id':'aeb212', 'to': contact_jid})
                            .c('result',  {'xmlns': 'urn:xmpp:mam:2', 'queryid':queryid, 'id':'28482-98726-73623'})
                                .c('forwarded', {'xmlns':'urn:xmpp:forward:0'})
                                    .c('delay', {'xmlns':'urn:xmpp:delay', 'stamp':'2010-07-10T23:08:25Z'}).up()
                                    .c('message', {
                                        'xmlns':'jabber:client',
                                        'to': contact_jid,
                                        'from': _converse.bare_jid,
                                        'type':'chat' })
                                    .c('body').t("Call me but love, and I'll be new baptized;");
                _converse.connection._dataRecv(test_utils.createRequest(msg1));
                const msg2 = $msg({'id':'aeb213', 'to': contact_jid})
                            .c('result',  {'xmlns': 'urn:xmpp:mam:2', 'queryid':queryid, 'id':'28482-98726-73624'})
                                .c('forwarded', {'xmlns':'urn:xmpp:forward:0'})
                                    .c('delay', {'xmlns':'urn:xmpp:delay', 'stamp':'2010-07-10T23:08:25Z'}).up()
                                    .c('message', {
                                        'xmlns':'jabber:client',
                                        'to': contact_jid,
                                        'from': _converse.bare_jid,
                                        'type':'chat' })
                                    .c('body').t("Henceforth I never will be Romeo.");
                _converse.connection._dataRecv(test_utils.createRequest(msg2));
                const stanza = $iq({'type': 'result', 'id': IQ_id})
                    .c('fin', {'xmlns': 'urn:xmpp:mam:2'})
                        .c('set',  {'xmlns': 'http://jabber.org/protocol/rsm'})
                            .c('first', {'index': '0'}).t('23452-4534-1').up()
                            .c('last').t('09af3-cc343-b409f').up()
                            .c('count').t('16');
                _converse.connection._dataRecv(test_utils.createRequest(stanza));
                done();
            }));

            it("will show an error message if the MAM query times out",
                mock.initConverse(
                    null, ['discoInitialized'], {},
                    async function (done, _converse) {

                const sendIQ = _converse.connection.sendIQ;

                let timeout_happened = false;
                spyOn(_converse.connection, 'sendIQ').and.callFake(function (iq, callback, errback) {
                    sendIQ.bind(this)(iq, callback, errback);
                    if (!timeout_happened) {
                        if (typeof(iq.tree) === "function") {
                            iq = iq.tree();
                        }
                        if (sizzle('query[xmlns="urn:xmpp:mam:2"]', iq).length) {
                            // We emulate a timeout event
                            callback(null);
                            timeout_happened = true;
                        }
                    }
                });
                await test_utils.waitForRoster(_converse, 'current', 1);
                const contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@montague.lit';
                await test_utils.openChatBoxFor(_converse, contact_jid);
                await test_utils.waitUntilDiscoConfirmed(_converse, _converse.bare_jid, null, [Strophe.NS.MAM]);

                const IQ_stanzas = _converse.connection.IQ_stanzas;
                let sent_stanza = await u.waitUntil(() => IQ_stanzas.filter(iq => sizzle('query[xmlns="urn:xmpp:mam:2"]', iq).length).pop());
                let queryid = sent_stanza.querySelector('query').getAttribute('queryid');

                expect(Strophe.serialize(sent_stanza)).toBe(
                    `<iq id="${sent_stanza.getAttribute('id')}" type="set" xmlns="jabber:client">`+
                        `<query queryid="${queryid}" xmlns="urn:xmpp:mam:2">`+
                            `<x type="submit" xmlns="jabber:x:data">`+
                                `<field type="hidden" var="FORM_TYPE"><value>urn:xmpp:mam:2</value></field>`+
                                `<field var="with"><value>mercutio@montague.lit</value></field>`+
                            `</x>`+
                            `<set xmlns="http://jabber.org/protocol/rsm"><max>50</max><before></before></set>`+
                        `</query>`+
                    `</iq>`);

                const view = _converse.chatboxviews.get(contact_jid);
                expect(view.model.messages.length).toBe(1);
                expect(view.model.messages.at(0).get('ephemeral')).toBe(false);
                expect(view.model.messages.at(0).get('type')).toBe('error');
                expect(view.model.messages.at(0).get('message')).toBe('Timeout while trying to fetch archived messages.');

                let err_message = view.el.querySelector('.message.chat-error');
                err_message.querySelector('.retry').click();
                expect(err_message.querySelector('.spinner')).not.toBe(null);

                while (_converse.connection.IQ_stanzas.length) {
                    _converse.connection.IQ_stanzas.pop();
                }
                sent_stanza = await u.waitUntil(() => IQ_stanzas.filter(iq => sizzle('query[xmlns="urn:xmpp:mam:2"]', iq).length).pop());
                queryid = sent_stanza.querySelector('query').getAttribute('queryid');
                expect(Strophe.serialize(sent_stanza)).toBe(
                    `<iq id="${sent_stanza.getAttribute('id')}" type="set" xmlns="jabber:client">`+
                        `<query queryid="${queryid}" xmlns="urn:xmpp:mam:2">`+
                            `<x type="submit" xmlns="jabber:x:data">`+
                                `<field type="hidden" var="FORM_TYPE"><value>urn:xmpp:mam:2</value></field>`+
                                `<field var="with"><value>mercutio@montague.lit</value></field>`+
                            `</x>`+
                            `<set xmlns="http://jabber.org/protocol/rsm"><max>50</max><before></before></set>`+
                        `</query>`+
                    `</iq>`);

                const msg1 = $msg({'id':'aeb212', 'to': contact_jid})
                            .c('result',  {'xmlns': 'urn:xmpp:mam:2', 'queryid': queryid, 'id':'28482-98726-73623'})
                                .c('forwarded', {'xmlns':'urn:xmpp:forward:0'})
                                    .c('delay', {'xmlns':'urn:xmpp:delay', 'stamp':'2010-07-10T23:08:25Z'}).up()
                                    .c('message', {
                                        'xmlns':'jabber:client',
                                        'to': contact_jid,
                                        'from': _converse.bare_jid,
                                        'type':'chat' })
                                    .c('body').t("Call me but love, and I'll be new baptized;");
                _converse.connection._dataRecv(test_utils.createRequest(msg1));

                const msg2 = $msg({'id':'aeb213', 'to': contact_jid})
                            .c('result',  {'xmlns': 'urn:xmpp:mam:2', 'queryid': queryid, 'id':'28482-98726-73624'})
                                .c('forwarded', {'xmlns':'urn:xmpp:forward:0'})
                                    .c('delay', {'xmlns':'urn:xmpp:delay', 'stamp':'2010-07-10T23:18:25Z'}).up()
                                    .c('message', {
                                        'xmlns':'jabber:client',
                                        'to': contact_jid,
                                        'from': _converse.bare_jid,
                                        'type':'chat' })
                                    .c('body').t("Henceforth I never will be Romeo.");
                _converse.connection._dataRecv(test_utils.createRequest(msg2));

                const stanza = $iq({'type': 'result', 'id': sent_stanza.getAttribute('id')})
                    .c('fin', {'xmlns': 'urn:xmpp:mam:2', 'complete': true})
                        .c('set',  {'xmlns': 'http://jabber.org/protocol/rsm'})
                            .c('first', {'index': '0'}).t('28482-98726-73623').up()
                            .c('last').t('28482-98726-73624').up()
                            .c('count').t('2');
                _converse.connection._dataRecv(test_utils.createRequest(stanza));
                await u.waitUntil(() => view.model.messages.length === 2, 500);
                err_message = view.el.querySelector('.message.chat-error');
                expect(err_message).toBe(null);
                done();
            }));
        });
    });
}));