xmpp.chapril.org-conversejs/tests/utils.js

273 lines
11 KiB
JavaScript
Raw Normal View History

(function (root, factory) {
2018-01-04 12:41:03 +01:00
define(['converse', 'es6-promise', 'mock', 'wait-until-promise'], factory);
}(this, function (converse_api, Promise, mock, waitUntilPromise) {
2017-04-05 11:01:31 +02:00
var _ = converse_api.env._;
var $msg = converse_api.env.$msg;
var $pres = converse_api.env.$pres;
var $iq = converse_api.env.$iq;
var Strophe = converse_api.env.Strophe;
var u = converse_api.env.utils;
var utils = {};
2017-04-05 11:01:31 +02:00
if (typeof window.Promise === 'undefined') {
waitUntilPromise.setPromiseImplementation(Promise);
}
2017-12-03 12:21:57 +01:00
utils.waitUntil = waitUntilPromise.default;
utils.waitUntilDiscoConfirmed = function (_converse, entity_jid, identities, features) {
2017-12-03 12:21:57 +01:00
var IQ_disco, stanza;
return utils.waitUntil(function () {
IQ_disco = _.filter(_converse.connection.IQ_stanzas, function (iq) {
return iq.nodeTree.querySelector('query[xmlns="http://jabber.org/protocol/disco#info"]') &&
iq.nodeTree.getAttribute('to') === entity_jid;
2017-12-03 12:21:57 +01:00
}).pop();
return !_.isUndefined(IQ_disco);
}, 300).then(function () {
var info_IQ_id = IQ_disco.nodeTree.getAttribute('id');
var stanza = $iq({
2017-12-03 12:21:57 +01:00
'type': 'result',
'from': entity_jid,
2017-12-03 12:21:57 +01:00
'to': 'dummy@localhost/resource',
'id': info_IQ_id
}).c('query', {'xmlns': 'http://jabber.org/protocol/disco#info'});
_.forEach(identities, function (identity) {
stanza.c('identity', {'category': 'pubsub', 'type': 'pep'}).up()
});
_.forEach(features, function (feature) {
stanza.c('feature', {'var': feature}).up();
});
2017-12-03 12:21:57 +01:00
_converse.connection._dataRecv(utils.createRequest(stanza));
});
}
2017-04-05 11:01:31 +02:00
utils.createRequest = function (iq) {
iq = typeof iq.tree == "function" ? iq.tree() : iq;
var req = new Strophe.Request(iq, function() {});
req.getResponse = function () {
var env = new Strophe.Builder('env', {type: 'mock'}).tree();
env.appendChild(iq);
return env;
};
return req;
};
utils.closeAllChatBoxes = function (converse) {
var i, chatbox;
for (i=converse.chatboxes.models.length-1; i>-1; i--) {
chatbox = converse.chatboxes.models[i];
converse.chatboxviews.get(chatbox.get('id')).close();
}
return this;
};
utils.openControlBox = function () {
var toggle = document.querySelector(".toggle-controlbox");
if (!u.isVisible(document.querySelector("#controlbox"))) {
if (!u.isVisible(toggle)) {
u.removeClass('hidden', toggle);
2014-02-28 03:04:52 +01:00
}
toggle.click();
}
return this;
};
utils.closeControlBox = function () {
var controlbox = document.querySelector("#controlbox");
if (u.isVisible(controlbox)) {
2018-02-07 13:29:54 +01:00
var button = controlbox.querySelector(".close-chatbox-button");
if (!_.isNull(button)) {
button.click();
}
}
return this;
};
utils.openChatBoxes = function (converse, amount) {
var i = 0, jid, views = [];
for (i; i<amount; i++) {
jid = mock.cur_names[i].replace(/ /g,'.').toLowerCase() + '@localhost';
views[i] = converse.roster.get(jid).trigger("open");
}
return views;
};
utils.openChatBoxFor = function (converse, jid) {
return converse.roster.get(jid).trigger("open");
};
2018-03-11 13:56:53 +01:00
utils.openChatRoomViaModal = function (_converse, jid, nick) {
// Opens a new chatroom
2018-03-11 13:56:53 +01:00
return new Promise(function (resolve, reject) {
utils.openControlBox(_converse);
var roomspanel = _converse.chatboxviews.get('controlbox').roomspanel;
roomspanel.el.querySelector('.trigger-add-chatrooms-modal').click();
utils.closeControlBox(_converse);
const modal = roomspanel.add_room_modal;
utils.waitUntil(function () {
return u.isVisible(modal.el);
}, 1000).then(function () {
modal.el.querySelector('input[name="chatroom"]').value = jid;
modal.el.querySelector('form input[type="submit"]').click();
resolve();
}).catch(_.partial(console.error, _));
}).catch(_.partial(console.error, _));
};
utils.openChatRoom = function (_converse, room, server, nick) {
_converse.api.rooms.open(`${room}@${server}`);
};
2018-03-11 13:56:53 +01:00
utils.openAndEnterChatRoom = function (_converse, room, server, nick) {
2017-07-12 09:55:43 +02:00
return new Promise(function (resolve, reject) {
2018-03-11 13:56:53 +01:00
sinon.spy(_converse.connection, 'sendIQ');
_converse.api.rooms.open(`${room}@${server}`);
var view = _converse.chatboxviews.get((room+'@'+server).toLowerCase());
2017-07-12 09:55:43 +02:00
// We pretend this is a new room, so no disco info is returned.
2018-03-11 13:56:53 +01:00
var IQ_id = _converse.connection.sendIQ.firstCall.returnValue;
2017-07-12 09:55:43 +02:00
var features_stanza = $iq({
2017-12-22 22:24:22 +01:00
'from': room+'@'+server,
2017-07-12 09:55:43 +02:00
'id': IQ_id,
2017-12-22 22:24:22 +01:00
'to': nick+'@'+server+'/desktop',
2017-07-12 09:55:43 +02:00
'type': 'error'
}).c('error', {'type': 'cancel'})
.c('item-not-found', {'xmlns': "urn:ietf:params:xml:ns:xmpp-stanzas"});
2018-03-11 13:56:53 +01:00
_converse.connection._dataRecv(utils.createRequest(features_stanza));
2017-07-12 09:55:43 +02:00
utils.waitUntil(function () {
2018-03-11 13:56:53 +01:00
return _converse.connection.sendIQ.secondCall;
2017-07-12 09:55:43 +02:00
}).then(function () {
// The XMPP server returns the reserved nick for this user.
2018-03-11 13:56:53 +01:00
IQ_id = _converse.connection.sendIQ.secondCall.returnValue;
2017-07-12 09:55:43 +02:00
var stanza = $iq({
'type': 'result',
'id': IQ_id,
'from': view.model.get('jid'),
2018-03-11 13:56:53 +01:00
'to': _converse.connection.jid
2017-07-12 09:55:43 +02:00
}).c('query', {'xmlns': 'http://jabber.org/protocol/disco#info', 'node': 'x-roomuser-item'})
.c('identity', {'category': 'conference', 'name': nick, 'type': 'text'});
2018-03-11 13:56:53 +01:00
_converse.connection._dataRecv(utils.createRequest(stanza));
2017-07-12 09:55:43 +02:00
// The user has just entered the room (because join was called)
// and receives their own presence from the server.
// See example 24: http://xmpp.org/extensions/xep-0045.html#enter-pres
var presence = $pres({
2018-03-11 13:56:53 +01:00
to: _converse.connection.jid,
2017-07-12 09:55:43 +02:00
from: room+'@'+server+'/'+nick,
id: 'DC352437-C019-40EC-B590-AF29E879AF97'
}).c('x').attrs({xmlns:'http://jabber.org/protocol/muc#user'})
.c('item').attrs({
affiliation: 'member',
2018-03-11 13:56:53 +01:00
jid: _converse.bare_jid,
role: 'participant'
2017-07-12 09:55:43 +02:00
}).up()
.c('status').attrs({code:'110'});
2018-03-11 13:56:53 +01:00
_converse.connection._dataRecv(utils.createRequest(presence));
_converse.connection.sendIQ.restore();
2017-07-12 09:55:43 +02:00
resolve();
2018-03-11 13:56:53 +01:00
}).catch(_.partial(console.error, _));
}).catch(_.partial(console.error, _));
};
2014-06-30 19:55:26 +02:00
utils.clearBrowserStorage = function () {
window.localStorage.clear();
window.sessionStorage.clear();
return this;
2014-06-30 19:55:26 +02:00
};
utils.clearChatBoxMessages = function (converse, jid) {
2014-03-04 14:54:36 +01:00
var view = converse.chatboxviews.get(jid);
2018-01-04 12:41:03 +01:00
view.el.querySelector('.chat-content').innerHTML = '';
view.model.messages.reset();
2014-06-30 19:21:16 +02:00
view.model.messages.browserStorage._clear();
};
utils.createContacts = function (converse, type, length) {
/* Create current (as opposed to requesting or pending) contacts
* for the user's roster.
*
* These contacts are not grouped. See below.
*/
2017-04-05 11:01:31 +02:00
var names, jid, subscription, requesting, ask;
if (type === 'requesting') {
names = mock.req_names;
subscription = 'none';
requesting = true;
ask = null;
} else if (type === 'pending') {
names = mock.pend_names;
subscription = 'none';
requesting = false;
ask = 'subscribe';
} else if (type === 'current') {
names = mock.cur_names;
subscription = 'both';
requesting = false;
ask = null;
} else if (type === 'all') {
this.createContacts(converse, 'current')
.createContacts(converse, 'requesting')
.createContacts(converse, 'pending');
return this;
} else {
2017-04-05 11:01:31 +02:00
throw Error("Need to specify the type of contact to create");
}
if (typeof length === 'undefined') {
length = names.length;
}
2017-04-05 11:01:31 +02:00
for (var i=0; i<length; i++) {
jid = names[i].replace(/ /g,'.').toLowerCase() + '@localhost';
if (!converse.roster.get(jid)) {
converse.roster.create({
'ask': ask,
'fullname': names[i],
'jid': jid,
'requesting': requesting,
'subscription': subscription
});
}
}
return this;
};
utils.createGroupedContacts = function (converse) {
/* Create grouped contacts
*/
var i=0, j=0;
_.each(_.keys(mock.groups), function (name) {
j = i;
for (i=j; i<j+mock.groups[name]; i++) {
converse.roster.create({
jid: mock.cur_names[i].replace(/ /g,'.').toLowerCase() + '@localhost',
subscription: 'both',
ask: null,
groups: name === 'ungrouped'? [] : [name],
fullname: mock.cur_names[i]
});
}
});
};
utils.createChatMessage = function (_converse, sender_jid, message) {
return $msg({
from: sender_jid,
to: _converse.connection.jid,
type: 'chat',
id: (new Date()).getTime()
})
.c('body').t(message).up()
.c('active', {'xmlns': Strophe.NS.CHATSTATES}).tree();
}
utils.sendMessage = function (chatboxview, message) {
chatboxview.el.querySelector('.chat-textarea').value = message;
chatboxview.keyPressed({
target: chatboxview.el.querySelector('textarea.chat-textarea'),
preventDefault: _.noop,
keyCode: 13
});
};
return utils;
}));