Use async/await in tests

spec/bookmarks.js

@@ -20,13 +20,14 @@
     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) {
@@ -35,16 +36,13 @@
             });
             spyOn(_converse.connection, 'getUniqueId').and.callThrough();
 
-                let view, bookmark;
-                test_utils.openChatRoom(_converse, 'theplay', 'conference.shakespeare.lit', 'JC')
-                .then(() => {
+            await test_utils.openChatRoom(_converse, 'theplay', 'conference.shakespeare.lit', 'JC');
             var jid = 'theplay@conference.shakespeare.lit';
-                    view = _converse.chatboxviews.get(jid);
+            const 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');
+            await test_utils.waitUntil(() => !_.isNull(view.el.querySelector('.toggle-bookmark')));
+            const bookmark = view.el.querySelector('.toggle-bookmark');
             bookmark.click();
             expect(view.renderBookmarkForm).toHaveBeenCalled();
 
@@ -95,8 +93,7 @@
             _converse.connection.IQ_stanzas = [];
             view.el.querySelector('.btn-primary').click();
 
-                    return test_utils.waitUntil(() => sent_stanza);
-                }).then(() => {
+            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">`+
@@ -135,26 +132,25 @@
                 'id':IQ_id
             });
             _converse.connection._dataRecv(test_utils.createRequest(stanza));
-                    return test_utils.waitUntil(() => view.model.get('bookmarked'));
-                }).then(() => {
+            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();
-                }).catch(_.partial(_converse.log, _, Strophe.LogLevel.FATAL));
-            });
         }));
 
+
         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';
+            );
+            let jid = 'lounge@localhost';
             _converse.bookmarks.create({
                 'jid': jid,
                 'autojoin': false,
@@ -172,24 +168,23 @@
             });
             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 () {
+                );
+                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);
@@ -197,26 +192,26 @@
                 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 () {
+                );
+                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();
@@ -270,23 +265,23 @@
                     `</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({
+                const jid = 'theplay@conference.shakespeare.lit';
+                const model = _converse.bookmarks.create({
                     'jid': jid,
                     'autojoin': false,
                     'name':  'The Play',
@@ -294,7 +289,6 @@
                 });
                 expect(_converse.api.rooms.create).not.toHaveBeenCalled();
                 _converse.bookmarks.remove(model);
-
                 _converse.bookmarks.create({
                     'jid': jid,
                     'autojoin': true,
@@ -303,7 +297,6 @@
                 });
                 expect(_converse.api.rooms.create).toHaveBeenCalled();
                 done();
-                });
             }));
         });
     });
@@ -312,15 +305,14 @@
 
         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 () {
+            );
+            await test_utils.waitUntil(() => _converse.bookmarks);
             // Emit here instead of mocking fetching of bookmarks.
             _converse.emit('bookmarksInitialized');
 
@@ -362,12 +354,10 @@
                                             '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 () {
+            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,14 +609,14 @@
         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(
@@ -642,21 +632,19 @@
                 'nick': ' Othello'
             });
             expect(_converse.bookmarks.length).toBe(1);
-                var room_els = _converse.bookmarksview.el.querySelectorAll(".open-room");
+            const 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");
+            const bookmark = _converse.bookmarksview.el.querySelector(".open-room");
             bookmark.click();
-                return test_utils.waitUntil(() => _converse.chatboxviews.get(jid));
-            }).then(() => {
+            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,7 +272,9 @@
         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) {
+                null, ['rosterInitialized', 'chatBoxesInitialized'], {},
+                async function (done, _converse) {
+
                 test_utils.openControlBox();
                 test_utils.createContacts(_converse, 'current', 2);
                 _converse.emit('rosterContactsFetched');
@@ -288,7 +291,7 @@
 
                 // Test for one JID
                 test_utils.openChatBoxFor(_converse, jid);
-                    test_utils.waitUntil(() => _converse.chatboxes.length == 1).then(() => {
+                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));
@@ -297,18 +300,17 @@
                 expect(u.isVisible(chatboxview.el)).toBeTruthy();
                 // Test for multiple JIDs
                 test_utils.openChatBoxFor(_converse, jid2);
-                        return test_utils.waitUntil(() => _converse.chatboxes.length == 2);
-                    }).then(() => {
+                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();
-                    }).catch(_.partial(console.error, _));
             }));
 
             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,7 +321,7 @@
                 // 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) => {
+                const box = await _converse.api.chats.open(jid);
                 expect(box instanceof Object).toBeTruthy();
                 expect(box.get('box_id')).toBe(b64_sha1(jid));
                 expect(
@@ -329,13 +331,11 @@
                 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) => {
+                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,22 +58,20 @@
             { 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(() => {
+            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(() => {
+            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);
 
@@ -82,7 +80,6 @@
             item = room_els[0];
             expect(item.textContent.trim()).toBe('balcony@chat.shakespeare.lit');
             done();
-            }).catch(_.partial(_converse.log, _, Strophe.LogLevel.FATAL));
         }));
 
         it("has an info icon which opens a details modal when clicked", mock.initConverseWithPromises(
@@ -195,15 +192,13 @@
         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(() => {
+            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);
@@ -215,25 +210,20 @@
             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) {
+                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';
-
-            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);
+            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';
-                nick = mock.chatroom_names[0];
+            const nick = mock.chatroom_names[0];
             view.model.onMessage(
                 $msg({
                     from: room_jid+'/'+nick,
@@ -243,9 +233,7 @@
                 }).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"
-                );
+            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
@@ -257,10 +245,9 @@
                     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(() => {
+            await test_utils.waitUntil(() => _converse.rooms_list_view.el.querySelectorAll(".msgs-indicator").length);
             spyOn(view.model, 'incrementUnreadMsgCounter').and.callThrough();
-                const indicator_el = _converse.rooms_list_view.el.querySelector(".msgs-indicator");
+            let indicator_el = _converse.rooms_list_view.el.querySelector(".msgs-indicator");
             expect(indicator_el.textContent).toBe('1');
             view.model.onMessage(
                 $msg({
@@ -270,19 +257,17 @@
                     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");
+            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");
+            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));
         }));
     });
 }));