Use async/await in tests

spec/bookmarks.js

@@ -20,290 +20,283 @@
     describe("A chat room", function () {
 
         it("can be bookmarked", mock.initConverseWithPromises(
-            null, ['rosterGroupsFetched'], {}, function (done, _converse) {
+            null, ['rosterGroupsFetched'], {},
+            async function (done, _converse) {
                 
-            test_utils.waitUntilDiscoConfirmed(
+            await test_utils.waitUntilDiscoConfirmed(
                 _converse, _converse.bare_jid,
                 [{'category': 'pubsub', 'type': 'pep'}],
                 ['http://jabber.org/protocol/pubsub#publish-options']
-            ).then(function () {
-                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.connection, 'getUniqueId').and.callThrough();
-
-                let view, bookmark;
-                test_utils.openChatRoom(_converse, 'theplay', 'conference.shakespeare.lit', 'JC')
-                .then(() => {
-                    var jid = 'theplay@conference.shakespeare.lit';
-                    view = _converse.chatboxviews.get(jid);
-                    spyOn(view, 'renderBookmarkForm').and.callThrough();
-                    spyOn(view, 'closeForm').and.callThrough();
-                    return test_utils.waitUntil(() => !_.isNull(view.el.querySelector('.toggle-bookmark')));
-                }).then(() => {
-                    bookmark = view.el.querySelector('.toggle-bookmark');
-                    bookmark.click();
-                    expect(view.renderBookmarkForm).toHaveBeenCalled();
-
-                    view.el.querySelector('.button-cancel').click();
-                    expect(view.closeForm).toHaveBeenCalled();
-                    expect(u.hasClass('on-button', bookmark), false);
-
-                    bookmark.click();
-                    expect(view.renderBookmarkForm).toHaveBeenCalled();
-
-                    /* Client uploads data:
-                     * --------------------
-                     *  <iq from='juliet@capulet.lit/balcony' type='set' id='pip1'>
-                     *      <pubsub xmlns='http://jabber.org/protocol/pubsub'>
-                     *          <publish node='storage:bookmarks'>
-                     *              <item id='current'>
-                     *                  <storage xmlns='storage:bookmarks'>
-                     *                      <conference name='The Play&apos;s the Thing'
-                     *                                  autojoin='true'
-                     *                                  jid='theplay@conference.shakespeare.lit'>
-                     *                          <nick>JC</nick>
-                     *                      </conference>
-                     *                  </storage>
-                     *              </item>
-                     *          </publish>
-                     *          <publish-options>
-                     *              <x xmlns='jabber:x:data' type='submit'>
-                     *                  <field var='FORM_TYPE' type='hidden'>
-                     *                      <value>http://jabber.org/protocol/pubsub#publish-options</value>
-                     *                  </field>
-                     *                  <field var='pubsub#persist_items'>
-                     *                      <value>true</value>
-                     *                  </field>
-                     *                  <field var='pubsub#access_model'>
-                     *                      <value>whitelist</value>
-                     *                  </field>
-                     *              </x>
-                     *          </publish-options>
-                     *      </pubsub>
-                     *  </iq>
-                     */
-                    expect(view.model.get('bookmarked')).toBeFalsy();
-                    const form = view.el.querySelector('.chatroom-form');
-                    form.querySelector('input[name="name"]').value = 'Play&apos;s the Thing';
-                    form.querySelector('input[name="autojoin"]').checked = 'checked';
-                    form.querySelector('input[name="nick"]').value = 'JC';
-
-                    _converse.connection.IQ_stanzas = [];
-                    view.el.querySelector('.btn-primary').click();
-
-                    return test_utils.waitUntil(() => sent_stanza);
-                }).then(() => {
-                    expect(sent_stanza.toLocaleString()).toBe(
-                        `<iq from="dummy@localhost/resource" id="${IQ_id}" type="set" xmlns="jabber:client">`+
-                            `<pubsub xmlns="http://jabber.org/protocol/pubsub">`+
-                                `<publish node="storage:bookmarks">`+
-                                    `<item id="current">`+
-                                        `<storage xmlns="storage:bookmarks">`+
-                                            `<conference autojoin="true" jid="theplay@conference.shakespeare.lit" name="Play&amp;apos;s the Thing">`+
-                                                `<nick>JC</nick>`+
-                                            `</conference>`+
-                                        `</storage>`+
-                                    `</item>`+
-                                `</publish>`+
-                                `<publish-options>`+
-                                    `<x type="submit" xmlns="jabber:x:data">`+
-                                        `<field type="hidden" var="FORM_TYPE">`+
-                                            `<value>http://jabber.org/protocol/pubsub#publish-options</value>`+
-                                        `</field>`+
-                                        `<field var="pubsub#persist_items">`+
-                                            `<value>true</value>`+
-                                        `</field>`+
-                                        `<field var="pubsub#access_model">`+
-                                            `<value>whitelist</value>`+
-                                        `</field>`+
-                                    `</x>`+
-                                `</publish-options>`+
-                            `</pubsub>`+
-                        `</iq>`
-                    );
-                    /* Server acknowledges successful storage
-                     *
-                     * <iq to='juliet@capulet.lit/balcony' type='result' id='pip1'/>
-                     */
-                    const stanza = $iq({
-                        'to':_converse.connection.jid,
-                        'type':'result',
-                        'id':IQ_id
-                    });
-                    _converse.connection._dataRecv(test_utils.createRequest(stanza));
-                    return test_utils.waitUntil(() => view.model.get('bookmarked'));
-                }).then(() => {
-                    expect(view.model.get('bookmarked')).toBeTruthy();
-                    expect(u.hasClass('on-button', bookmark), true);
-                    // We ignore this IQ stanza... (unless it's an error stanza), so
-                    // nothing to test for here.
-                    done();
-                }).catch(_.partial(_converse.log, _, Strophe.LogLevel.FATAL));
+            );
+            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.connection, 'getUniqueId').and.callThrough();
+
+            await test_utils.openChatRoom(_converse, 'theplay', 'conference.shakespeare.lit', 'JC');
+            var jid = 'theplay@conference.shakespeare.lit';
+            const view = _converse.chatboxviews.get(jid);
+            spyOn(view, 'renderBookmarkForm').and.callThrough();
+            spyOn(view, 'closeForm').and.callThrough();
+            await test_utils.waitUntil(() => !_.isNull(view.el.querySelector('.toggle-bookmark')));
+            const bookmark = view.el.querySelector('.toggle-bookmark');
+            bookmark.click();
+            expect(view.renderBookmarkForm).toHaveBeenCalled();
+
+            view.el.querySelector('.button-cancel').click();
+            expect(view.closeForm).toHaveBeenCalled();
+            expect(u.hasClass('on-button', bookmark), false);
+
+            bookmark.click();
+            expect(view.renderBookmarkForm).toHaveBeenCalled();
+
+            /* Client uploads data:
+             * --------------------
+             *  <iq from='juliet@capulet.lit/balcony' type='set' id='pip1'>
+             *      <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+             *          <publish node='storage:bookmarks'>
+             *              <item id='current'>
+             *                  <storage xmlns='storage:bookmarks'>
+             *                      <conference name='The Play&apos;s the Thing'
+             *                                  autojoin='true'
+             *                                  jid='theplay@conference.shakespeare.lit'>
+             *                          <nick>JC</nick>
+             *                      </conference>
+             *                  </storage>
+             *              </item>
+             *          </publish>
+             *          <publish-options>
+             *              <x xmlns='jabber:x:data' type='submit'>
+             *                  <field var='FORM_TYPE' type='hidden'>
+             *                      <value>http://jabber.org/protocol/pubsub#publish-options</value>
+             *                  </field>
+             *                  <field var='pubsub#persist_items'>
+             *                      <value>true</value>
+             *                  </field>
+             *                  <field var='pubsub#access_model'>
+             *                      <value>whitelist</value>
+             *                  </field>
+             *              </x>
+             *          </publish-options>
+             *      </pubsub>
+             *  </iq>
+             */
+            expect(view.model.get('bookmarked')).toBeFalsy();
+            const form = view.el.querySelector('.chatroom-form');
+            form.querySelector('input[name="name"]').value = 'Play&apos;s the Thing';
+            form.querySelector('input[name="autojoin"]').checked = 'checked';
+            form.querySelector('input[name="nick"]').value = 'JC';
+
+            _converse.connection.IQ_stanzas = [];
+            view.el.querySelector('.btn-primary').click();
+
+            await test_utils.waitUntil(() => sent_stanza);
+            expect(sent_stanza.toLocaleString()).toBe(
+                `<iq from="dummy@localhost/resource" id="${IQ_id}" type="set" xmlns="jabber:client">`+
+                    `<pubsub xmlns="http://jabber.org/protocol/pubsub">`+
+                        `<publish node="storage:bookmarks">`+
+                            `<item id="current">`+
+                                `<storage xmlns="storage:bookmarks">`+
+                                    `<conference autojoin="true" jid="theplay@conference.shakespeare.lit" name="Play&amp;apos;s the Thing">`+
+                                        `<nick>JC</nick>`+
+                                    `</conference>`+
+                                `</storage>`+
+                            `</item>`+
+                        `</publish>`+
+                        `<publish-options>`+
+                            `<x type="submit" xmlns="jabber:x:data">`+
+                                `<field type="hidden" var="FORM_TYPE">`+
+                                    `<value>http://jabber.org/protocol/pubsub#publish-options</value>`+
+                                `</field>`+
+                                `<field var="pubsub#persist_items">`+
+                                    `<value>true</value>`+
+                                `</field>`+
+                                `<field var="pubsub#access_model">`+
+                                    `<value>whitelist</value>`+
+                                `</field>`+
+                            `</x>`+
+                        `</publish-options>`+
+                    `</pubsub>`+
+                `</iq>`
+            );
+            /* Server acknowledges successful storage
+             *
+             * <iq to='juliet@capulet.lit/balcony' type='result' id='pip1'/>
+             */
+            const stanza = $iq({
+                'to':_converse.connection.jid,
+                'type':'result',
+                'id':IQ_id
+            });
+            _converse.connection._dataRecv(test_utils.createRequest(stanza));
+            await test_utils.waitUntil(() => view.model.get('bookmarked'));
+            expect(view.model.get('bookmarked')).toBeTruthy();
+            expect(u.hasClass('on-button', bookmark), true);
+            // We ignore this IQ stanza... (unless it's an error stanza), so
+            // nothing to test for here.
+            done();
         }));
 
+
         it("will be automatically opened if 'autojoin' is set on the bookmark", mock.initConverseWithPromises(
-            null, ['rosterGroupsFetched'], {}, function (done, _converse) {
+            null, ['rosterGroupsFetched'], {},
+            async function (done, _converse) {
 
-            test_utils.waitUntilDiscoConfirmed(
+            await test_utils.waitUntilDiscoConfirmed(
                 _converse, _converse.bare_jid,
                 [{'category': 'pubsub', 'type': 'pep'}],
                 ['http://jabber.org/protocol/pubsub#publish-options']
-            ).then(function () {
-                var jid = 'lounge@localhost';
-                _converse.bookmarks.create({
-                    'jid': jid,
-                    'autojoin': false,
-                    'name':  'The Lounge',
-                    'nick': ' Othello'
-                });
-                expect(_.isUndefined(_converse.chatboxviews.get(jid))).toBeTruthy();
-
-                jid = 'theplay@conference.shakespeare.lit';
-                _converse.bookmarks.create({
-                    'jid': jid,
-                    'autojoin': true,
-                    'name':  'The Play',
-                    'nick': ' Othello'
-                });
-                expect(_.isUndefined(_converse.chatboxviews.get(jid))).toBeFalsy();
-                done();
+            );
+            let jid = 'lounge@localhost';
+            _converse.bookmarks.create({
+                'jid': jid,
+                'autojoin': false,
+                'name':  'The Lounge',
+                'nick': ' Othello'
+            });
+            expect(_.isUndefined(_converse.chatboxviews.get(jid))).toBeTruthy();
+
+            jid = 'theplay@conference.shakespeare.lit';
+            _converse.bookmarks.create({
+                'jid': jid,
+                'autojoin': true,
+                'name':  'The Play',
+                'nick': ' Othello'
             });
+            expect(_.isUndefined(_converse.chatboxviews.get(jid))).toBeFalsy();
+            done();
         }));
 
+
         describe("when bookmarked", function () {
 
             it("displays that it's bookmarked through its bookmark icon", mock.initConverseWithPromises(
-                null, ['rosterGroupsFetched'], {}, function (done, _converse) {
+                null, ['rosterGroupsFetched'], {},
+                async function (done, _converse) {
 
-                let view;
                 test_utils.waitUntilDiscoConfirmed(
                     _converse, _converse.bare_jid,
                     [{'category': 'pubsub', 'type': 'pep'}],
                     ['http://jabber.org/protocol/pubsub#publish-options']
-                ).then(() => test_utils.openChatRoom(_converse, 'lounge', 'localhost', 'dummy'))
-                .then(() => {
-                    view = _converse.chatboxviews.get('lounge@localhost');
-                    return test_utils.waitUntil(() => !_.isNull(view.el.querySelector('.toggle-bookmark')))
-                }).then(function () {
-                    var bookmark_icon = view.el.querySelector('.toggle-bookmark');
-                    expect(_.includes(bookmark_icon.classList, 'button-on')).toBeFalsy();
-                    view.model.set('bookmarked', true);
-                    expect(_.includes(bookmark_icon.classList, 'button-on')).toBeTruthy();
-                    view.model.set('bookmarked', false);
-                    expect(_.includes(bookmark_icon.classList, 'button-on')).toBeFalsy();
-                    done();
-                });
+                );
+                await test_utils.openChatRoom(_converse, 'lounge', 'localhost', 'dummy');
+                const view = _converse.chatboxviews.get('lounge@localhost');
+                await test_utils.waitUntil(() => !_.isNull(view.el.querySelector('.toggle-bookmark')));
+                var bookmark_icon = view.el.querySelector('.toggle-bookmark');
+                expect(_.includes(bookmark_icon.classList, 'button-on')).toBeFalsy();
+                view.model.set('bookmarked', true);
+                expect(_.includes(bookmark_icon.classList, 'button-on')).toBeTruthy();
+                view.model.set('bookmarked', false);
+                expect(_.includes(bookmark_icon.classList, 'button-on')).toBeFalsy();
+                done();
             }));
 
             it("can be unbookmarked", mock.initConverseWithPromises(
-                null, ['rosterGroupsFetched'], {}, function (done, _converse) {
+                null, ['rosterGroupsFetched'], {},
+                async function (done, _converse) {
 
-                let sent_stanza, IQ_id, view, sendIQ;
+                let sent_stanza, IQ_id;
 
-                test_utils.waitUntilDiscoConfirmed(
+                await test_utils.waitUntilDiscoConfirmed(
                     _converse, _converse.bare_jid,
                     [{'category': 'pubsub', 'type': 'pep'}],
                     ['http://jabber.org/protocol/pubsub#publish-options']
-                ).then(() => {
-                    sendIQ = _converse.connection.sendIQ;
-                    return test_utils.openChatRoom(_converse, 'theplay', 'conference.shakespeare.lit', 'JC');
-                }).then(() => {
-                    var jid = 'theplay@conference.shakespeare.lit';
-                    view = _converse.chatboxviews.get(jid);
-                    return test_utils.waitUntil(() => !_.isNull(view.el.querySelector('.toggle-bookmark')));
-                }).then(function () {
-                    spyOn(view, 'toggleBookmark').and.callThrough();
-                    spyOn(_converse.bookmarks, 'sendBookmarkStanza').and.callThrough();
-                    view.delegateEvents();
-
-                    _converse.bookmarks.create({
-                        'jid': view.model.get('jid'),
-                        'autojoin': false,
-                        'name':  'The Play',
-                        'nick': ' Othello'
-                    });
-                    expect(_converse.bookmarks.length).toBe(1);
-                    expect(view.model.get('bookmarked')).toBeTruthy();
-                    var bookmark_icon = view.el.querySelector('.toggle-bookmark');
-                    expect(u.hasClass('button-on', bookmark_icon)).toBeTruthy();
-
-                    spyOn(_converse.connection, 'sendIQ').and.callFake(function (iq, callback, errback) {
-                        sent_stanza = iq;
-                        IQ_id = sendIQ.bind(this)(iq, callback, errback);
-                    });
-                    spyOn(_converse.connection, 'getUniqueId').and.callThrough();
-                    bookmark_icon.click();
-                    expect(view.toggleBookmark).toHaveBeenCalled();
-                    expect(u.hasClass('button-on', bookmark_icon)).toBeFalsy();
-                    expect(_converse.bookmarks.length).toBe(0);
-
-                    // Check that an IQ stanza is sent out, containing no
-                    // conferences to bookmark (since we removed the one and
-                    // only bookmark).
-                    expect(sent_stanza.toLocaleString()).toBe(
-                        `<iq from="dummy@localhost/resource" id="${IQ_id}" type="set" xmlns="jabber:client">`+
-                            `<pubsub xmlns="http://jabber.org/protocol/pubsub">`+
-                                `<publish node="storage:bookmarks">`+
-                                    `<item id="current">`+
-                                        `<storage xmlns="storage:bookmarks"/>`+
-                                    `</item>`+
-                                `</publish>`+
-                                `<publish-options>`+
-                                    `<x type="submit" xmlns="jabber:x:data">`+
-                                        `<field type="hidden" var="FORM_TYPE">`+
-                                            `<value>http://jabber.org/protocol/pubsub#publish-options</value>`+
-                                        `</field>`+
-                                        `<field var="pubsub#persist_items">`+
-                                            `<value>true</value>`+
-                                        `</field>`+
-                                        `<field var="pubsub#access_model">`+
-                                            `<value>whitelist</value>`+
-                                        `</field>`+
-                                    `</x>`+
-                                `</publish-options>`+
-                            `</pubsub>`+
-                        `</iq>`
-                    );
-                    done();
+                );
+                const sendIQ = _converse.connection.sendIQ;
+                await test_utils.openChatRoom(_converse, 'theplay', 'conference.shakespeare.lit', 'JC');
+
+                const jid = 'theplay@conference.shakespeare.lit';
+                const view = _converse.chatboxviews.get(jid);
+                await test_utils.waitUntil(() => !_.isNull(view.el.querySelector('.toggle-bookmark')));
+
+                spyOn(view, 'toggleBookmark').and.callThrough();
+                spyOn(_converse.bookmarks, 'sendBookmarkStanza').and.callThrough();
+                view.delegateEvents();
+
+                _converse.bookmarks.create({
+                    'jid': view.model.get('jid'),
+                    'autojoin': false,
+                    'name':  'The Play',
+                    'nick': ' Othello'
+                });
+                expect(_converse.bookmarks.length).toBe(1);
+                expect(view.model.get('bookmarked')).toBeTruthy();
+                var bookmark_icon = view.el.querySelector('.toggle-bookmark');
+                expect(u.hasClass('button-on', bookmark_icon)).toBeTruthy();
+
+                spyOn(_converse.connection, 'sendIQ').and.callFake(function (iq, callback, errback) {
+                    sent_stanza = iq;
+                    IQ_id = sendIQ.bind(this)(iq, callback, errback);
                 });
+                spyOn(_converse.connection, 'getUniqueId').and.callThrough();
+                bookmark_icon.click();
+                expect(view.toggleBookmark).toHaveBeenCalled();
+                expect(u.hasClass('button-on', bookmark_icon)).toBeFalsy();
+                expect(_converse.bookmarks.length).toBe(0);
+
+                // Check that an IQ stanza is sent out, containing no
+                // conferences to bookmark (since we removed the one and
+                // only bookmark).
+                expect(sent_stanza.toLocaleString()).toBe(
+                    `<iq from="dummy@localhost/resource" id="${IQ_id}" type="set" xmlns="jabber:client">`+
+                        `<pubsub xmlns="http://jabber.org/protocol/pubsub">`+
+                            `<publish node="storage:bookmarks">`+
+                                `<item id="current">`+
+                                    `<storage xmlns="storage:bookmarks"/>`+
+                                `</item>`+
+                            `</publish>`+
+                            `<publish-options>`+
+                                `<x type="submit" xmlns="jabber:x:data">`+
+                                    `<field type="hidden" var="FORM_TYPE">`+
+                                        `<value>http://jabber.org/protocol/pubsub#publish-options</value>`+
+                                    `</field>`+
+                                    `<field var="pubsub#persist_items">`+
+                                        `<value>true</value>`+
+                                    `</field>`+
+                                    `<field var="pubsub#access_model">`+
+                                        `<value>whitelist</value>`+
+                                    `</field>`+
+                                `</x>`+
+                            `</publish-options>`+
+                        `</pubsub>`+
+                    `</iq>`
+                );
+                done();
             }));
         });
 
         describe("and when autojoin is set", function () {
 
             it("will be be opened and joined automatically upon login", mock.initConverseWithPromises(
-                null, ['rosterGroupsFetched'], {}, function (done, _converse) {
+                null, ['rosterGroupsFetched'], {},
+                async function (done, _converse) {
 
-                test_utils.waitUntilDiscoConfirmed(
+                await test_utils.waitUntilDiscoConfirmed(
                     _converse, _converse.bare_jid,
                     [{'category': 'pubsub', 'type': 'pep'}],
                     ['http://jabber.org/protocol/pubsub#publish-options']
-                ).then(function () {
-                    spyOn(_converse.api.rooms, 'create').and.callThrough();
-                    var jid = 'theplay@conference.shakespeare.lit';
-                    var model = _converse.bookmarks.create({
-                        'jid': jid,
-                        'autojoin': false,
-                        'name':  'The Play',
-                        'nick': ''
-                    });
-                    expect(_converse.api.rooms.create).not.toHaveBeenCalled();
-                    _converse.bookmarks.remove(model);
-
-                    _converse.bookmarks.create({
-                        'jid': jid,
-                        'autojoin': true,
-                        'name':  'Hamlet',
-                        'nick': ''
-                    });
-                    expect(_converse.api.rooms.create).toHaveBeenCalled();
-                    done();
+                );
+                spyOn(_converse.api.rooms, 'create').and.callThrough();
+                const jid = 'theplay@conference.shakespeare.lit';
+                const model = _converse.bookmarks.create({
+                    'jid': jid,
+                    'autojoin': false,
+                    'name':  'The Play',
+                    'nick': ''
                 });
+                expect(_converse.api.rooms.create).not.toHaveBeenCalled();
+                _converse.bookmarks.remove(model);
+                _converse.bookmarks.create({
+                    'jid': jid,
+                    'autojoin': true,
+                    'name':  'Hamlet',
+                    'nick': ''
+                });
+                expect(_converse.api.rooms.create).toHaveBeenCalled();
+                done();
             }));
         });
     });
@@ -312,62 +305,59 @@
 
         it("can be pushed from the XMPP server", mock.initConverseWithPromises(
             ['send'], ['rosterGroupsFetched', 'connected'], {},
-            function (done, _converse) {
+            async function (done, _converse) {
 
-            test_utils.waitUntilDiscoConfirmed(
+            await test_utils.waitUntilDiscoConfirmed(
                 _converse, _converse.bare_jid,
                 [{'category': 'pubsub', 'type': 'pep'}],
                 ['http://jabber.org/protocol/pubsub#publish-options']
-            ).then(function () {
-                return test_utils.waitUntil(() => _converse.bookmarks);
-            }).then(function () {
-                // Emit here instead of mocking fetching of bookmarks.
-                _converse.emit('bookmarksInitialized');
-
-               /* The stored data is automatically pushed to all of the user's
-                * connected resources.
-                *
-                * Publisher receives event notification
-                * -------------------------------------
-                * <message from='juliet@capulet.lit'
-                *         to='juliet@capulet.lit/balcony'
-                *         type='headline'
-                *         id='rnfoo1'>
-                * <event xmlns='http://jabber.org/protocol/pubsub#event'>
-                *     <items node='storage:bookmarks'>
-                *     <item id='current'>
-                *         <storage xmlns='storage:bookmarks'>
-                *         <conference name='The Play&apos;s the Thing'
-                *                     autojoin='true'
-                *                     jid='theplay@conference.shakespeare.lit'>
-                *             <nick>JC</nick>
-                *         </conference>
-                *         </storage>
-                *     </item>
-                *     </items>
-                * </event>
-                * </message>
-                */
-               var stanza = $msg({
-                   'from': 'dummy@localhost',
-                   'to': 'dummy@localhost/resource',
-                   'type': 'headline',
-                   'id': 'rnfoo1'
-               }).c('event', {'xmlns': 'http://jabber.org/protocol/pubsub#event'})
-                   .c('items', {'node': 'storage:bookmarks'})
-                       .c('item', {'id': 'current'})
-                           .c('storage', {'xmlns': 'storage:bookmarks'})
-                               .c('conference', {'name': 'The Play&apos;s the Thing',
-                                               'autojoin': 'true',
-                                               'jid':'theplay@conference.shakespeare.lit'})
-                                   .c('nick').t('JC');
-               _converse.connection._dataRecv(test_utils.createRequest(stanza));
-                return test_utils.waitUntil(() => _converse.bookmarks.length);
-            }).then(function () {
-               expect(_converse.bookmarks.length).toBe(1);
-               expect(_converse.chatboxviews.get('theplay@conference.shakespeare.lit')).not.toBeUndefined();
-               done();
-            });
+            );
+            await test_utils.waitUntil(() => _converse.bookmarks);
+            // Emit here instead of mocking fetching of bookmarks.
+            _converse.emit('bookmarksInitialized');
+
+            /* The stored data is automatically pushed to all of the user's
+             * connected resources.
+             *
+             * Publisher receives event notification
+             * -------------------------------------
+             * <message from='juliet@capulet.lit'
+             *         to='juliet@capulet.lit/balcony'
+             *         type='headline'
+             *         id='rnfoo1'>
+             * <event xmlns='http://jabber.org/protocol/pubsub#event'>
+             *     <items node='storage:bookmarks'>
+             *     <item id='current'>
+             *         <storage xmlns='storage:bookmarks'>
+             *         <conference name='The Play&apos;s the Thing'
+             *                     autojoin='true'
+             *                     jid='theplay@conference.shakespeare.lit'>
+             *             <nick>JC</nick>
+             *         </conference>
+             *         </storage>
+             *     </item>
+             *     </items>
+             * </event>
+             * </message>
+             */
+            var stanza = $msg({
+                'from': 'dummy@localhost',
+                'to': 'dummy@localhost/resource',
+                'type': 'headline',
+                'id': 'rnfoo1'
+            }).c('event', {'xmlns': 'http://jabber.org/protocol/pubsub#event'})
+                .c('items', {'node': 'storage:bookmarks'})
+                    .c('item', {'id': 'current'})
+                        .c('storage', {'xmlns': 'storage:bookmarks'})
+                            .c('conference', {'name': 'The Play&apos;s the Thing',
+                                            'autojoin': 'true',
+                                            'jid':'theplay@conference.shakespeare.lit'})
+                                .c('nick').t('JC');
+            _converse.connection._dataRecv(test_utils.createRequest(stanza));
+            await test_utils.waitUntil(() => _converse.bookmarks.length);
+            expect(_converse.bookmarks.length).toBe(1);
+            expect(_converse.chatboxviews.get('theplay@conference.shakespeare.lit')).not.toBeUndefined();
+            done();
         }));
 
 
@@ -619,44 +609,42 @@
         it("can be closed", mock.initConverseWithPromises(
             null, ['rosterGroupsFetched'],
             { hide_open_bookmarks: true },
-            function (done, _converse) {
+            async function (done, _converse) {
 
             const jid = 'room@conference.example.org';
-            test_utils.waitUntilDiscoConfirmed(
+            await test_utils.waitUntilDiscoConfirmed(
                 _converse, _converse.bare_jid,
                 [{'category': 'pubsub', 'type': 'pep'}],
                 ['http://jabber.org/protocol/pubsub#publish-options']
-            ).then(function () {
-                // XXX Create bookmarks view here, otherwise we need to mock stanza
-                // traffic for it to get created.
-                _converse.bookmarksview = new _converse.BookmarksView(
-                    {'model': _converse.bookmarks}
-                );
-                _converse.emit('bookmarksInitialized');
-
-                // Check that it's there
-                _converse.bookmarks.create({
-                    'jid': jid,
-                    'autojoin': false,
-                    'name':  'The Play',
-                    'nick': ' Othello'
-                });
-                expect(_converse.bookmarks.length).toBe(1);
-                var room_els = _converse.bookmarksview.el.querySelectorAll(".open-room");
-                expect(room_els.length).toBe(1);
-
-                // Check that it disappears once the room is opened
-                var bookmark = _converse.bookmarksview.el.querySelector(".open-room");
-                bookmark.click();
-                return test_utils.waitUntil(() => _converse.chatboxviews.get(jid));
-            }).then(() => {
-                expect(u.hasClass('hidden', _converse.bookmarksview.el.querySelector(".available-chatroom"))).toBeTruthy();
-                // Check that it reappears once the room is closed
-                const view = _converse.chatboxviews.get(jid);
-                view.close();
-                expect(u.hasClass('hidden', _converse.bookmarksview.el.querySelector(".available-chatroom"))).toBeFalsy();
-                done();
+            );
+            // XXX Create bookmarks view here, otherwise we need to mock stanza
+            // traffic for it to get created.
+            _converse.bookmarksview = new _converse.BookmarksView(
+                {'model': _converse.bookmarks}
+            );
+            _converse.emit('bookmarksInitialized');
+
+            // Check that it's there
+            _converse.bookmarks.create({
+                'jid': jid,
+                'autojoin': false,
+                'name':  'The Play',
+                'nick': ' Othello'
             });
+            expect(_converse.bookmarks.length).toBe(1);
+            const room_els = _converse.bookmarksview.el.querySelectorAll(".open-room");
+            expect(room_els.length).toBe(1);
+
+            // Check that it disappears once the room is opened
+            const bookmark = _converse.bookmarksview.el.querySelector(".open-room");
+            bookmark.click();
+            await test_utils.waitUntil(() => _converse.chatboxviews.get(jid));
+            expect(u.hasClass('hidden', _converse.bookmarksview.el.querySelector(".available-chatroom"))).toBeTruthy();
+            // Check that it reappears once the room is closed
+            const view = _converse.chatboxviews.get(jid);
+            view.close();
+            expect(u.hasClass('hidden', _converse.bookmarksview.el.querySelector(".available-chatroom"))).toBeFalsy();
+            done();
         }));
     });
 }));

spec/converse.js

@@ -11,9 +11,10 @@
     describe("Converse", function() {
         
         describe("Authentication", function () {
+
             it("needs either a bosh_service_url a websocket_url or both", mock.initConverse(function (_converse) {
-                var url = _converse.bosh_service_url;
-                var connection = _converse.connection;
+                const url = _converse.bosh_service_url;
+                const connection = _converse.connection;
                 delete _converse.bosh_service_url;
                 delete _converse.connection;
                 expect(_converse.initConnection).toThrow(
@@ -271,44 +272,45 @@
         describe("The \"chats\" API", function() {
 
             it("has a method 'get' which returns the promise that resolves to a chat model", mock.initConverseWithPromises(
-                null, ['rosterInitialized', 'chatBoxesInitialized'], {}, function (done, _converse) {
-                    test_utils.openControlBox();
-                    test_utils.createContacts(_converse, 'current', 2);
-                    _converse.emit('rosterContactsFetched');
-
-                    // Test on chat that doesn't exist.
-                    expect(_converse.api.chats.get('non-existing@jabber.org')).toBeFalsy();
-                    const jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
-                    const jid2 = mock.cur_names[1].replace(/ /g,'.').toLowerCase() + '@localhost';
-
-                    // Test on chat that's not open
-                    let box = _converse.api.chats.get(jid);
-                    expect(typeof box === 'undefined').toBeTruthy();
-                    expect(_converse.chatboxes.length).toBe(1);
-
-                    // Test for one JID
-                    test_utils.openChatBoxFor(_converse, jid);
-                    test_utils.waitUntil(() => _converse.chatboxes.length == 1).then(() => {
-                        box = _converse.api.chats.get(jid);
-                        expect(box instanceof Object).toBeTruthy();
-                        expect(box.get('box_id')).toBe(b64_sha1(jid));
-
-                        const chatboxview = _converse.chatboxviews.get(jid);
-                        expect(u.isVisible(chatboxview.el)).toBeTruthy();
-                        // Test for multiple JIDs
-                        test_utils.openChatBoxFor(_converse, jid2);
-                        return test_utils.waitUntil(() => _converse.chatboxes.length == 2);
-                    }).then(() => {
-                        const list = _converse.api.chats.get([jid, jid2]);
-                        expect(_.isArray(list)).toBeTruthy();
-                        expect(list[0].get('box_id')).toBe(b64_sha1(jid));
-                        expect(list[1].get('box_id')).toBe(b64_sha1(jid2));
-                        done();
-                    }).catch(_.partial(console.error, _));
+                null, ['rosterInitialized', 'chatBoxesInitialized'], {},
+                async function (done, _converse) {
+
+                test_utils.openControlBox();
+                test_utils.createContacts(_converse, 'current', 2);
+                _converse.emit('rosterContactsFetched');
+
+                // Test on chat that doesn't exist.
+                expect(_converse.api.chats.get('non-existing@jabber.org')).toBeFalsy();
+                const jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
+                const jid2 = mock.cur_names[1].replace(/ /g,'.').toLowerCase() + '@localhost';
+
+                // Test on chat that's not open
+                let box = _converse.api.chats.get(jid);
+                expect(typeof box === 'undefined').toBeTruthy();
+                expect(_converse.chatboxes.length).toBe(1);
+
+                // Test for one JID
+                test_utils.openChatBoxFor(_converse, jid);
+                await test_utils.waitUntil(() => _converse.chatboxes.length == 1);
+                box = _converse.api.chats.get(jid);
+                expect(box instanceof Object).toBeTruthy();
+                expect(box.get('box_id')).toBe(b64_sha1(jid));
+
+                const chatboxview = _converse.chatboxviews.get(jid);
+                expect(u.isVisible(chatboxview.el)).toBeTruthy();
+                // Test for multiple JIDs
+                test_utils.openChatBoxFor(_converse, jid2);
+                await test_utils.waitUntil(() => _converse.chatboxes.length == 2);
+                const list = _converse.api.chats.get([jid, jid2]);
+                expect(_.isArray(list)).toBeTruthy();
+                expect(list[0].get('box_id')).toBe(b64_sha1(jid));
+                expect(list[1].get('box_id')).toBe(b64_sha1(jid2));
+                done();
             }));
 
             it("has a method 'open' which opens and returns a promise that resolves to a chat model", mock.initConverseWithPromises(
-                null, ['rosterGroupsFetched', 'chatBoxesInitialized'], {}, function (done, _converse) {
+                null, ['rosterGroupsFetched', 'chatBoxesInitialized'], {},
+                async function (done, _converse) {
 
                 test_utils.openControlBox();
                 test_utils.createContacts(_converse, 'current', 2);
@@ -319,23 +321,21 @@
                 // Test on chat that doesn't exist.
                 expect(_converse.api.chats.get('non-existing@jabber.org')).toBeFalsy();
 
-                return _converse.api.chats.open(jid).then((box) => {
-                    expect(box instanceof Object).toBeTruthy();
-                    expect(box.get('box_id')).toBe(b64_sha1(jid));
-                    expect(
-                        _.keys(box),
-                        ['close', 'endOTR', 'focus', 'get', 'initiateOTR', 'is_chatroom', 'maximize', 'minimize', 'open', 'set']
-                    );
-                    const chatboxview = _converse.chatboxviews.get(jid);
-                    expect(u.isVisible(chatboxview.el)).toBeTruthy();
-                    // Test for multiple JIDs
-                    return _converse.api.chats.open([jid, jid2]);
-                }).then((list) => {
-                    expect(_.isArray(list)).toBeTruthy();
-                    expect(list[0].get('box_id')).toBe(b64_sha1(jid));
-                    expect(list[1].get('box_id')).toBe(b64_sha1(jid2));
-                    done();
-                });
+                const box = await _converse.api.chats.open(jid);
+                expect(box instanceof Object).toBeTruthy();
+                expect(box.get('box_id')).toBe(b64_sha1(jid));
+                expect(
+                    _.keys(box),
+                    ['close', 'endOTR', 'focus', 'get', 'initiateOTR', 'is_chatroom', 'maximize', 'minimize', 'open', 'set']
+                );
+                const chatboxview = _converse.chatboxviews.get(jid);
+                expect(u.isVisible(chatboxview.el)).toBeTruthy();
+                // Test for multiple JIDs
+                const list = await _converse.api.chats.open([jid, jid2]);
+                expect(_.isArray(list)).toBeTruthy();
+                expect(list[0].get('box_id')).toBe(b64_sha1(jid));
+                expect(list[1].get('box_id')).toBe(b64_sha1(jid2));
+                done();
             }));
         });
 
@@ -361,7 +361,7 @@
             it("only has a method 'add' for registering plugins", mock.initConverse(function (_converse) {
                 expect(_.keys(converse.plugins)).toEqual(["add"]);
                 // Cheating a little bit. We clear the plugins to test more easily.
-                var _old_plugins = _converse.pluggable.plugins;
+                const _old_plugins = _converse.pluggable.plugins;
                 _converse.pluggable.plugins = [];
                 converse.plugins.add('plugin1', {});
                 expect(_.keys(_converse.pluggable.plugins)).toEqual(['plugin1']);

spec/roomslist.js

@@ -58,31 +58,28 @@
             { whitelisted_plugins: ['converse-roomslist'],
               allow_bookmarks: false // Makes testing easier, otherwise we
                                      // have to mock stanza traffic.
-            }, function (done, _converse) {
+            }, async function (done, _converse) {
 
             spyOn(_converse, 'isSingleton').and.callFake(() => true);
 
             let room_els, item;
             test_utils.openControlBox();
-            _converse.api.rooms.open('coven@chat.shakespeare.lit', {'nick': 'some1'})
-            .then(() => {
-                room_els = _converse.rooms_list_view.el.querySelectorAll(".available-chatroom");
-                expect(room_els.length).toBe(1);
+            await _converse.api.rooms.open('coven@chat.shakespeare.lit', {'nick': 'some1'});
+            room_els = _converse.rooms_list_view.el.querySelectorAll(".available-chatroom");
+            expect(room_els.length).toBe(1);
 
-                item = room_els[0];
-                expect(u.hasClass('open', item)).toBe(true);
-                expect(item.textContent.trim()).toBe('coven@chat.shakespeare.lit');
-                return _converse.api.rooms.open('balcony@chat.shakespeare.lit', {'nick': 'some1'});
-            }).then(() => {
-                room_els = _converse.rooms_list_view.el.querySelectorAll(".open-room");
-                expect(room_els.length).toBe(2);
+            item = room_els[0];
+            expect(u.hasClass('open', item)).toBe(true);
+            expect(item.textContent.trim()).toBe('coven@chat.shakespeare.lit');
+            await _converse.api.rooms.open('balcony@chat.shakespeare.lit', {'nick': 'some1'});
+            room_els = _converse.rooms_list_view.el.querySelectorAll(".open-room");
+            expect(room_els.length).toBe(2);
 
-                room_els = _converse.rooms_list_view.el.querySelectorAll(".available-chatroom.open");
-                expect(room_els.length).toBe(1);
-                item = room_els[0];
-                expect(item.textContent.trim()).toBe('balcony@chat.shakespeare.lit');
-                done();
-            }).catch(_.partial(_converse.log, _, Strophe.LogLevel.FATAL));
+            room_els = _converse.rooms_list_view.el.querySelectorAll(".available-chatroom.open");
+            expect(room_els.length).toBe(1);
+            item = room_els[0];
+            expect(item.textContent.trim()).toBe('balcony@chat.shakespeare.lit');
+            done();
         }));
 
         it("has an info icon which opens a details modal when clicked", mock.initConverseWithPromises(
@@ -195,94 +192,82 @@
         it("can be closed", mock.initConverseWithPromises(
             null, ['rosterGroupsFetched'],
             { whitelisted_plugins: ['converse-roomslist'],
-              allow_bookmarks: false // Makes testing easier, otherwise we
-                                     // have to mock stanza traffic.
+              allow_bookmarks: false // Makes testing easier, otherwise we have to mock stanza traffic.
             },
-            function (done, _converse) {
+            async function (done, _converse) {
 
             spyOn(window, 'confirm').and.callFake(() => true);
             expect(_converse.chatboxes.length).toBe(1);
-            test_utils.openChatRoom(_converse, 'lounge', 'conference.shakespeare.lit', 'JC')
-            .then(() => {
-                expect(_converse.chatboxes.length).toBe(2);
-                var room_els = _converse.rooms_list_view.el.querySelectorAll(".open-room");
-                expect(room_els.length).toBe(1);
-                var close_el = _converse.rooms_list_view.el.querySelector(".close-room");
-                close_el.click();
-                expect(window.confirm).toHaveBeenCalledWith(
-                    'Are you sure you want to leave the groupchat lounge@conference.shakespeare.lit?');
-                room_els = _converse.rooms_list_view.el.querySelectorAll(".open-room");
-                expect(room_els.length).toBe(0);
-                expect(_converse.chatboxes.length).toBe(1);
-                done();
-            });
+            await test_utils.openChatRoom(_converse, 'lounge', 'conference.shakespeare.lit', 'JC');
+            expect(_converse.chatboxes.length).toBe(2);
+            var room_els = _converse.rooms_list_view.el.querySelectorAll(".open-room");
+            expect(room_els.length).toBe(1);
+            var close_el = _converse.rooms_list_view.el.querySelector(".close-room");
+            close_el.click();
+            expect(window.confirm).toHaveBeenCalledWith(
+                'Are you sure you want to leave the groupchat lounge@conference.shakespeare.lit?');
+            room_els = _converse.rooms_list_view.el.querySelectorAll(".open-room");
+            expect(room_els.length).toBe(0);
+            expect(_converse.chatboxes.length).toBe(1);
+            done();
         }));
 
         it("shows unread messages directed at the user", mock.initConverseWithAsync(
-                { whitelisted_plugins: ['converse-roomslist'],
-                  allow_bookmarks: false // Makes testing easier, otherwise we
-                                         // have to mock stanza traffic.
-                }, function (done, _converse) {
+            { whitelisted_plugins: ['converse-roomslist'],
+                allow_bookmarks: false // Makes testing easier, otherwise we have to mock stanza traffic.
+            }, async function (done, _converse) {
 
-            let view, nick;
             const room_jid = 'kitchen@conference.shakespeare.lit';
+            await test_utils.waitUntil(() => !_.isUndefined(_converse.rooms_list_view), 500);
+            await  test_utils.openAndEnterChatRoom(_converse, 'kitchen', 'conference.shakespeare.lit', 'romeo');
+            const view = _converse.chatboxviews.get(room_jid);
+            view.model.set({'minimized': true});
+            const contact_jid = mock.cur_names[5].replace(/ /g,'.').toLowerCase() + '@localhost';
+            const nick = mock.chatroom_names[0];
+            view.model.onMessage(
+                $msg({
+                    from: room_jid+'/'+nick,
+                    id: (new Date()).getTime(),
+                    to: 'dummy@localhost',
+                    type: 'groupchat'
+                }).c('body').t('foo').tree());
 
-            test_utils.waitUntil(() => !_.isUndefined(_converse.rooms_list_view), 500)
-            .then(() => test_utils.openAndEnterChatRoom(_converse, 'kitchen', 'conference.shakespeare.lit', 'romeo'))
-            .then(() => {
-                view = _converse.chatboxviews.get(room_jid);
-                view.model.set({'minimized': true});
-                const contact_jid = mock.cur_names[5].replace(/ /g,'.').toLowerCase() + '@localhost';
-                nick = mock.chatroom_names[0];
-                view.model.onMessage(
-                    $msg({
-                        from: room_jid+'/'+nick,
-                        id: (new Date()).getTime(),
-                        to: 'dummy@localhost',
-                        type: 'groupchat'
-                    }).c('body').t('foo').tree());
-
-                // If the user isn't mentioned, the counter doesn't get incremented, but the text of the groupchat is bold
-                var room_el = _converse.rooms_list_view.el.querySelector(
-                    ".available-chatroom"
-                );
-                expect(_.includes(room_el.classList, 'unread-msgs'));
+            // If the user isn't mentioned, the counter doesn't get incremented, but the text of the groupchat is bold
+            let room_el = _converse.rooms_list_view.el.querySelector(".available-chatroom");
+            expect(_.includes(room_el.classList, 'unread-msgs'));
 
-                // If the user is mentioned, the counter also gets updated
-                view.model.onMessage(
-                    $msg({
-                        from: room_jid+'/'+nick,
-                        id: (new Date()).getTime(),
-                        to: 'dummy@localhost',
-                        type: 'groupchat'
-                    }).c('body').t('romeo: Your attention is required').tree()
-                );
-                return test_utils.waitUntil(() => _converse.rooms_list_view.el.querySelectorAll(".msgs-indicator").length);
-            }).then(() => {
-                spyOn(view.model, 'incrementUnreadMsgCounter').and.callThrough();
-                const indicator_el = _converse.rooms_list_view.el.querySelector(".msgs-indicator");
-                expect(indicator_el.textContent).toBe('1');
-                view.model.onMessage(
-                    $msg({
-                        from: room_jid+'/'+nick,
-                        id: (new Date()).getTime(),
-                        to: 'dummy@localhost',
-                        type: 'groupchat'
-                    }).c('body').t('romeo: and another thing...').tree()
-                );
-                return test_utils.waitUntil(() => view.model.incrementUnreadMsgCounter.calls.count());
-            }).then(() => {
-                let indicator_el = _converse.rooms_list_view.el.querySelector(".msgs-indicator");
-                expect(indicator_el.textContent).toBe('2');
+            // If the user is mentioned, the counter also gets updated
+            view.model.onMessage(
+                $msg({
+                    from: room_jid+'/'+nick,
+                    id: (new Date()).getTime(),
+                    to: 'dummy@localhost',
+                    type: 'groupchat'
+                }).c('body').t('romeo: Your attention is required').tree()
+            );
+            await test_utils.waitUntil(() => _converse.rooms_list_view.el.querySelectorAll(".msgs-indicator").length);
+            spyOn(view.model, 'incrementUnreadMsgCounter').and.callThrough();
+            let indicator_el = _converse.rooms_list_view.el.querySelector(".msgs-indicator");
+            expect(indicator_el.textContent).toBe('1');
+            view.model.onMessage(
+                $msg({
+                    from: room_jid+'/'+nick,
+                    id: (new Date()).getTime(),
+                    to: 'dummy@localhost',
+                    type: 'groupchat'
+                }).c('body').t('romeo: and another thing...').tree()
+            );
+            await test_utils.waitUntil(() => view.model.incrementUnreadMsgCounter.calls.count());
+            indicator_el = _converse.rooms_list_view.el.querySelector(".msgs-indicator");
+            expect(indicator_el.textContent).toBe('2');
 
-                // When the chat gets maximized again, the unread indicators are removed
-                view.model.set({'minimized': false});
-                indicator_el = _converse.rooms_list_view.el.querySelector(".msgs-indicator");
-                expect(_.isNull(indicator_el));
-                const room_el = _converse.rooms_list_view.el.querySelector(".available-chatroom");
-                expect(_.includes(room_el.classList, 'unread-msgs')).toBeFalsy();
-                done();
-            }).catch(_.partial(_converse.log, _, Strophe.LogLevel.FATAL));
+            // When the chat gets maximized again, the unread indicators are removed
+            view.model.set({'minimized': false});
+            indicator_el = _converse.rooms_list_view.el.querySelector(".msgs-indicator");
+            expect(_.isNull(indicator_el));
+            room_el = _converse.rooms_list_view.el.querySelector(".available-chatroom");
+            expect(_.includes(room_el.classList, 'unread-msgs')).toBeFalsy();
+            done();
         }));
     });
 }));