Skip to content

C
converse.js
Commit c22fe41a authored by JC Brand's avatar JC Brand
Browse files
Options

Use async/await in tests

parent cb3ba7bd
Hide whitespace changes
Inline Side-by-side
Showing with 447 additions and 474 deletions
spec/bookmarks.js
View file @ c22fe41a
...@@ -20,290 +20,283 @@ ...@@ -20,290 +20,283 @@
describe("A chat room", function () { describe("A chat room", function () {
it("can be bookmarked", mock.initConverseWithPromises( 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, _converse, _converse.bare_jid,
[{'category': 'pubsub', 'type': 'pep'}], [{'category': 'pubsub', 'type': 'pep'}],
['http://jabber.org/protocol/pubsub#publish-options'] ['http://jabber.org/protocol/pubsub#publish-options']
).then(function () { );
let sent_stanza, IQ_id; let sent_stanza, IQ_id;
const sendIQ = _converse.connection.sendIQ; const sendIQ = _converse.connection.sendIQ;
spyOn(_converse.connection, 'sendIQ').and.callFake(function (iq, callback, errback) { spyOn(_converse.connection, 'sendIQ').and.callFake(function (iq, callback, errback) {
sent_stanza = iq; sent_stanza = iq;
IQ_id = sendIQ.bind(this)(iq, callback, errback); 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));
}); });
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( 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, _converse, _converse.bare_jid,
[{'category': 'pubsub', 'type': 'pep'}], [{'category': 'pubsub', 'type': 'pep'}],
['http://jabber.org/protocol/pubsub#publish-options'] ['http://jabber.org/protocol/pubsub#publish-options']
).then(function () { );
var jid = 'lounge@localhost'; let jid = 'lounge@localhost';
_converse.bookmarks.create({ _converse.bookmarks.create({
'jid': jid, 'jid': jid,
'autojoin': false, 'autojoin': false,
'name': 'The Lounge', 'name': 'The Lounge',
'nick': ' Othello' 'nick': ' Othello'
}); });
expect(_.isUndefined(_converse.chatboxviews.get(jid))).toBeTruthy(); expect(_.isUndefined(_converse.chatboxviews.get(jid))).toBeTruthy();
jid = 'theplay@conference.shakespeare.lit'; jid = 'theplay@conference.shakespeare.lit';
_converse.bookmarks.create({ _converse.bookmarks.create({
'jid': jid, 'jid': jid,
'autojoin': true, 'autojoin': true,
'name': 'The Play', 'name': 'The Play',
'nick': ' Othello' 'nick': ' Othello'
});
expect(_.isUndefined(_converse.chatboxviews.get(jid))).toBeFalsy();
done();
}); });
expect(_.isUndefined(_converse.chatboxviews.get(jid))).toBeFalsy();
done();
})); }));
describe("when bookmarked", function () { describe("when bookmarked", function () {
it("displays that it's bookmarked through its bookmark icon", mock.initConverseWithPromises( 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( test_utils.waitUntilDiscoConfirmed(
_converse, _converse.bare_jid, _converse, _converse.bare_jid,
[{'category': 'pubsub', 'type': 'pep'}], [{'category': 'pubsub', 'type': 'pep'}],
['http://jabber.org/protocol/pubsub#publish-options'] ['http://jabber.org/protocol/pubsub#publish-options']
).then(() => test_utils.openChatRoom(_converse, 'lounge', 'localhost', 'dummy')) );
.then(() => { await test_utils.openChatRoom(_converse, 'lounge', 'localhost', 'dummy');
view = _converse.chatboxviews.get('lounge@localhost'); const view = _converse.chatboxviews.get('lounge@localhost');
return test_utils.waitUntil(() => !_.isNull(view.el.querySelector('.toggle-bookmark'))) await test_utils.waitUntil(() => !_.isNull(view.el.querySelector('.toggle-bookmark')));
}).then(function () { var bookmark_icon = view.el.querySelector('.toggle-bookmark');
var bookmark_icon = view.el.querySelector('.toggle-bookmark'); expect(_.includes(bookmark_icon.classList, 'button-on')).toBeFalsy();
expect(_.includes(bookmark_icon.classList, 'button-on')).toBeFalsy(); view.model.set('bookmarked', true);
view.model.set('bookmarked', true); expect(_.includes(bookmark_icon.classList, 'button-on')).toBeTruthy();
expect(_.includes(bookmark_icon.classList, 'button-on')).toBeTruthy(); view.model.set('bookmarked', false);
view.model.set('bookmarked', false); expect(_.includes(bookmark_icon.classList, 'button-on')).toBeFalsy();
expect(_.includes(bookmark_icon.classList, 'button-on')).toBeFalsy(); done();
done();
});
})); }));
it("can be unbookmarked", mock.initConverseWithPromises( 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, _converse, _converse.bare_jid,
[{'category': 'pubsub', 'type': 'pep'}], [{'category': 'pubsub', 'type': 'pep'}],
['http://jabber.org/protocol/pubsub#publish-options'] ['http://jabber.org/protocol/pubsub#publish-options']
).then(() => { );
sendIQ = _converse.connection.sendIQ; const sendIQ = _converse.connection.sendIQ;
return test_utils.openChatRoom(_converse, 'theplay', 'conference.shakespeare.lit', 'JC'); await test_utils.openChatRoom(_converse, 'theplay', 'conference.shakespeare.lit', 'JC');
}).then(() => {
var jid = 'theplay@conference.shakespeare.lit'; const jid = 'theplay@conference.shakespeare.lit';
view = _converse.chatboxviews.get(jid); const view = _converse.chatboxviews.get(jid);
return test_utils.waitUntil(() => !_.isNull(view.el.querySelector('.toggle-bookmark'))); await test_utils.waitUntil(() => !_.isNull(view.el.querySelector('.toggle-bookmark')));
}).then(function () {
spyOn(view, 'toggleBookmark').and.callThrough(); spyOn(view, 'toggleBookmark').and.callThrough();
spyOn(_converse.bookmarks, 'sendBookmarkStanza').and.callThrough(); spyOn(_converse.bookmarks, 'sendBookmarkStanza').and.callThrough();
view.delegateEvents(); view.delegateEvents();
_converse.bookmarks.create({ _converse.bookmarks.create({
'jid': view.model.get('jid'), 'jid': view.model.get('jid'),
'autojoin': false, 'autojoin': false,
'name': 'The Play', 'name': 'The Play',
'nick': ' Othello' 'nick': ' Othello'
}); });
expect(_converse.bookmarks.length).toBe(1); expect(_converse.bookmarks.length).toBe(1);
expect(view.model.get('bookmarked')).toBeTruthy(); expect(view.model.get('bookmarked')).toBeTruthy();
var bookmark_icon = view.el.querySelector('.toggle-bookmark'); var bookmark_icon = view.el.querySelector('.toggle-bookmark');
expect(u.hasClass('button-on', bookmark_icon)).toBeTruthy(); expect(u.hasClass('button-on', bookmark_icon)).toBeTruthy();
spyOn(_converse.connection, 'sendIQ').and.callFake(function (iq, callback, errback) { spyOn(_converse.connection, 'sendIQ').and.callFake(function (iq, callback, errback) {
sent_stanza = iq; sent_stanza = iq;
IQ_id = sendIQ.bind(this)(iq, callback, errback); 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();
}); });
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 () { describe("and when autojoin is set", function () {
it("will be be opened and joined automatically upon login", mock.initConverseWithPromises( 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, _converse, _converse.bare_jid,
[{'category': 'pubsub', 'type': 'pep'}], [{'category': 'pubsub', 'type': 'pep'}],
['http://jabber.org/protocol/pubsub#publish-options'] ['http://jabber.org/protocol/pubsub#publish-options']
).then(function () { );
spyOn(_converse.api.rooms, 'create').and.callThrough(); spyOn(_converse.api.rooms, 'create').and.callThrough();
var jid = 'theplay@conference.shakespeare.lit'; const jid = 'theplay@conference.shakespeare.lit';
var model = _converse.bookmarks.create({ const model = _converse.bookmarks.create({
'jid': jid, 'jid': jid,
'autojoin': false, 'autojoin': false,
'name': 'The Play', 'name': 'The Play',
'nick': '' '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();
}); });
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 @@ ...@@ -312,62 +305,59 @@
it("can be pushed from the XMPP server", mock.initConverseWithPromises( it("can be pushed from the XMPP server", mock.initConverseWithPromises(
['send'], ['rosterGroupsFetched', 'connected'], {}, ['send'], ['rosterGroupsFetched', 'connected'], {},
function (done, _converse) { async function (done, _converse) {
test_utils.waitUntilDiscoConfirmed( await test_utils.waitUntilDiscoConfirmed(
_converse, _converse.bare_jid, _converse, _converse.bare_jid,
[{'category': 'pubsub', 'type': 'pep'}], [{'category': 'pubsub', 'type': 'pep'}],
['http://jabber.org/protocol/pubsub#publish-options'] ['http://jabber.org/protocol/pubsub#publish-options']
).then(function () { );
return test_utils.waitUntil(() => _converse.bookmarks); await test_utils.waitUntil(() => _converse.bookmarks);
}).then(function () { // Emit here instead of mocking fetching of bookmarks.
// Emit here instead of mocking fetching of bookmarks. _converse.emit('bookmarksInitialized');
_converse.emit('bookmarksInitialized');
/* The stored data is automatically pushed to all of the user's
/* The stored data is automatically pushed to all of the user's * connected resources.
* connected resources. *
* * Publisher receives event notification
* Publisher receives event notification * -------------------------------------
* ------------------------------------- * <message from='juliet@capulet.lit'
* <message from='juliet@capulet.lit' * to='juliet@capulet.lit/balcony'
* to='juliet@capulet.lit/balcony' * type='headline'
* type='headline' * id='rnfoo1'>
* id='rnfoo1'> * <event xmlns='http://jabber.org/protocol/pubsub#event'>
* <event xmlns='http://jabber.org/protocol/pubsub#event'> * <items node='storage:bookmarks'>
* <items node='storage:bookmarks'> * <item id='current'>
* <item id='current'> * <storage xmlns='storage:bookmarks'>
* <storage xmlns='storage:bookmarks'> * <conference name='The Play&apos;s the Thing'
* <conference name='The Play&apos;s the Thing' * autojoin='true'
* autojoin='true' * jid='theplay@conference.shakespeare.lit'>
* jid='theplay@conference.shakespeare.lit'> * <nick>JC</nick>
* <nick>JC</nick> * </conference>
* </conference> * </storage>
* </storage> * </item>
* </item> * </items>
* </items> * </event>
* </event> * </message>
* </message> */
*/ var stanza = $msg({
var stanza = $msg({ 'from': 'dummy@localhost',
'from': 'dummy@localhost', 'to': 'dummy@localhost/resource',
'to': 'dummy@localhost/resource', 'type': 'headline',
'type': 'headline', 'id': 'rnfoo1'
'id': 'rnfoo1' }).c('event', {'xmlns': 'http://jabber.org/protocol/pubsub#event'})
}).c('event', {'xmlns': 'http://jabber.org/protocol/pubsub#event'}) .c('items', {'node': 'storage:bookmarks'})
.c('items', {'node': 'storage:bookmarks'}) .c('item', {'id': 'current'})
.c('item', {'id': 'current'}) .c('storage', {'xmlns': 'storage:bookmarks'})
.c('storage', {'xmlns': 'storage:bookmarks'}) .c('conference', {'name': 'The Play&apos;s the Thing',
.c('conference', {'name': 'The Play&apos;s the Thing', 'autojoin': 'true',
'autojoin': 'true', 'jid':'theplay@conference.shakespeare.lit'})
'jid':'theplay@conference.shakespeare.lit'}) .c('nick').t('JC');
.c('nick').t('JC'); _converse.connection._dataRecv(test_utils.createRequest(stanza));
_converse.connection._dataRecv(test_utils.createRequest(stanza)); await test_utils.waitUntil(() => _converse.bookmarks.length);
return test_utils.waitUntil(() => _converse.bookmarks.length); expect(_converse.bookmarks.length).toBe(1);
}).then(function () { expect(_converse.chatboxviews.get('theplay@conference.shakespeare.lit')).not.toBeUndefined();
expect(_converse.bookmarks.length).toBe(1); done();
expect(_converse.chatboxviews.get('theplay@conference.shakespeare.lit')).not.toBeUndefined();
done();
});
})); }));
...@@ -619,44 +609,42 @@ ...@@ -619,44 +609,42 @@
it("can be closed", mock.initConverseWithPromises( it("can be closed", mock.initConverseWithPromises(
null, ['rosterGroupsFetched'], null, ['rosterGroupsFetched'],
{ hide_open_bookmarks: true }, { hide_open_bookmarks: true },
function (done, _converse) { async function (done, _converse) {
const jid = 'room@conference.example.org'; const jid = 'room@conference.example.org';
test_utils.waitUntilDiscoConfirmed( await test_utils.waitUntilDiscoConfirmed(
_converse, _converse.bare_jid, _converse, _converse.bare_jid,
[{'category': 'pubsub', 'type': 'pep'}], [{'category': 'pubsub', 'type': 'pep'}],
['http://jabber.org/protocol/pubsub#publish-options'] ['http://jabber.org/protocol/pubsub#publish-options']
).then(function () { );
// XXX Create bookmarks view here, otherwise we need to mock stanza // XXX Create bookmarks view here, otherwise we need to mock stanza
// traffic for it to get created. // traffic for it to get created.
_converse.bookmarksview = new _converse.BookmarksView( _converse.bookmarksview = new _converse.BookmarksView(
{'model': _converse.bookmarks} {'model': _converse.bookmarks}
); );
_converse.emit('bookmarksInitialized'); _converse.emit('bookmarksInitialized');
// Check that it's there // Check that it's there
_converse.bookmarks.create({ _converse.bookmarks.create({
'jid': jid, 'jid': jid,
'autojoin': false, 'autojoin': false,
'name': 'The Play', 'name': 'The Play',
'nick': ' Othello' '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();
}); });
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
View file @ c22fe41a
...@@ -11,9 +11,10 @@ ...@@ -11,9 +11,10 @@
describe("Converse", function() { describe("Converse", function() {
describe("Authentication", function () { describe("Authentication", function () {
it("needs either a bosh_service_url a websocket_url or both", mock.initConverse(function (_converse) { it("needs either a bosh_service_url a websocket_url or both", mock.initConverse(function (_converse) {
var url = _converse.bosh_service_url; const url = _converse.bosh_service_url;
var connection = _converse.connection; const connection = _converse.connection;
delete _converse.bosh_service_url; delete _converse.bosh_service_url;
delete _converse.connection; delete _converse.connection;
expect(_converse.initConnection).toThrow( expect(_converse.initConnection).toThrow(
...@@ -271,44 +272,45 @@ ...@@ -271,44 +272,45 @@
describe("The \"chats\" API", function() { describe("The \"chats\" API", function() {
it("has a method 'get' which returns the promise that resolves to a chat model", mock.initConverseWithPromises( 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'], {},
test_utils.openControlBox(); async function (done, _converse) {
test_utils.createContacts(_converse, 'current', 2);
_converse.emit('rosterContactsFetched'); test_utils.openControlBox();
test_utils.createContacts(_converse, 'current', 2);
// Test on chat that doesn't exist. _converse.emit('rosterContactsFetched');
expect(_converse.api.chats.get('non-existing@jabber.org')).toBeFalsy();
const jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost'; // Test on chat that doesn't exist.
const jid2 = mock.cur_names[1].replace(/ /g,'.').toLowerCase() + '@localhost'; expect(_converse.api.chats.get('non-existing@jabber.org')).toBeFalsy();
const jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
// Test on chat that's not open const jid2 = mock.cur_names[1].replace(/ /g,'.').toLowerCase() + '@localhost';
let box = _converse.api.chats.get(jid);
expect(typeof box === 'undefined').toBeTruthy(); // Test on chat that's not open
expect(_converse.chatboxes.length).toBe(1); let box = _converse.api.chats.get(jid);
expect(typeof box === 'undefined').toBeTruthy();
// Test for one JID expect(_converse.chatboxes.length).toBe(1);
test_utils.openChatBoxFor(_converse, jid);
test_utils.waitUntil(() => _converse.chatboxes.length == 1).then(() => { // Test for one JID
box = _converse.api.chats.get(jid); test_utils.openChatBoxFor(_converse, jid);
expect(box instanceof Object).toBeTruthy(); await test_utils.waitUntil(() => _converse.chatboxes.length == 1);
expect(box.get('box_id')).toBe(b64_sha1(jid)); box = _converse.api.chats.get(jid);
expect(box instanceof Object).toBeTruthy();
const chatboxview = _converse.chatboxviews.get(jid); expect(box.get('box_id')).toBe(b64_sha1(jid));
expect(u.isVisible(chatboxview.el)).toBeTruthy();
// Test for multiple JIDs const chatboxview = _converse.chatboxviews.get(jid);
test_utils.openChatBoxFor(_converse, jid2); expect(u.isVisible(chatboxview.el)).toBeTruthy();
return test_utils.waitUntil(() => _converse.chatboxes.length == 2); // Test for multiple JIDs
}).then(() => { test_utils.openChatBoxFor(_converse, jid2);
const list = _converse.api.chats.get([jid, jid2]); await test_utils.waitUntil(() => _converse.chatboxes.length == 2);
expect(_.isArray(list)).toBeTruthy(); const list = _converse.api.chats.get([jid, jid2]);
expect(list[0].get('box_id')).toBe(b64_sha1(jid)); expect(_.isArray(list)).toBeTruthy();
expect(list[1].get('box_id')).toBe(b64_sha1(jid2)); expect(list[0].get('box_id')).toBe(b64_sha1(jid));
done(); expect(list[1].get('box_id')).toBe(b64_sha1(jid2));
}).catch(_.partial(console.error, _)); done();
})); }));
it("has a method 'open' which opens and returns a promise that resolves to a chat model", mock.initConverseWithPromises( 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.openControlBox();
test_utils.createContacts(_converse, 'current', 2); test_utils.createContacts(_converse, 'current', 2);
...@@ -319,23 +321,21 @@ ...@@ -319,23 +321,21 @@
// Test on chat that doesn't exist. // Test on chat that doesn't exist.
expect(_converse.api.chats.get('non-existing@jabber.org')).toBeFalsy(); 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 instanceof Object).toBeTruthy();
expect(box.get('box_id')).toBe(b64_sha1(jid)); expect(box.get('box_id')).toBe(b64_sha1(jid));
expect( expect(
_.keys(box), _.keys(box),
['close', 'endOTR', 'focus', 'get', 'initiateOTR', 'is_chatroom', 'maximize', 'minimize', 'open', 'set'] ['close', 'endOTR', 'focus', 'get', 'initiateOTR', 'is_chatroom', 'maximize', 'minimize', 'open', 'set']
); );
const chatboxview = _converse.chatboxviews.get(jid); const chatboxview = _converse.chatboxviews.get(jid);
expect(u.isVisible(chatboxview.el)).toBeTruthy(); expect(u.isVisible(chatboxview.el)).toBeTruthy();
// Test for multiple JIDs // Test for multiple JIDs
return _converse.api.chats.open([jid, jid2]); const list = await _converse.api.chats.open([jid, jid2]);
}).then((list) => { expect(_.isArray(list)).toBeTruthy();
expect(_.isArray(list)).toBeTruthy(); expect(list[0].get('box_id')).toBe(b64_sha1(jid));
expect(list[0].get('box_id')).toBe(b64_sha1(jid)); expect(list[1].get('box_id')).toBe(b64_sha1(jid2));
expect(list[1].get('box_id')).toBe(b64_sha1(jid2)); done();
done();
});
})); }));
}); });
...@@ -361,7 +361,7 @@ ...@@ -361,7 +361,7 @@
it("only has a method 'add' for registering plugins", mock.initConverse(function (_converse) { it("only has a method 'add' for registering plugins", mock.initConverse(function (_converse) {
expect(_.keys(converse.plugins)).toEqual(["add"]); expect(_.keys(converse.plugins)).toEqual(["add"]);
// Cheating a little bit. We clear the plugins to test more easily. // 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.pluggable.plugins = [];
converse.plugins.add('plugin1', {}); converse.plugins.add('plugin1', {});
expect(_.keys(_converse.pluggable.plugins)).toEqual(['plugin1']); expect(_.keys(_converse.pluggable.plugins)).toEqual(['plugin1']);
......
spec/roomslist.js
View file @ c22fe41a
...@@ -58,31 +58,28 @@ ...@@ -58,31 +58,28 @@
{ whitelisted_plugins: ['converse-roomslist'], { whitelisted_plugins: ['converse-roomslist'],
allow_bookmarks: false // Makes testing easier, otherwise we allow_bookmarks: false // Makes testing easier, otherwise we
// have to mock stanza traffic. // have to mock stanza traffic.
}, function (done, _converse) { }, async function (done, _converse) {
spyOn(_converse, 'isSingleton').and.callFake(() => true); spyOn(_converse, 'isSingleton').and.callFake(() => true);
let room_els, item; let room_els, item;
test_utils.openControlBox(); test_utils.openControlBox();
_converse.api.rooms.open('coven@chat.shakespeare.lit', {'nick': 'some1'}) await _converse.api.rooms.open('coven@chat.shakespeare.lit', {'nick': 'some1'});
.then(() => { room_els = _converse.rooms_list_view.el.querySelectorAll(".available-chatroom");
room_els = _converse.rooms_list_view.el.querySelectorAll(".available-chatroom"); expect(room_els.length).toBe(1);
expect(room_els.length).toBe(1);
item = room_els[0]; item = room_els[0];
expect(u.hasClass('open', item)).toBe(true); expect(u.hasClass('open', item)).toBe(true);
expect(item.textContent.trim()).toBe('coven@chat.shakespeare.lit'); expect(item.textContent.trim()).toBe('coven@chat.shakespeare.lit');
return _converse.api.rooms.open('balcony@chat.shakespeare.lit', {'nick': 'some1'}); await _converse.api.rooms.open('balcony@chat.shakespeare.lit', {'nick': 'some1'});
}).then(() => { room_els = _converse.rooms_list_view.el.querySelectorAll(".open-room");
room_els = _converse.rooms_list_view.el.querySelectorAll(".open-room"); expect(room_els.length).toBe(2);
expect(room_els.length).toBe(2);
room_els = _converse.rooms_list_view.el.querySelectorAll(".available-chatroom.open"); room_els = _converse.rooms_list_view.el.querySelectorAll(".available-chatroom.open");
expect(room_els.length).toBe(1); expect(room_els.length).toBe(1);
item = room_els[0]; item = room_els[0];
expect(item.textContent.trim()).toBe('balcony@chat.shakespeare.lit'); expect(item.textContent.trim()).toBe('balcony@chat.shakespeare.lit');
done(); done();
}).catch(_.partial(_converse.log, _, Strophe.LogLevel.FATAL));
})); }));
it("has an info icon which opens a details modal when clicked", mock.initConverseWithPromises( it("has an info icon which opens a details modal when clicked", mock.initConverseWithPromises(
...@@ -195,94 +192,82 @@ ...@@ -195,94 +192,82 @@
it("can be closed", mock.initConverseWithPromises( it("can be closed", mock.initConverseWithPromises(
null, ['rosterGroupsFetched'], null, ['rosterGroupsFetched'],
{ whitelisted_plugins: ['converse-roomslist'], { whitelisted_plugins: ['converse-roomslist'],
allow_bookmarks: false // Makes testing easier, otherwise we allow_bookmarks: false // Makes testing easier, otherwise we have to mock stanza traffic.
// have to mock stanza traffic.
}, },
function (done, _converse) { async function (done, _converse) {
spyOn(window, 'confirm').and.callFake(() => true); spyOn(window, 'confirm').and.callFake(() => true);
expect(_converse.chatboxes.length).toBe(1); expect(_converse.chatboxes.length).toBe(1);
test_utils.openChatRoom(_converse, 'lounge', 'conference.shakespeare.lit', 'JC') await test_utils.openChatRoom(_converse, 'lounge', 'conference.shakespeare.lit', 'JC');
.then(() => { expect(_converse.chatboxes.length).toBe(2);
expect(_converse.chatboxes.length).toBe(2); var room_els = _converse.rooms_list_view.el.querySelectorAll(".open-room");
var room_els = _converse.rooms_list_view.el.querySelectorAll(".open-room"); expect(room_els.length).toBe(1);
expect(room_els.length).toBe(1); var close_el = _converse.rooms_list_view.el.querySelector(".close-room");
var close_el = _converse.rooms_list_view.el.querySelector(".close-room"); close_el.click();
close_el.click(); expect(window.confirm).toHaveBeenCalledWith(
expect(window.confirm).toHaveBeenCalledWith( 'Are you sure you want to leave the groupchat lounge@conference.shakespeare.lit?');
'Are you sure you want to leave the groupchat lounge@conference.shakespeare.lit?'); room_els = _converse.rooms_list_view.el.querySelectorAll(".open-room");
room_els = _converse.rooms_list_view.el.querySelectorAll(".open-room"); expect(room_els.length).toBe(0);
expect(room_els.length).toBe(0); expect(_converse.chatboxes.length).toBe(1);
expect(_converse.chatboxes.length).toBe(1); done();
done();
});
})); }));
it("shows unread messages directed at the user", mock.initConverseWithAsync( it("shows unread messages directed at the user", mock.initConverseWithAsync(
{ whitelisted_plugins: ['converse-roomslist'], { whitelisted_plugins: ['converse-roomslist'],
allow_bookmarks: false // Makes testing easier, otherwise we allow_bookmarks: false // Makes testing easier, otherwise we have to mock stanza traffic.
// have to mock stanza traffic. }, async function (done, _converse) {
}, function (done, _converse) {
let view, nick;
const room_jid = 'kitchen@conference.shakespeare.lit'; 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) // If the user isn't mentioned, the counter doesn't get incremented, but the text of the groupchat is bold
.then(() => test_utils.openAndEnterChatRoom(_converse, 'kitchen', 'conference.shakespeare.lit', 'romeo')) let room_el = _converse.rooms_list_view.el.querySelector(".available-chatroom");
.then(() => { expect(_.includes(room_el.classList, 'unread-msgs'));
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 is mentioned, the counter also gets updated // If the user is mentioned, the counter also gets updated
view.model.onMessage( view.model.onMessage(
$msg({ $msg({
from: room_jid+'/'+nick, from: room_jid+'/'+nick,
id: (new Date()).getTime(), id: (new Date()).getTime(),
to: 'dummy@localhost', to: 'dummy@localhost',
type: 'groupchat' type: 'groupchat'
}).c('body').t('romeo: Your attention is required').tree() }).c('body').t('romeo: Your attention is required').tree()
); );
return test_utils.waitUntil(() => _converse.rooms_list_view.el.querySelectorAll(".msgs-indicator").length); await test_utils.waitUntil(() => _converse.rooms_list_view.el.querySelectorAll(".msgs-indicator").length);
}).then(() => { spyOn(view.model, 'incrementUnreadMsgCounter').and.callThrough();
spyOn(view.model, 'incrementUnreadMsgCounter').and.callThrough(); let indicator_el = _converse.rooms_list_view.el.querySelector(".msgs-indicator");
const indicator_el = _converse.rooms_list_view.el.querySelector(".msgs-indicator"); expect(indicator_el.textContent).toBe('1');
expect(indicator_el.textContent).toBe('1'); view.model.onMessage(
view.model.onMessage( $msg({
$msg({ from: room_jid+'/'+nick,
from: room_jid+'/'+nick, id: (new Date()).getTime(),
id: (new Date()).getTime(), to: 'dummy@localhost',
to: 'dummy@localhost', type: 'groupchat'
type: 'groupchat' }).c('body').t('romeo: and another thing...').tree()
}).c('body').t('romeo: and another thing...').tree() );
); await test_utils.waitUntil(() => view.model.incrementUnreadMsgCounter.calls.count());
return test_utils.waitUntil(() => view.model.incrementUnreadMsgCounter.calls.count()); indicator_el = _converse.rooms_list_view.el.querySelector(".msgs-indicator");
}).then(() => { expect(indicator_el.textContent).toBe('2');
let 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 // When the chat gets maximized again, the unread indicators are removed
view.model.set({'minimized': false}); view.model.set({'minimized': false});
indicator_el = _converse.rooms_list_view.el.querySelector(".msgs-indicator"); indicator_el = _converse.rooms_list_view.el.querySelector(".msgs-indicator");
expect(_.isNull(indicator_el)); 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(); expect(_.includes(room_el.classList, 'unread-msgs')).toBeFalsy();
done(); done();
}).catch(_.partial(_converse.log, _, Strophe.LogLevel.FATAL));
})); }));
}); });
})); }));
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7