Chapril/xmpp.chapril.org-conversejs
Chapril/xmpp.chapril.org-conversejs
25
0
Fork 0
Code Issues Pull Requests Projects Releases Activity
59e216ad34
xmpp.chapril.org-conversejs/spec/messages.js

1671 lines
88 KiB
JavaScript
Raw Normal View History

chatview: Scroll down on image load
2020-07-14 14:06:52 +02:00
/*global mock, converse */
Use Karma as test runner
2020-04-22 13:11:48 +02:00
const { Promise, Strophe, $msg, dayjs, sizzle, _ } = converse.env;
const u = converse.env.utils;
describe("A Chat Message", function () {
Re-add support for a new messages indicator Fixes #2040
2020-06-01 16:05:00 +02:00
it("will be demarcated if it's the first newly received message",
mock.initConverse(['rosterGroupsFetched', 'chatBoxesFetched'], {},
async function (done, _converse) {
await mock.waitForRoster(_converse, 'current', 1);
const contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@montague.lit';
await mock.openChatBoxFor(_converse, contact_jid);
const view = _converse.api.chatviews.get(contact_jid);
await _converse.handleMessageStanza(mock.createChatMessage(_converse, contact_jid, 'This message will be read'));
Rename `api.settings.update` to `api.settings.extend` This is to try and make it clearer that this method won't override initialization settings, and is instead simply to add to the default settings.
2020-06-03 09:17:13 +02:00
const msg_el = await u.waitUntil(() => view.el.querySelector('converse-chat-message'));
expect(msg_el.querySelector('.chat-msg__text').textContent).toBe('This message will be read');
expect(view.model.get('num_unread')).toBe(0);
Re-add support for a new messages indicator Fixes #2040
2020-06-01 16:05:00 +02:00
_converse.windowState = 'hidden';
await _converse.handleMessageStanza(mock.createChatMessage(_converse, contact_jid, 'This message will be new'));
await u.waitUntil(() => view.model.messages.length);
expect(view.model.get('num_unread')).toBe(1);
expect(view.model.get('first_unread_id')).toBe(view.model.messages.last().get('id'));
await u.waitUntil(() => view.el.querySelectorAll('converse-chat-message').length === 2);
const last_msg_el = view.el.querySelector('converse-chat-message:last-child');
expect(last_msg_el.firstElementChild?.textContent).toBe('New messages');
done();
}));
Use Karma as test runner
2020-04-22 13:11:48 +02:00
it("is rejected if it's an unencapsulated forwarded message",
mock.initConverse(
['rosterGroupsFetched', 'chatBoxesFetched'], {},
async function (done, _converse) {
await mock.waitForRoster(_converse, 'current', 2);
const contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@montague.lit';
const forwarded_contact_jid = mock.cur_names[1].replace(/ /g,'.').toLowerCase() + '@montague.lit';
await mock.openChatBoxFor(_converse, contact_jid);
let models = await _converse.api.chats.get();
expect(models.length).toBe(1);
const received_stanza = u.toStanza(`
<message to='${_converse.jid}' from='${contact_jid}' type='chat' id='${_converse.connection.getUniqueId()}'>
<body>A most courteous exposition!</body>
<forwarded xmlns='urn:xmpp:forward:0'>
<delay xmlns='urn:xmpp:delay' stamp='2019-07-10T23:08:25Z'/>
<message from='${forwarded_contact_jid}'
id='0202197'
to='${_converse.bare_jid}'
type='chat'
xmlns='jabber:client'>
<body>Yet I should kill thee with much cherishing.</body>
<mood xmlns='http://jabber.org/protocol/mood'>
<amorous/>
</mood>
</message>
</forwarded>
</message>
`);
_converse.connection._dataRecv(mock.createRequest(received_stanza));
const sent_stanzas = _converse.connection.sent_stanzas;
const sent_stanza = await u.waitUntil(() => sent_stanzas.filter(s => s.querySelector('error')).pop());
expect(Strophe.serialize(sent_stanza)).toBe(
`<message id="${received_stanza.getAttribute('id')}" to="${contact_jid}" type="error" xmlns="jabber:client">`+
'<error type="cancel">'+
'<not-allowed xmlns="urn:ietf:params:xml:ns:xmpp-stanzas"/>'+
'<text xmlns="urn:ietf:params:xml:ns:xmpp-stanzas">'+
'Forwarded messages not part of an encapsulating protocol are not supported</text>'+
'</error>'+
'</message>');
models = await _converse.api.chats.get();
expect(models.length).toBe(1);
done();
}));
it("can be received out of order, and will still be displayed in the right order",
mock.initConverse(
['rosterGroupsFetched'], {},
async function (done, _converse) {
await mock.waitForRoster(_converse, 'current');
await mock.openControlBox(_converse);
const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@montague.lit';
await u.waitUntil(() => _converse.rosterview.el.querySelectorAll('.roster-group').length)
_converse.filter_by_resource = true;
let msg = $msg({
'xmlns': 'jabber:client',
'id': _converse.connection.getUniqueId(),
'to': _converse.bare_jid,
'from': sender_jid,
'type': 'chat'})
.c('body').t("message").up()
.c('delay', {'xmlns': 'urn:xmpp:delay', 'stamp':'2018-01-02T13:08:25Z'})
.tree();
await _converse.handleMessageStanza(msg);
const view = _converse.api.chatviews.get(sender_jid);
msg = $msg({
'xmlns': 'jabber:client',
'id': _converse.connection.getUniqueId(),
'to': _converse.bare_jid,
'from': sender_jid,
'type': 'chat'})
.c('body').t("Older message").up()
.c('delay', {'xmlns': 'urn:xmpp:delay', 'stamp':'2017-12-31T22:08:25Z'})
.tree();
_converse.handleMessageStanza(msg);
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
await new Promise(resolve => view.model.messages.once('rendered', resolve));
Use Karma as test runner
2020-04-22 13:11:48 +02:00
msg = $msg({
'xmlns': 'jabber:client',
'id': _converse.connection.getUniqueId(),
'to': _converse.bare_jid,
'from': sender_jid,
'type': 'chat'})
.c('body').t("Inbetween message").up()
.c('delay', {'xmlns': 'urn:xmpp:delay', 'stamp':'2018-01-01T13:18:23Z'})
.tree();
_converse.handleMessageStanza(msg);
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
await new Promise(resolve => view.model.messages.once('rendered', resolve));
Use Karma as test runner
2020-04-22 13:11:48 +02:00
msg = $msg({
'xmlns': 'jabber:client',
'id': _converse.connection.getUniqueId(),
'to': _converse.bare_jid,
'from': sender_jid,
'type': 'chat'})
.c('body').t("another inbetween message").up()
.c('delay', {'xmlns': 'urn:xmpp:delay', 'stamp':'2018-01-01T13:18:23Z'})
.tree();
_converse.handleMessageStanza(msg);
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
await new Promise(resolve => view.model.messages.once('rendered', resolve));
Use Karma as test runner
2020-04-22 13:11:48 +02:00
msg = $msg({
'xmlns': 'jabber:client',
'id': _converse.connection.getUniqueId(),
'to': _converse.bare_jid,
'from': sender_jid,
'type': 'chat'})
.c('body').t("An earlier message on the next day").up()
.c('delay', {'xmlns': 'urn:xmpp:delay', 'stamp':'2018-01-02T12:18:23Z'})
.tree();
_converse.handleMessageStanza(msg);
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
await new Promise(resolve => view.model.messages.once('rendered', resolve));
Use Karma as test runner
2020-04-22 13:11:48 +02:00
msg = $msg({
'xmlns': 'jabber:client',
'id': _converse.connection.getUniqueId(),
'to': _converse.bare_jid,
'from': sender_jid,
'type': 'chat'})
.c('body').t("newer message from the next day").up()
.c('delay', {'xmlns': 'urn:xmpp:delay', 'stamp':'2018-01-02T22:28:23Z'})
.tree();
_converse.handleMessageStanza(msg);
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
await new Promise(resolve => view.model.messages.once('rendered', resolve));
Use Karma as test runner
2020-04-22 13:11:48 +02:00
// Insert <composing> message, to also check that
// text messages are inserted correctly with
// temporary chat events in the chat contents.
msg = $msg({
'id': _converse.connection.getUniqueId(),
'to': _converse.bare_jid,
'xmlns': 'jabber:client',
'from': sender_jid,
'type': 'chat'})
.c('composing', {'xmlns': Strophe.NS.CHATSTATES}).up()
.tree();
_converse.handleMessageStanza(msg);
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
const csntext = await u.waitUntil(() => view.el.querySelector('.chat-content__notifications').textContent);
expect(csntext.trim()).toEqual('Mercutio is typing');
Use Karma as test runner
2020-04-22 13:11:48 +02:00
msg = $msg({
'id': _converse.connection.getUniqueId(),
'to': _converse.bare_jid,
'xmlns': 'jabber:client',
'from': sender_jid,
'type': 'chat'})
.c('composing', {'xmlns': Strophe.NS.CHATSTATES}).up()
.c('body').t("latest message")
.tree();
await _converse.handleMessageStanza(msg);
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
await new Promise(resolve => view.model.messages.once('rendered', resolve));
Use Karma as test runner
2020-04-22 13:11:48 +02:00
view.clearSpinner(); //cleanup
expect(view.content.querySelectorAll('.date-separator').length).toEqual(4);
let day = sizzle('.date-separator:first', view.content).pop();
expect(day.getAttribute('data-isodate')).toEqual(dayjs('2017-12-31T00:00:00').toISOString());
let time = sizzle('time:first', view.content).pop();
expect(time.textContent).toEqual('Sunday Dec 31st 2017')
day = sizzle('.date-separator:first', view.content).pop();
expect(day.nextElementSibling.querySelector('.chat-msg__text').textContent).toBe('Older message');
let el = sizzle('.chat-msg:first', view.content).pop().querySelector('.chat-msg__text')
expect(u.hasClass('chat-msg--followup', el)).toBe(false);
expect(el.textContent).toEqual('Older message');
time = sizzle('time.separator-text:eq(1)', view.content).pop();
expect(time.textContent).toEqual("Monday Jan 1st 2018");
day = sizzle('.date-separator:eq(1)', view.content).pop();
expect(day.getAttribute('data-isodate')).toEqual(dayjs('2018-01-01T00:00:00').toISOString());
expect(day.nextElementSibling.querySelector('.chat-msg__text').textContent).toBe('Inbetween message');
el = sizzle('.chat-msg:eq(1)', view.content).pop();
expect(el.querySelector('.chat-msg__text').textContent).toEqual('Inbetween message');
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
expect(el.parentElement.nextElementSibling.querySelector('.chat-msg__text').textContent).toEqual('another inbetween message');
Use Karma as test runner
2020-04-22 13:11:48 +02:00
el = sizzle('.chat-msg:eq(2)', view.content).pop();
expect(el.querySelector('.chat-msg__text').textContent)
.toEqual('another inbetween message');
expect(u.hasClass('chat-msg--followup', el)).toBe(true);
time = sizzle('time.separator-text:nth(2)', view.content).pop();
expect(time.textContent).toEqual("Tuesday Jan 2nd 2018");
day = sizzle('.date-separator:nth(2)', view.content).pop();
expect(day.getAttribute('data-isodate')).toEqual(dayjs('2018-01-02T00:00:00').toISOString());
expect(day.nextElementSibling.querySelector('.chat-msg__text').textContent).toBe('An earlier message on the next day');
el = sizzle('.chat-msg:eq(3)', view.content).pop();
expect(el.querySelector('.chat-msg__text').textContent).toEqual('An earlier message on the next day');
expect(u.hasClass('chat-msg--followup', el)).toBe(false);
el = sizzle('.chat-msg:eq(4)', view.content).pop();
expect(el.querySelector('.chat-msg__text').textContent).toEqual('message');
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
expect(el.parentElement.nextElementSibling.querySelector('.chat-msg__text').textContent).toEqual('newer message from the next day');
Use Karma as test runner
2020-04-22 13:11:48 +02:00
expect(u.hasClass('chat-msg--followup', el)).toBe(false);
day = sizzle('.date-separator:last', view.content).pop();
expect(day.getAttribute('data-isodate')).toEqual(dayjs().startOf('day').toISOString());
expect(day.nextElementSibling.querySelector('.chat-msg__text').textContent).toBe('latest message');
expect(u.hasClass('chat-msg--followup', el)).toBe(false);
done();
}));
it("is ignored if it's a malformed headline message",
Make `converse.initialize` an `async` function - Combine all test init functions into `initConverse` - Use `async` functions in more tests - Replace `var` with `let` and `const` in more tests - New utils method `toStanza` which converts a string to a Node
2019-02-12 14:21:45 +01:00
mock.initConverse(
Use Karma as test runner
2020-04-22 13:11:48 +02:00
['rosterGroupsFetched'], {},
Use async/await
2018-11-20 18:10:55 +01:00
async function (done, _converse) {
Move message-related tests into their own file
2018-04-29 15:40:24 +02:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
await mock.waitForRoster(_converse, 'current');
await mock.openControlBox(_converse);
// Ideally we wouldn't have to filter out headline
// messages, but Prosody gives them the wrong 'type' :(
Refactor so that message attributes are parsed early It's better to parse an incoming message stanza early, than to have all kinds of methods throughout the codebase that does querySelector etc. Firstly, it allows us to catch and report errors and malicious stanzas early on. It also simplifies programming because you don't need to try and remember how to properly parse a stanza, all the work is done upfront for you.
2020-04-24 17:33:32 +02:00
spyOn(converse.env.log, 'info');
Use Karma as test runner
2020-04-22 13:11:48 +02:00
sinon.spy(_converse.api.chatboxes, 'get');
const msg = $msg({
from: 'montague.lit',
to: _converse.bare_jid,
type: 'chat',
id: u.getUniqueId()
}).c('body').t("This headline message will not be shown").tree();
await _converse.handleMessageStanza(msg);
Refactor so that message attributes are parsed early It's better to parse an incoming message stanza early, than to have all kinds of methods throughout the codebase that does querySelector etc. Firstly, it allows us to catch and report errors and malicious stanzas early on. It also simplifies programming because you don't need to try and remember how to properly parse a stanza, all the work is done upfront for you.
2020-04-24 17:33:32 +02:00
expect(converse.env.log.info).toHaveBeenCalledWith(
"handleMessageStanza: Ignoring incoming server message from JID: montague.lit"
);
Use Karma as test runner
2020-04-22 13:11:48 +02:00
expect(_converse.api.chatboxes.get.called).toBeFalsy();
// Remove sinon spies
_converse.api.chatboxes.get.restore();
done();
}));
it("can be a carbon message, as defined in XEP-0280",
mock.initConverse(
['rosterGroupsFetched'], {},
async function (done, _converse) {
const include_nick = false;
await mock.waitForRoster(_converse, 'current', 2, include_nick);
await mock.openControlBox(_converse);
// Send a message from a different resource
const msgtext = 'This is a carbon message';
const sender_jid = mock.cur_names[1].replace(/ /g,'.').toLowerCase() + '@montague.lit';
const msg = $msg({
'from': _converse.bare_jid,
'id': u.getUniqueId(),
'to': _converse.connection.jid,
'type': 'chat',
'xmlns': 'jabber:client'
}).c('received', {'xmlns': 'urn:xmpp:carbons:2'})
.c('forwarded', {'xmlns': 'urn:xmpp:forward:0'})
.c('message', {
'xmlns': 'jabber:client',
'from': sender_jid,
'to': _converse.bare_jid+'/another-resource',
'type': 'chat'
}).c('body').t(msgtext).tree();
await _converse.handleMessageStanza(msg);
const chatbox = _converse.chatboxes.get(sender_jid);
const view = _converse.chatboxviews.get(sender_jid);
expect(chatbox).toBeDefined();
expect(view).toBeDefined();
// Check that the message was received and check the message parameters
await u.waitUntil(() => chatbox.messages.length);
const msg_obj = chatbox.messages.models[0];
expect(msg_obj.get('message')).toEqual(msgtext);
expect(msg_obj.get('fullname')).toBeUndefined();
expect(msg_obj.get('nickname')).toBe(null);
expect(msg_obj.get('sender')).toEqual('them');
expect(msg_obj.get('is_delayed')).toEqual(false);
// Now check that the message appears inside the chatbox in the DOM
await u.waitUntil(() => view.content.querySelector('.chat-msg .chat-msg__text'));
expect(view.content.querySelector('.chat-msg .chat-msg__text').textContent).toEqual(msgtext);
expect(view.content.querySelector('.chat-msg__time').textContent.match(/^[0-9][0-9]:[0-9][0-9]/)).toBeTruthy();
await u.waitUntil(() => chatbox.vcard.get('fullname') === 'Juliet Capulet')
expect(view.content.querySelector('span.chat-msg__author').textContent.trim()).toBe('Juliet Capulet');
done();
}));
it("can be a carbon message that this user sent from a different client, as defined in XEP-0280",
mock.initConverse(
['rosterGroupsFetched'], {},
async function (done, _converse) {
await mock.waitUntilDiscoConfirmed(_converse, 'montague.lit', [], ['vcard-temp']);
await mock.waitForRoster(_converse, 'current');
await mock.openControlBox(_converse);
// Send a message from a different resource
const msgtext = 'This is a sent carbon message';
const recipient_jid = mock.cur_names[5].replace(/ /g,'.').toLowerCase() + '@montague.lit';
const msg = $msg({
'from': _converse.bare_jid,
'id': u.getUniqueId(),
'to': _converse.connection.jid,
'type': 'chat',
'xmlns': 'jabber:client'
}).c('sent', {'xmlns': 'urn:xmpp:carbons:2'})
.c('forwarded', {'xmlns': 'urn:xmpp:forward:0'})
.c('message', {
'xmlns': 'jabber:client',
'from': _converse.bare_jid+'/another-resource',
'to': recipient_jid,
'type': 'chat'
}).c('body').t(msgtext).tree();
await _converse.handleMessageStanza(msg);
// Check that the chatbox and its view now exist
const chatbox = await _converse.api.chats.get(recipient_jid);
const view = _converse.api.chatviews.get(recipient_jid);
expect(chatbox).toBeDefined();
expect(view).toBeDefined();
// Check that the message was received and check the message parameters
expect(chatbox.messages.length).toEqual(1);
const msg_obj = chatbox.messages.models[0];
expect(msg_obj.get('message')).toEqual(msgtext);
expect(msg_obj.get('fullname')).toEqual(_converse.xmppstatus.get('fullname'));
expect(msg_obj.get('sender')).toEqual('me');
expect(msg_obj.get('is_delayed')).toEqual(false);
// Now check that the message appears inside the chatbox in the DOM
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
const msg_el = await u.waitUntil(() => view.el.querySelector('.chat-content .chat-msg .chat-msg__text'));
expect(msg_el.textContent).toEqual(msgtext);
Use Karma as test runner
2020-04-22 13:11:48 +02:00
done();
}));
it("will be discarded if it's a malicious message meant to look like a carbon copy",
mock.initConverse(
['rosterGroupsFetched'], {},
async function (done, _converse) {
await mock.waitForRoster(_converse, 'current');
await mock.openControlBox(_converse);
/* <message from="mallory@evil.example" to="b@xmpp.example">
* <received xmlns='urn:xmpp:carbons:2'>
* <forwarded xmlns='urn:xmpp:forward:0'>
* <message from="alice@xmpp.example" to="bob@xmpp.example/client1">
* <body>Please come to Creepy Valley tonight, alone!</body>
* </message>
* </forwarded>
* </received>
* </message>
*/
const msgtext = 'Please come to Creepy Valley tonight, alone!';
const sender_jid = mock.cur_names[1].replace(/ /g,'.').toLowerCase() + '@montague.lit';
const impersonated_jid = mock.cur_names[2].replace(/ /g,'.').toLowerCase() + '@montague.lit';
const msg = $msg({
'from': sender_jid,
'id': u.getUniqueId(),
'to': _converse.connection.jid,
'type': 'chat',
'xmlns': 'jabber:client'
}).c('received', {'xmlns': 'urn:xmpp:carbons:2'})
.c('forwarded', {'xmlns': 'urn:xmpp:forward:0'})
.c('message', {
'xmlns': 'jabber:client',
'from': impersonated_jid,
'to': _converse.connection.jid,
'type': 'chat'
}).c('body').t(msgtext).tree();
await _converse.handleMessageStanza(msg);
// Check that chatbox for impersonated user is not created.
let chatbox = await _converse.api.chats.get(impersonated_jid);
expect(chatbox).toBe(null);
// Check that the chatbox for the malicous user is not created
chatbox = await _converse.api.chats.get(sender_jid);
expect(chatbox).toBe(null);
done();
}));
it("will indicate when it has a time difference of more than a day between it and its predecessor",
mock.initConverse(
['rosterGroupsFetched', 'chatBoxesFetched'], {},
async function (done, _converse) {
const include_nick = false;
await mock.waitForRoster(_converse, 'current', 2, include_nick);
await mock.openControlBox(_converse);
spyOn(_converse.api, "trigger").and.callThrough();
const contact_name = mock.cur_names[1];
const contact_jid = contact_name.replace(/ /g,'.').toLowerCase() + '@montague.lit';
await u.waitUntil(() => _converse.rosterview.el.querySelectorAll('.roster-group').length);
await mock.openChatBoxFor(_converse, contact_jid);
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
const one_day_ago = dayjs().subtract(1, 'day');
const chatbox = _converse.chatboxes.get(contact_jid);
const view = _converse.chatboxviews.get(contact_jid);
let message = 'This is a day old message';
let msg = $msg({
from: contact_jid,
to: _converse.connection.jid,
type: 'chat',
id: one_day_ago.toDate().getTime()
}).c('body').t(message).up()
.c('delay', { xmlns:'urn:xmpp:delay', from: 'montague.lit', stamp: one_day_ago.toISOString() })
.c('active', {'xmlns': 'http://jabber.org/protocol/chatstates'}).tree();
await _converse.handleMessageStanza(msg);
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
await new Promise(resolve => view.model.messages.once('rendered', resolve));
Use Karma as test runner
2020-04-22 13:11:48 +02:00
expect(_converse.api.trigger).toHaveBeenCalledWith('message', jasmine.any(Object));
expect(chatbox.messages.length).toEqual(1);
let msg_obj = chatbox.messages.models[0];
expect(msg_obj.get('message')).toEqual(message);
expect(msg_obj.get('fullname')).toBeUndefined();
expect(msg_obj.get('nickname')).toBe(null);
expect(msg_obj.get('sender')).toEqual('them');
expect(msg_obj.get('is_delayed')).toEqual(true);
await u.waitUntil(() => chatbox.vcard.get('fullname') === 'Juliet Capulet')
expect(view.msgs_container.querySelector('.chat-msg .chat-msg__text').textContent).toEqual(message);
expect(view.msgs_container.querySelector('.chat-msg__time').textContent.match(/^[0-9][0-9]:[0-9][0-9]/)).toBeTruthy();
expect(view.msgs_container.querySelector('span.chat-msg__author').textContent.trim()).toBe('Juliet Capulet');
expect(view.msgs_container.querySelectorAll('.date-separator').length).toEqual(1);
let day = view.msgs_container.querySelector('.date-separator');
expect(day.getAttribute('class')).toEqual('message date-separator');
expect(day.getAttribute('data-isodate')).toEqual(dayjs(one_day_ago.startOf('day')).toISOString());
let time = view.msgs_container.querySelector('time.separator-text');
expect(time.textContent).toEqual(dayjs(one_day_ago.startOf('day')).format("dddd MMM Do YYYY"));
message = 'This is a current message';
msg = $msg({
from: contact_jid,
to: _converse.connection.jid,
type: 'chat',
id: new Date().getTime()
}).c('body').t(message).up()
.c('active', {'xmlns': 'http://jabber.org/protocol/chatstates'}).tree();
await _converse.handleMessageStanza(msg);
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
await new Promise(resolve => view.model.messages.once('rendered', resolve));
Use Karma as test runner
2020-04-22 13:11:48 +02:00
expect(_converse.api.trigger).toHaveBeenCalledWith('message', jasmine.any(Object));
// Check that there is a <time> element, with the required props.
expect(view.msgs_container.querySelectorAll('time.separator-text').length).toEqual(2); // There are now two time elements
const message_date = new Date();
day = sizzle('.date-separator:last', view.msgs_container);
expect(day.length).toEqual(1);
expect(day[0].getAttribute('class')).toEqual('message date-separator');
expect(day[0].getAttribute('data-isodate')).toEqual(dayjs(message_date).startOf('day').toISOString());
time = sizzle('time.separator-text:last', view.msgs_container).pop();
expect(time.textContent).toEqual(dayjs(message_date).startOf('day').format("dddd MMM Do YYYY"));
// Normal checks for the 2nd message
expect(chatbox.messages.length).toEqual(2);
msg_obj = chatbox.messages.models[1];
expect(msg_obj.get('message')).toEqual(message);
expect(msg_obj.get('fullname')).toBeUndefined();
expect(msg_obj.get('sender')).toEqual('them');
expect(msg_obj.get('is_delayed')).toEqual(false);
const msg_txt = sizzle('.chat-msg:last .chat-msg__text', view.msgs_container).pop().textContent;
expect(msg_txt).toEqual(message);
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
expect(view.msgs_container.querySelector('converse-chat-message:last-child .chat-msg__text').textContent).toEqual(message);
expect(view.msgs_container.querySelector('converse-chat-message:last-child .chat-msg__time').textContent.match(/^[0-9][0-9]:[0-9][0-9]/)).toBeTruthy();
expect(view.msgs_container.querySelector('converse-chat-message:last-child .chat-msg__author').textContent.trim()).toBe('Juliet Capulet');
Use Karma as test runner
2020-04-22 13:11:48 +02:00
done();
}));
it("is sanitized to prevent Javascript injection attacks",
mock.initConverse(
['rosterGroupsFetched', 'chatBoxesFetched'], {},
async function (done, _converse) {
await mock.waitForRoster(_converse, 'current');
await mock.openControlBox(_converse);
const contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@montague.lit';
await mock.openChatBoxFor(_converse, contact_jid)
const view = _converse.api.chatviews.get(contact_jid);
const message = '<p>This message contains <em>some</em> <b>markup</b></p>';
spyOn(view.model, 'sendMessage').and.callThrough();
await mock.sendMessage(view, message);
expect(view.model.sendMessage).toHaveBeenCalled();
const msg = sizzle('.chat-content .chat-msg:last .chat-msg__text', view.el).pop();
expect(msg.textContent).toEqual(message);
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
expect(msg.innerHTML.replace(/<!---->/g, '')).toEqual('&lt;p&gt;This message contains &lt;em&gt;some&lt;/em&gt; &lt;b&gt;markup&lt;/b&gt;&lt;/p&gt;');
Use Karma as test runner
2020-04-22 13:11:48 +02:00
done();
}));
it("can contain hyperlinks, which will be clickable",
mock.initConverse(
['rosterGroupsFetched', 'chatBoxesFetched'], {},
async function (done, _converse) {
await mock.waitForRoster(_converse, 'current');
await mock.openControlBox(_converse);
const contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@montague.lit';
await mock.openChatBoxFor(_converse, contact_jid)
const view = _converse.api.chatviews.get(contact_jid);
const message = 'This message contains a hyperlink: www.opkode.com';
spyOn(view.model, 'sendMessage').and.callThrough();
mock.sendMessage(view, message);
expect(view.model.sendMessage).toHaveBeenCalled();
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
await new Promise(resolve => view.model.messages.once('rendered', resolve));
Use Karma as test runner
2020-04-22 13:11:48 +02:00
const msg = sizzle('.chat-content .chat-msg:last .chat-msg__text', view.el).pop();
expect(msg.textContent).toEqual(message);
Refactor the body directive Changes how rich message markup is generated and kept track of. We now have a MessageText class which subclasses String and which keeps track of the rich markup associated with the message.
2020-07-09 06:27:56 +02:00
await u.waitUntil(() => msg.innerHTML.replace(/<!---->/g, '') ===
'This message contains a hyperlink: <a target="_blank" rel="noopener" href="http://www.opkode.com">www.opkode.com</a>');
Use Karma as test runner
2020-04-22 13:11:48 +02:00
done();
}));
Removes query params from urls as set in config
2020-08-27 23:26:51 +02:00
it("will remove url query parameters from hyperlinks as set",
mock.initConverse(
Test string value for `filter_url_query_params`
2020-09-01 07:26:20 +02:00
['rosterGroupsFetched', 'chatBoxesFetched'],
{'filter_url_query_params': ['utm_medium', 'utm_content', 's']},
Removes query params from urls as set in config
2020-08-27 23:26:51 +02:00
async function (done, _converse) {
await mock.waitForRoster(_converse, 'current');
await mock.openControlBox(_converse);
const contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@montague.lit';
await mock.openChatBoxFor(_converse, contact_jid);
const view = _converse.api.chatviews.get(contact_jid);
Test string value for `filter_url_query_params`
2020-09-01 07:26:20 +02:00
let message = 'This message contains a hyperlink with forbidden query params: https://www.opkode.com/?id=0&utm_content=1&utm_medium=2&s=1';
Removes query params from urls as set in config
2020-08-27 23:26:51 +02:00
mock.sendMessage(view, message);
await new Promise(resolve => view.model.messages.once('rendered', resolve));
Test string value for `filter_url_query_params`
2020-09-01 07:26:20 +02:00
let msg = sizzle('.chat-content .chat-msg:last .chat-msg__text', view.el).pop();
Removes query params from urls as set in config
2020-08-27 23:26:51 +02:00
expect(msg.textContent).toEqual(message);
await u.waitUntil(() => msg.innerHTML.replace(/<!---->/g, '') ===
'This message contains a hyperlink with forbidden query params: <a target="_blank" rel="noopener" href="https://www.opkode.com/?id=0">https://www.opkode.com/?id=0</a>');
Test string value for `filter_url_query_params`
2020-09-01 07:26:20 +02:00
// Test assigning a string to filter_url_query_params
_converse.api.settings.set('filter_url_query_params', 'utm_medium');
message = 'Another message with a hyperlink with forbidden query params: https://www.opkode.com/?id=0&utm_content=1&utm_medium=2&s=1';
mock.sendMessage(view, message);
await new Promise(resolve => view.model.messages.once('rendered', resolve));
msg = sizzle('.chat-content .chat-msg:last .chat-msg__text', view.el).pop();
expect(msg.textContent).toEqual(message);
await u.waitUntil(() => msg.innerHTML.replace(/<!---->/g, '') ===
'Another message with a hyperlink with forbidden query params: '+
'<a target="_blank" rel="noopener" href="https://www.opkode.com/?id=0&amp;utm_content=1&amp;s=1">https://www.opkode.com/?id=0&amp;utm_content=1&amp;s=1</a>');
Removes query params from urls as set in config
2020-08-27 23:26:51 +02:00
done();
}));
Use Karma as test runner
2020-04-22 13:11:48 +02:00
it("will render newlines",
mock.initConverse(
['rosterGroupsFetched', 'chatBoxesFetched'], {},
async function (done, _converse) {
await mock.waitForRoster(_converse, 'current');
const contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@montague.lit';
const view = await mock.openChatBoxFor(_converse, contact_jid);
let stanza = u.toStanza(`
<message from="${contact_jid}"
type="chat"
to="romeo@montague.lit/orchard">
<body>Hey\nHave you heard the news?</body>
</message>`);
_converse.connection._dataRecv(mock.createRequest(stanza));
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
await new Promise(resolve => view.model.messages.once('rendered', resolve));
expect(view.content.querySelector('.chat-msg__text').innerHTML.replace(/<!---->/g, '')).toBe('Hey\nHave you heard the news?');
Use Karma as test runner
2020-04-22 13:11:48 +02:00
stanza = u.toStanza(`
<message from="${contact_jid}"
type="chat"
to="romeo@montague.lit/orchard">
<body>Hey\n\n\nHave you heard the news?</body>
</message>`);
_converse.connection._dataRecv(mock.createRequest(stanza));
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
await new Promise(resolve => view.model.messages.once('rendered', resolve));
Refactor the body directive Changes how rich message markup is generated and kept track of. We now have a MessageText class which subclasses String and which keeps track of the rich markup associated with the message.
2020-07-09 06:27:56 +02:00
await u.waitUntil(() => view.content.querySelector('converse-chat-message:last-child .chat-msg__text').innerHTML.replace(/<!---->/g, '') === 'Hey\n\nHave you heard the news?');
Use Karma as test runner
2020-04-22 13:11:48 +02:00
stanza = u.toStanza(`
<message from="${contact_jid}"
type="chat"
to="romeo@montague.lit/orchard">
<body>Hey\nHave you heard\nthe news?</body>
</message>`);
_converse.connection._dataRecv(mock.createRequest(stanza));
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
await new Promise(resolve => view.model.messages.once('rendered', resolve));
expect(view.content.querySelector('converse-chat-message:last-child .chat-msg__text').innerHTML.replace(/<!---->/g, '')).toBe('Hey\nHave you heard\nthe news?');
Use Karma as test runner
2020-04-22 13:11:48 +02:00
done();
}));
it("will render images from their URLs",
mock.initConverse(
['rosterGroupsFetched', 'chatBoxesFetched'], {},
async function (done, _converse) {
await mock.waitForRoster(_converse, 'current');
const base_url = 'https://conversejs.org';
let message = base_url+"/logo/conversejs-filled.svg";
const contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@montague.lit';
await mock.openChatBoxFor(_converse, contact_jid);
const view = _converse.api.chatviews.get(contact_jid);
spyOn(view.model, 'sendMessage').and.callThrough();
mock.sendMessage(view, message);
await u.waitUntil(() => view.el.querySelectorAll('.chat-content .chat-image').length, 1000)
expect(view.model.sendMessage).toHaveBeenCalled();
let msg = sizzle('.chat-content .chat-msg:last .chat-msg__text').pop();
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
expect(msg.innerHTML.replace(/<!---->/g, '').trim()).toEqual(
`<a class="chat-image__link" target="_blank" rel="noopener" href="${base_url}/logo/conversejs-filled.svg">`+
Add a `renderImage` directive which handles errors
2020-07-09 08:57:25 +02:00
`<img class="chat-image img-thumbnail" src="https://conversejs.org/logo/conversejs-filled.svg">`+
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
`</a>`);
Use Karma as test runner
2020-04-22 13:11:48 +02:00
message += "?param1=val1&param2=val2";
mock.sendMessage(view, message);
await u.waitUntil(() => view.el.querySelectorAll('.chat-content .chat-image').length === 2, 1000);
expect(view.model.sendMessage).toHaveBeenCalled();
msg = sizzle('.chat-content .chat-msg:last .chat-msg__text').pop();
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
expect(msg.innerHTML.replace(/<!---->/g, '').trim()).toEqual(
`<a class="chat-image__link" target="_blank" rel="noopener" href="${base_url}/logo/conversejs-filled.svg?param1=val1&amp;param2=val2">`+
`<img class="chat-image img-thumbnail" src="${message.replace(/&/g, '&amp;')}">`+
`</a>`);
Use Karma as test runner
2020-04-22 13:11:48 +02:00
// Test now with two images in one message
message += ' hello world '+base_url+"/logo/conversejs-filled.svg";
mock.sendMessage(view, message);
await u.waitUntil(() => view.el.querySelectorAll('.chat-content .chat-image').length === 4, 1000);
expect(view.model.sendMessage).toHaveBeenCalled();
msg = sizzle('.chat-content .chat-msg:last .chat-msg__text').pop();
expect(msg.textContent.trim()).toEqual('hello world');
Append `.png` to failed image URLs without extensions Otherwise Imgur URLs don't render
2020-08-31 20:29:51 +02:00
expect(msg.querySelectorAll('img.chat-image').length).toEqual(2);
Added tests and documentation
2020-08-28 23:12:21 +02:00
// Configured image URLs are rendered
_converse.api.settings.set('image_urls_regex', /^https?:\/\/(?:www.)?(?:imgur\.com\/\w{7})\/?$/i);
Append `.png` to failed image URLs without extensions Otherwise Imgur URLs don't render
2020-08-31 20:29:51 +02:00
message = 'https://imgur.com/oxymPax';
Added tests and documentation
2020-08-28 23:12:21 +02:00
mock.sendMessage(view, message);
await u.waitUntil(() => view.el.querySelectorAll('.chat-content .chat-image').length === 5, 1000);
adds option to whitelist image domains
2020-08-28 01:05:12 +02:00
expect(view.content.querySelectorAll('.chat-content .chat-image').length).toBe(5);
Append `.png` to failed image URLs without extensions Otherwise Imgur URLs don't render
2020-08-31 20:29:51 +02:00
// Check that the Imgur URL gets a .png attached to make it render
await u.waitUntil(() => Array.from(view.el.querySelectorAll('.chat-content .chat-image')).pop().src.endsWith('png'), 1000);
adds option to whitelist image domains
2020-08-28 01:05:12 +02:00
done();
}));
it("will render images from approved URLs only",
mock.initConverse(
Properly test for `show_images_inline`
2020-08-31 20:58:39 +02:00
['rosterGroupsFetched', 'chatBoxesFetched'], {'show_images_inline': ['conversejs.org']},
adds option to whitelist image domains
2020-08-28 01:05:12 +02:00
async function (done, _converse) {
await mock.waitForRoster(_converse, 'current');
const base_url = 'https://conversejs.org';
Properly test for `show_images_inline`
2020-08-31 20:58:39 +02:00
let message = 'https://imgur.com/oxymPax.png';
adds option to whitelist image domains
2020-08-28 01:05:12 +02:00
const contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@montague.lit';
await mock.openChatBoxFor(_converse, contact_jid);
const view = _converse.api.chatviews.get(contact_jid);
spyOn(view.model, 'sendMessage').and.callThrough();
mock.sendMessage(view, message);
Properly test for `show_images_inline`
2020-08-31 20:58:39 +02:00
await u.waitUntil(() => view.el.querySelectorAll('.chat-content .chat-msg').length === 1);
adds option to whitelist image domains
2020-08-28 01:05:12 +02:00
message = base_url+"/logo/conversejs-filled.svg";
mock.sendMessage(view, message);
await u.waitUntil(() => view.el.querySelectorAll('.chat-content .chat-msg').length === 2, 1000);
await u.waitUntil(() => view.el.querySelectorAll('.chat-content .chat-image').length === 1, 1000)
expect(view.content.querySelectorAll('.chat-content .chat-image').length).toBe(1);
Use Karma as test runner
2020-04-22 13:11:48 +02:00
done();
}));
Add a `renderImage` directive which handles errors
2020-07-09 08:57:25 +02:00
it("will fall back to rendering images as URLs",
mock.initConverse(
['rosterGroupsFetched', 'chatBoxesFetched'], {},
async function (done, _converse) {
await mock.waitForRoster(_converse, 'current');
const base_url = 'https://conversejs.org';
const message = base_url+"/logo/non-existing.svg";
const contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@montague.lit';
await mock.openChatBoxFor(_converse, contact_jid);
const view = _converse.api.chatviews.get(contact_jid);
spyOn(view.model, 'sendMessage').and.callThrough();
mock.sendMessage(view, message);
await u.waitUntil(() => view.el.querySelectorAll('.chat-content .chat-image').length, 1000)
expect(view.model.sendMessage).toHaveBeenCalled();
const msg = sizzle('.chat-content .chat-msg:last .chat-msg__text').pop();
await u.waitUntil(() => msg.innerHTML.replace(/<!---->/g, '').trim() ==
chatview: Scroll down on image load
2020-07-14 14:06:52 +02:00
`<a target="_blank" rel="noopener" href="https://conversejs.org/logo/non-existing.svg">https://conversejs.org/logo/non-existing.svg</a>`, 1000);
Add a `renderImage` directive which handles errors
2020-07-09 08:57:25 +02:00
done();
}));
Use Karma as test runner
2020-04-22 13:11:48 +02:00
it("will render the message time as configured",
mock.initConverse(
['rosterGroupsFetched', 'chatBoxesFetched'], {},
async function (done, _converse) {
Use async/await
2018-11-20 18:10:55 +01:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
await mock.waitForRoster(_converse, 'current');
_converse.time_format = 'hh:mm';
const contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@montague.lit';
await mock.openChatBoxFor(_converse, contact_jid)
const view = _converse.api.chatviews.get(contact_jid);
const message = 'This message is sent from this chatbox';
await mock.sendMessage(view, message);
const chatbox = await _converse.api.chats.get(contact_jid);
expect(chatbox.messages.models.length, 1);
const msg_object = chatbox.messages.models[0];
const msg_author = view.el.querySelector('.chat-content .chat-msg:last-child .chat-msg__author');
expect(msg_author.textContent.trim()).toBe('Romeo Montague');
const msg_time = view.el.querySelector('.chat-content .chat-msg:last-child .chat-msg__time');
const time = dayjs(msg_object.get('time')).format(_converse.time_format);
expect(msg_time.textContent).toBe(time);
done();
}));
it("will be correctly identified and rendered as a followup message",
mock.initConverse(
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
['rosterGroupsFetched'], {'debounced_content_rendering': false},
Use Karma as test runner
2020-04-22 13:11:48 +02:00
async function (done, _converse) {
await mock.waitForRoster(_converse, 'current');
await mock.openControlBox(_converse);
const base_time = new Date();
const ONE_MINUTE_LATER = 60000;
await u.waitUntil(() => _converse.rosterview.el.querySelectorAll('.roster-group').length, 300);
const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@montague.lit';
_converse.filter_by_resource = true;
jasmine.clock().install();
jasmine.clock().mockDate(base_time);
_converse.handleMessageStanza($msg({
'from': sender_jid,
'to': _converse.connection.jid,
'type': 'chat',
'id': u.getUniqueId()
}).c('body').t('A message').up()
.c('active', {'xmlns': 'http://jabber.org/protocol/chatstates'}).tree());
await new Promise(resolve => _converse.on('chatBoxViewInitialized', resolve));
const view = _converse.api.chatviews.get(sender_jid);
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
await new Promise(resolve => view.model.messages.once('rendered', resolve));
Use Karma as test runner
2020-04-22 13:11:48 +02:00
jasmine.clock().tick(3*ONE_MINUTE_LATER);
_converse.handleMessageStanza($msg({
'from': sender_jid,
'to': _converse.connection.jid,
'type': 'chat',
'id': u.getUniqueId()
}).c('body').t("Another message 3 minutes later").up()
.c('active', {'xmlns': 'http://jabber.org/protocol/chatstates'}).tree());
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
await new Promise(resolve => view.model.messages.once('rendered', resolve));
Use Karma as test runner
2020-04-22 13:11:48 +02:00
jasmine.clock().tick(11*ONE_MINUTE_LATER);
_converse.handleMessageStanza($msg({
'from': sender_jid,
'to': _converse.connection.jid,
'type': 'chat',
'id': u.getUniqueId()
}).c('body').t("Another message 14 minutes since we started").up()
.c('active', {'xmlns': 'http://jabber.org/protocol/chatstates'}).tree());
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
await new Promise(resolve => view.model.messages.once('rendered', resolve));
Use Karma as test runner
2020-04-22 13:11:48 +02:00
jasmine.clock().tick(1*ONE_MINUTE_LATER);
_converse.handleMessageStanza($msg({
'from': sender_jid,
'to': _converse.connection.jid,
'type': 'chat',
'id': _converse.connection.getUniqueId()
}).c('body').t("Another message 1 minute and 1 second since the previous one").up()
.c('active', {'xmlns': 'http://jabber.org/protocol/chatstates'}).tree());
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
await new Promise(resolve => view.model.messages.once('rendered', resolve));
Use Karma as test runner
2020-04-22 13:11:48 +02:00
jasmine.clock().tick(1*ONE_MINUTE_LATER);
await mock.sendMessage(view, "Another message within 10 minutes, but from a different person");
expect(view.content.querySelectorAll('.message').length).toBe(6);
expect(view.content.querySelectorAll('.chat-msg').length).toBe(5);
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
const nth_child = (n) => `converse-chat-message:nth-child(${n}) .chat-msg`;
expect(u.hasClass('chat-msg--followup', view.content.querySelector(nth_child(2)))).toBe(false);
expect(view.content.querySelector(`${nth_child(2)} .chat-msg__text`).textContent).toBe("A message");
expect(u.hasClass('chat-msg--followup', view.content.querySelector(nth_child(3)))).toBe(true);
expect(view.content.querySelector(`${nth_child(3)} .chat-msg__text`).textContent).toBe(
Use Karma as test runner
2020-04-22 13:11:48 +02:00
"Another message 3 minutes later");
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
expect(u.hasClass('chat-msg--followup', view.content.querySelector(nth_child(4)))).toBe(false);
expect(view.content.querySelector(`${nth_child(4)} .chat-msg__text`).textContent).toBe(
Use Karma as test runner
2020-04-22 13:11:48 +02:00
"Another message 14 minutes since we started");
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
expect(u.hasClass('chat-msg--followup', view.content.querySelector(nth_child(5)))).toBe(true);
expect(view.content.querySelector(`${nth_child(5)} .chat-msg__text`).textContent).toBe(
Use Karma as test runner
2020-04-22 13:11:48 +02:00
"Another message 1 minute and 1 second since the previous one");
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
expect(u.hasClass('chat-msg--followup', view.content.querySelector(nth_child(6)))).toBe(false);
expect(view.content.querySelector(`${nth_child(6)} .chat-msg__text`).textContent).toBe(
Use Karma as test runner
2020-04-22 13:11:48 +02:00
"Another message within 10 minutes, but from a different person");
// Let's add a delayed, inbetween message
_converse.handleMessageStanza(
$msg({
'xmlns': 'jabber:client',
'id': _converse.connection.getUniqueId(),
'to': _converse.bare_jid,
'from': sender_jid,
'type': 'chat'
}).c('body').t("A delayed message, sent 5 minutes since we started").up()
.c('delay', {'xmlns': 'urn:xmpp:delay', 'stamp': dayjs(base_time).add(5, 'minutes').toISOString()})
.tree());
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
await new Promise(resolve => view.model.messages.once('rendered', resolve));
Use Karma as test runner
2020-04-22 13:11:48 +02:00
expect(view.content.querySelectorAll('.message').length).toBe(7);
expect(view.content.querySelectorAll('.chat-msg').length).toBe(6);
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
expect(u.hasClass('chat-msg--followup', view.content.querySelector(nth_child(2)))).toBe(false);
expect(view.content.querySelector(`${nth_child(2)} .chat-msg__text`).textContent).toBe("A message");
expect(u.hasClass('chat-msg--followup', view.content.querySelector(nth_child(3)))).toBe(true);
expect(view.content.querySelector(`${nth_child(3)} .chat-msg__text`).textContent).toBe(
Use Karma as test runner
2020-04-22 13:11:48 +02:00
"Another message 3 minutes later");
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
expect(u.hasClass('chat-msg--followup', view.content.querySelector(nth_child(4)))).toBe(true);
expect(view.content.querySelector(`${nth_child(4)} .chat-msg__text`).textContent).toBe(
Use Karma as test runner
2020-04-22 13:11:48 +02:00
"A delayed message, sent 5 minutes since we started");
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
expect(u.hasClass('chat-msg--followup', view.content.querySelector(nth_child(5)))).toBe(true);
expect(view.content.querySelector(`${nth_child(5)} .chat-msg__text`).textContent).toBe(
Use Karma as test runner
2020-04-22 13:11:48 +02:00
"Another message 14 minutes since we started");
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
expect(u.hasClass('chat-msg--followup', view.content.querySelector(nth_child(6)))).toBe(true);
expect(view.content.querySelector(`${nth_child(6)} .chat-msg__text`).textContent).toBe(
Use Karma as test runner
2020-04-22 13:11:48 +02:00
"Another message 1 minute and 1 second since the previous one");
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
expect(u.hasClass('chat-msg--followup', view.content.querySelector(nth_child(7)))).toBe(false);
expect(view.content.querySelector(`${nth_child(7)} .chat-msg__text`).textContent).toBe(
"Another message within 10 minutes, but from a different person");
Use Karma as test runner
2020-04-22 13:11:48 +02:00
_converse.handleMessageStanza(
$msg({
'xmlns': 'jabber:client',
'id': _converse.connection.getUniqueId(),
'to': sender_jid,
'from': _converse.bare_jid+"/some-other-resource",
'type': 'chat'})
.c('body').t("A carbon message 4 minutes later").up()
.c('delay', {'xmlns': 'urn:xmpp:delay', 'stamp':dayjs(base_time).add(4, 'minutes').toISOString()})
.tree());
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
await new Promise(resolve => view.model.messages.once('rendered', resolve));
Use Karma as test runner
2020-04-22 13:11:48 +02:00
expect(view.content.querySelectorAll('.chat-msg').length).toBe(7);
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
expect(u.hasClass('chat-msg--followup', view.content.querySelector(nth_child(2)))).toBe(false);
expect(view.content.querySelector(`${nth_child(2)} .chat-msg__text`).textContent).toBe("A message");
expect(u.hasClass('chat-msg--followup', view.content.querySelector(nth_child(3)))).toBe(true);
expect(view.content.querySelector(`${nth_child(3)} .chat-msg__text`).textContent).toBe(
Use Karma as test runner
2020-04-22 13:11:48 +02:00
"Another message 3 minutes later");
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
expect(u.hasClass('chat-msg--followup', view.content.querySelector(nth_child(4)))).toBe(false);
expect(view.content.querySelector(`${nth_child(4)} .chat-msg__text`).textContent).toBe(
Use Karma as test runner
2020-04-22 13:11:48 +02:00
"A carbon message 4 minutes later");
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
expect(u.hasClass('chat-msg--followup', view.content.querySelector(nth_child(5)))).toBe(false);
expect(view.content.querySelector(`${nth_child(5)} .chat-msg__text`).textContent).toBe(
Use Karma as test runner
2020-04-22 13:11:48 +02:00
"A delayed message, sent 5 minutes since we started");
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
expect(u.hasClass('chat-msg--followup', view.content.querySelector(nth_child(6)))).toBe(true);
expect(view.content.querySelector(`${nth_child(6)} .chat-msg__text`).textContent).toBe(
Use Karma as test runner
2020-04-22 13:11:48 +02:00
"Another message 14 minutes since we started");
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
expect(u.hasClass('chat-msg--followup', view.content.querySelector(nth_child(7)))).toBe(true);
expect(view.content.querySelector(`${nth_child(7)} .chat-msg__text`).textContent).toBe(
Use Karma as test runner
2020-04-22 13:11:48 +02:00
"Another message 1 minute and 1 second since the previous one");
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
expect(u.hasClass('chat-msg--followup', view.content.querySelector(nth_child(8)))).toBe(false);
expect(view.content.querySelector(`${nth_child(8)} .chat-msg__text`).textContent).toBe(
Use Karma as test runner
2020-04-22 13:11:48 +02:00
"Another message within 10 minutes, but from a different person");
jasmine.clock().uninstall();
done();
}));
Use async/await
2018-11-20 18:10:55 +01:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
describe("when sent", function () {
Move message-related tests into their own file
2018-04-29 15:40:24 +02:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
it("will appear inside the chatbox it was sent from",
Make `converse.initialize` an `async` function - Combine all test init functions into `initConverse` - Use `async` functions in more tests - Replace `var` with `let` and `const` in more tests - New utils method `toStanza` which converts a string to a Node
2019-02-12 14:21:45 +01:00
mock.initConverse(
Remove need to pass in spies to `initConverse` They aren't used anymore.
2019-10-11 16:38:01 +02:00
['rosterGroupsFetched', 'chatBoxesFetched'], {},
Make the message view's `render` method async So that we first render dynamic content (e.g. images) before inserting it into the chat. Also, add the `show_images_inline` setting (which is the cause of this whole change). Updated tests to handle this new change and start using async/await instead of promise callbacks.
2018-10-13 23:25:01 +02:00
async function (done, _converse) {
Move message-related tests into their own file
2018-04-29 15:40:24 +02:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
await mock.waitForRoster(_converse, 'current');
await mock.openControlBox(_converse);
spyOn(_converse.api, "trigger").and.callThrough();
Use shakespearean character names in tests
2019-06-03 07:58:51 +02:00
const contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@montague.lit';
Use Karma as test runner
2020-04-22 13:11:48 +02:00
await mock.openChatBoxFor(_converse, contact_jid)
const view = _converse.chatboxviews.get(contact_jid);
const message = 'This message is sent from this chatbox';
Make the message view's `render` method async So that we first render dynamic content (e.g. images) before inserting it into the chat. Also, add the `show_images_inline` setting (which is the cause of this whole change). Updated tests to handle this new change and start using async/await instead of promise callbacks.
2018-10-13 23:25:01 +02:00
spyOn(view.model, 'sendMessage').and.callThrough();
Use Karma as test runner
2020-04-22 13:11:48 +02:00
await mock.sendMessage(view, message);
Make the message view's `render` method async So that we first render dynamic content (e.g. images) before inserting it into the chat. Also, add the `show_images_inline` setting (which is the cause of this whole change). Updated tests to handle this new change and start using async/await instead of promise callbacks.
2018-10-13 23:25:01 +02:00
expect(view.model.sendMessage).toHaveBeenCalled();
Use Karma as test runner
2020-04-22 13:11:48 +02:00
expect(view.model.messages.length, 2);
expect(_converse.api.trigger.calls.mostRecent().args, ['messageSend', message]);
expect(sizzle('.chat-content .chat-msg:last .chat-msg__text', view.el).pop().textContent).toEqual(message);
Make the message view's `render` method async So that we first render dynamic content (e.g. images) before inserting it into the chat. Also, add the `show_images_inline` setting (which is the cause of this whole change). Updated tests to handle this new change and start using async/await instead of promise callbacks.
2018-10-13 23:25:01 +02:00
done();
Rearrange: move non-nested tests to top of `describe`
2018-08-15 11:02:24 +02:00
}));
Move message-related tests into their own file
2018-04-29 15:40:24 +02:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
it("will be trimmed of leading and trailing whitespace",
Make `converse.initialize` an `async` function - Combine all test init functions into `initConverse` - Use `async` functions in more tests - Replace `var` with `let` and `const` in more tests - New utils method `toStanza` which converts a string to a Node
2019-02-12 14:21:45 +01:00
mock.initConverse(
emoji: Lazy load the emoji JSON Only load it once the first chat has been opened.
2020-01-21 12:45:34 +01:00
['rosterGroupsFetched', 'chatBoxesFetched'], {},
Use async/await
2018-11-18 15:24:34 +01:00
async function (done, _converse) {
Move message-related tests into their own file
2018-04-29 15:40:24 +02:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
await mock.waitForRoster(_converse, 'current', 1);
Use shakespearean character names in tests
2019-06-03 07:58:51 +02:00
const contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@montague.lit';
Use Karma as test runner
2020-04-22 13:11:48 +02:00
await mock.openChatBoxFor(_converse, contact_jid)
const view = _converse.chatboxviews.get(contact_jid);
const message = ' \nThis message is sent from this chatbox \n \n';
await mock.sendMessage(view, message);
expect(view.model.messages.at(0).get('message')).toEqual(message.trim());
const message_el = sizzle('.chat-content .chat-msg:last .chat-msg__text', view.el).pop();
expect(message_el.textContent).toEqual(message.trim());
Use async/await
2018-11-18 15:24:34 +01:00
done();
Move message-related tests into their own file
2018-04-29 15:40:24 +02:00
}));
Use Karma as test runner
2020-04-22 13:11:48 +02:00
});
Move message-related tests into their own file
2018-04-29 15:40:24 +02:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
describe("when received from someone else", function () {
Move message-related tests into their own file
2018-04-29 15:40:24 +02:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
it("will open a chatbox and be displayed inside it",
Make `converse.initialize` an `async` function - Combine all test init functions into `initConverse` - Use `async` functions in more tests - Replace `var` with `let` and `const` in more tests - New utils method `toStanza` which converts a string to a Node
2019-02-12 14:21:45 +01:00
mock.initConverse(
emoji: Lazy load the emoji JSON Only load it once the first chat has been opened.
2020-01-21 12:45:34 +01:00
['rosterGroupsFetched'], {},
Make the message view's `render` method async So that we first render dynamic content (e.g. images) before inserting it into the chat. Also, add the `show_images_inline` setting (which is the cause of this whole change). Updated tests to handle this new change and start using async/await instead of promise callbacks.
2018-10-13 23:25:01 +02:00
async function (done, _converse) {
Move message-related tests into their own file
2018-04-29 15:40:24 +02:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
const include_nick = false;
await mock.waitForRoster(_converse, 'current', 1, include_nick);
await mock.openControlBox(_converse);
Replace wait-until-promise with utility method and bump default timeout Also let `_converse.api.waitUntil` use it if a function is passed in.
2019-07-11 22:50:30 +02:00
await u.waitUntil(() => _converse.rosterview.el.querySelectorAll('.roster-group').length, 300);
Use Karma as test runner
2020-04-22 13:11:48 +02:00
spyOn(_converse.api, "trigger").and.callThrough();
const message = 'This is a received message';
Use shakespearean character names in tests
2019-06-03 07:58:51 +02:00
const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@montague.lit';
Use Karma as test runner
2020-04-22 13:11:48 +02:00
// We don't already have an open chatbox for this user
expect(_converse.chatboxes.get(sender_jid)).not.toBeDefined();
await _converse.handleMessageStanza(
$msg({
Make the message view's `render` method async So that we first render dynamic content (e.g. images) before inserting it into the chat. Also, add the `show_images_inline` setting (which is the cause of this whole change). Updated tests to handle this new change and start using async/await instead of promise callbacks.
2018-10-13 23:25:01 +02:00
'from': sender_jid,
'to': _converse.connection.jid,
'type': 'chat',
tests: Use `u.getUniqueId` instead of time for message ids
2020-02-07 12:24:02 +01:00
'id': u.getUniqueId()
Use Karma as test runner
2020-04-22 13:11:48 +02:00
}).c('body').t(message).up()
.c('active', {'xmlns': 'http://jabber.org/protocol/chatstates'}).tree()
);
const chatbox = await _converse.chatboxes.get(sender_jid);
expect(chatbox).toBeDefined();
Use the API in tests
2019-02-22 21:43:49 +01:00
const view = _converse.api.chatviews.get(sender_jid);
Use Karma as test runner
2020-04-22 13:11:48 +02:00
expect(view).toBeDefined();
Make the message view's `render` method async So that we first render dynamic content (e.g. images) before inserting it into the chat. Also, add the `show_images_inline` setting (which is the cause of this whole change). Updated tests to handle this new change and start using async/await instead of promise callbacks.
2018-10-13 23:25:01 +02:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
expect(_converse.api.trigger).toHaveBeenCalledWith('message', jasmine.any(Object));
// Check that the message was received and check the message parameters
await u.waitUntil(() => chatbox.messages.length);
expect(chatbox.messages.length).toEqual(1);
const msg_obj = chatbox.messages.models[0];
expect(msg_obj.get('message')).toEqual(message);
expect(msg_obj.get('fullname')).toBeUndefined();
expect(msg_obj.get('sender')).toEqual('them');
expect(msg_obj.get('is_delayed')).toEqual(false);
// Now check that the message appears inside the chatbox in the DOM
const mel = await u.waitUntil(() => view.content.querySelector('.chat-msg .chat-msg__text'));
expect(mel.textContent).toEqual(message);
expect(view.content.querySelector('.chat-msg__time').textContent.match(/^[0-9][0-9]:[0-9][0-9]/)).toBeTruthy();
await u.waitUntil(() => chatbox.vcard.get('fullname') === mock.cur_names[0]);
expect(view.content.querySelector('span.chat-msg__author').textContent.trim()).toBe('Mercutio');
done();
}));
Make the message view's `render` method async So that we first render dynamic content (e.g. images) before inserting it into the chat. Also, add the `show_images_inline` setting (which is the cause of this whole change). Updated tests to handle this new change and start using async/await instead of promise callbacks.
2018-10-13 23:25:01 +02:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
it("will be trimmed of leading and trailing whitespace",
mock.initConverse(
['rosterGroupsFetched'], {},
async function (done, _converse) {
Handle and render chat state notifications separately from messages
2020-03-18 19:32:03 +01:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
await mock.waitForRoster(_converse, 'current', 1, false);
await u.waitUntil(() => _converse.rosterview.el.querySelectorAll('.roster-group').length, 300);
const message = '\n\n This is a received message \n\n';
const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@montague.lit';
await _converse.handleMessageStanza(
$msg({
Make the message view's `render` method async So that we first render dynamic content (e.g. images) before inserting it into the chat. Also, add the `show_images_inline` setting (which is the cause of this whole change). Updated tests to handle this new change and start using async/await instead of promise callbacks.
2018-10-13 23:25:01 +02:00
'from': sender_jid,
'to': _converse.connection.jid,
'type': 'chat',
Use Karma as test runner
2020-04-22 13:11:48 +02:00
'id': u.getUniqueId()
}).c('body').t(message).up()
.c('active', {'xmlns': 'http://jabber.org/protocol/chatstates'}).tree()
);
const view = _converse.api.chatviews.get(sender_jid);
await u.waitUntil(() => view.model.messages.length);
expect(view.model.messages.length).toEqual(1);
const msg_obj = view.model.messages.at(0);
expect(msg_obj.get('message')).toEqual(message.trim());
const mel = await u.waitUntil(() => view.content.querySelector('.chat-msg .chat-msg__text'));
expect(mel.textContent).toEqual(message.trim());
Make the message view's `render` method async So that we first render dynamic content (e.g. images) before inserting it into the chat. Also, add the `show_images_inline` setting (which is the cause of this whole change). Updated tests to handle this new change and start using async/await instead of promise callbacks.
2018-10-13 23:25:01 +02:00
done();
Move message-related tests into their own file
2018-04-29 15:40:24 +02:00
}));
Use Karma as test runner
2020-04-22 13:11:48 +02:00
describe("when a chatbox is opened for someone who is not in the roster", function () {
it("the VCard for that user is fetched and the chatbox updated with the results",
Re-group some message specs
2019-06-26 11:09:07 +02:00
mock.initConverse(
Use Karma as test runner
2020-04-22 13:11:48 +02:00
['rosterGroupsFetched'], {'allow_non_roster_messaging': true},
Re-group some message specs
2019-06-26 11:09:07 +02:00
async function (done, _converse) {
Use Karma as test runner
2020-04-22 13:11:48 +02:00
await mock.waitForRoster(_converse, 'current', 0);
Fixes #1561 Don't clear localStorage and sessionStorage
2019-08-01 10:26:35 +02:00
spyOn(_converse.api, "trigger").and.callThrough();
Re-group some message specs
2019-06-26 11:09:07 +02:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@montague.lit';
var vcard_fetched = false;
spyOn(_converse.api.vcard, "get").and.callFake(function () {
vcard_fetched = true;
return Promise.resolve({
'fullname': mock.cur_names[0],
'vcard_updated': (new Date()).toISOString(),
'jid': sender_jid
});
});
const message = 'This is a received message from someone not on the roster';
const msg = $msg({
from: sender_jid,
to: _converse.connection.jid,
type: 'chat',
id: u.getUniqueId()
}).c('body').t(message).up()
.c('active', {'xmlns': 'http://jabber.org/protocol/chatstates'}).tree();
Fixes #1494. Trim whitespace around messages
2019-06-26 10:59:02 +02:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
// We don't already have an open chatbox for this user
expect(_converse.chatboxes.get(sender_jid)).not.toBeDefined();
Fixes #1494. Trim whitespace around messages
2019-06-26 10:59:02 +02:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
await _converse.handleMessageStanza(msg);
const view = await u.waitUntil(() => _converse.api.chatviews.get(sender_jid));
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
await new Promise(resolve => view.model.messages.once('rendered', resolve));
Use Karma as test runner
2020-04-22 13:11:48 +02:00
expect(_converse.api.trigger).toHaveBeenCalledWith('message', jasmine.any(Object));
// Check that the chatbox and its view now exist
const chatbox = await _converse.api.chats.get(sender_jid);
expect(chatbox.get('fullname') === sender_jid);
await u.waitUntil(() => view.el.querySelector('.chat-msg__author').textContent.trim() === 'Mercutio');
let author_el = view.el.querySelector('.chat-msg__author');
expect( _.includes(author_el.textContent.trim(), 'Mercutio')).toBeTruthy();
await u.waitUntil(() => vcard_fetched, 100);
expect(_converse.api.vcard.get).toHaveBeenCalled();
await u.waitUntil(() => chatbox.vcard.get('fullname') === mock.cur_names[0])
author_el = view.el.querySelector('.chat-msg__author');
expect( _.includes(author_el.textContent.trim(), 'Mercutio')).toBeTruthy();
Fixes #1494. Trim whitespace around messages
2019-06-26 10:59:02 +02:00
done();
}));
});
Add method to determine references from message text
2018-08-15 17:22:24 +02:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
describe("who is not on the roster", function () {
Move message-related tests into their own file
2018-04-29 15:40:24 +02:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
it("will open a chatbox and be displayed inside it if allow_non_roster_messaging is true",
Make `converse.initialize` an `async` function - Combine all test init functions into `initConverse` - Use `async` functions in more tests - Replace `var` with `let` and `const` in more tests - New utils method `toStanza` which converts a string to a Node
2019-02-12 14:21:45 +01:00
mock.initConverse(
Use Karma as test runner
2020-04-22 13:11:48 +02:00
['rosterGroupsFetched'], {'allow_non_roster_messaging': false},
Make the message view's `render` method async So that we first render dynamic content (e.g. images) before inserting it into the chat. Also, add the `show_images_inline` setting (which is the cause of this whole change). Updated tests to handle this new change and start using async/await instead of promise callbacks.
2018-10-13 23:25:01 +02:00
async function (done, _converse) {
Move message-related tests into their own file
2018-04-29 15:40:24 +02:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
await mock.waitForRoster(_converse, 'current', 0);
Rename `emit` to `trigger` for consistency with Backbone.Events
2019-03-29 21:10:45 +01:00
spyOn(_converse.api, "trigger").and.callThrough();
Use Karma as test runner
2020-04-22 13:11:48 +02:00
const message = 'This is a received message from someone not on the roster';
Use shakespearean character names in tests
2019-06-03 07:58:51 +02:00
const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@montague.lit';
Use Karma as test runner
2020-04-22 13:11:48 +02:00
const msg = $msg({
from: sender_jid,
to: _converse.connection.jid,
type: 'chat',
id: u.getUniqueId()
}).c('body').t(message).up()
.c('active', {'xmlns': 'http://jabber.org/protocol/chatstates'}).tree();
Make the message view's `render` method async So that we first render dynamic content (e.g. images) before inserting it into the chat. Also, add the `show_images_inline` setting (which is the cause of this whole change). Updated tests to handle this new change and start using async/await instead of promise callbacks.
2018-10-13 23:25:01 +02:00
// We don't already have an open chatbox for this user
expect(_converse.chatboxes.get(sender_jid)).not.toBeDefined();
Use Karma as test runner
2020-04-22 13:11:48 +02:00
let chatbox = await _converse.api.chats.get(sender_jid);
expect(chatbox).toBe(null);
await _converse.handleMessageStanza(msg);
let view = _converse.chatboxviews.get(sender_jid);
expect(view).not.toBeDefined();
_converse.allow_non_roster_messaging = true;
await _converse.handleMessageStanza(msg);
view = _converse.chatboxviews.get(sender_jid);
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
await new Promise(resolve => view.model.messages.once('rendered', resolve));
Rename `emit` to `trigger` for consistency with Backbone.Events
2019-03-29 21:10:45 +01:00
expect(_converse.api.trigger).toHaveBeenCalledWith('message', jasmine.any(Object));
Use Karma as test runner
2020-04-22 13:11:48 +02:00
// Check that the chatbox and its view now exist
chatbox = await _converse.api.chats.get(sender_jid);
expect(chatbox).toBeDefined();
expect(view).toBeDefined();
Make the message view's `render` method async So that we first render dynamic content (e.g. images) before inserting it into the chat. Also, add the `show_images_inline` setting (which is the cause of this whole change). Updated tests to handle this new change and start using async/await instead of promise callbacks.
2018-10-13 23:25:01 +02:00
// Check that the message was received and check the message parameters
expect(chatbox.messages.length).toEqual(1);
const msg_obj = chatbox.messages.models[0];
expect(msg_obj.get('message')).toEqual(message);
Use Karma as test runner
2020-04-22 13:11:48 +02:00
expect(msg_obj.get('fullname')).toEqual(undefined);
Make the message view's `render` method async So that we first render dynamic content (e.g. images) before inserting it into the chat. Also, add the `show_images_inline` setting (which is the cause of this whole change). Updated tests to handle this new change and start using async/await instead of promise callbacks.
2018-10-13 23:25:01 +02:00
expect(msg_obj.get('sender')).toEqual('them');
expect(msg_obj.get('is_delayed')).toEqual(false);
Use Karma as test runner
2020-04-22 13:11:48 +02:00
await u.waitUntil(() => view.el.querySelector('.chat-msg__author').textContent.trim() === 'Mercutio');
Make the message view's `render` method async So that we first render dynamic content (e.g. images) before inserting it into the chat. Also, add the `show_images_inline` setting (which is the cause of this whole change). Updated tests to handle this new change and start using async/await instead of promise callbacks.
2018-10-13 23:25:01 +02:00
// Now check that the message appears inside the chatbox in the DOM
Use Karma as test runner
2020-04-22 13:11:48 +02:00
expect(view.content.querySelector('.chat-msg .chat-msg__text').textContent).toEqual(message);
Show chat state notifications inside the scrollable area Rename CSS class to conform to convention
2020-03-24 10:20:11 +01:00
expect(view.content.querySelector('.chat-msg__time').textContent.match(/^[0-9][0-9]:[0-9][0-9]/)).toBeTruthy();
expect(view.content.querySelector('span.chat-msg__author').textContent.trim()).toBe('Mercutio');
Make the message view's `render` method async So that we first render dynamic content (e.g. images) before inserting it into the chat. Also, add the `show_images_inline` setting (which is the cause of this whole change). Updated tests to handle this new change and start using async/await instead of promise callbacks.
2018-10-13 23:25:01 +02:00
done();
Rearrange: move non-nested tests to top of `describe`
2018-08-15 11:02:24 +02:00
}));
Use Karma as test runner
2020-04-22 13:11:48 +02:00
});
Move message-related tests into their own file
2018-04-29 15:40:24 +02:00
Fixes #1494. Trim whitespace around messages
2019-06-26 10:59:02 +02:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
describe("and for which then an error message is received from the server", function () {
Fixes #1494. Trim whitespace around messages
2019-06-26 10:59:02 +02:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
it("will have the error message displayed after itself",
Make `converse.initialize` an `async` function - Combine all test init functions into `initConverse` - Use `async` functions in more tests - Replace `var` with `let` and `const` in more tests - New utils method `toStanza` which converts a string to a Node
2019-02-12 14:21:45 +01:00
mock.initConverse(
Remove need to pass in spies to `initConverse` They aren't used anymore.
2019-10-11 16:38:01 +02:00
['rosterGroupsFetched', 'chatBoxesFetched'], {},
Make the message view's `render` method async So that we first render dynamic content (e.g. images) before inserting it into the chat. Also, add the `show_images_inline` setting (which is the cause of this whole change). Updated tests to handle this new change and start using async/await instead of promise callbacks.
2018-10-13 23:25:01 +02:00
async function (done, _converse) {
Move message-related tests into their own file
2018-04-29 15:40:24 +02:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
await mock.waitForRoster(_converse, 'current', 1);
// TODO: what could still be done for error
// messages... if the <error> element has type
// "cancel", then we know the messages wasn't sent,
// and can give the user a nicer indication of
// that.
/* <message from="scotty@enterprise.com/_converse.js-84843526"
* to="kirk@enterprise.com.com"
* type="chat"
* id="82bc02ce-9651-4336-baf0-fa04762ed8d2"
* xmlns="jabber:client">
* <body>yo</body>
* <active xmlns="http://jabber.org/protocol/chatstates"/>
* </message>
*/
const error_txt = 'Server-to-server connection failed: Connecting failed: connection timeout';
Refactor so that message attributes are parsed early It's better to parse an incoming message stanza early, than to have all kinds of methods throughout the codebase that does querySelector etc. Firstly, it allows us to catch and report errors and malicious stanzas early on. It also simplifies programming because you don't need to try and remember how to properly parse a stanza, all the work is done upfront for you.
2020-04-24 17:33:32 +02:00
const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@montague.lit';
Use Karma as test runner
2020-04-22 13:11:48 +02:00
await _converse.api.chats.open(sender_jid)
let msg_text = 'This message will not be sent, due to an error';
const view = _converse.api.chatviews.get(sender_jid);
const message = await view.model.sendMessage(msg_text);
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
await new Promise(resolve => view.model.messages.once('rendered', resolve));
Use Karma as test runner
2020-04-22 13:11:48 +02:00
let msg_txt = sizzle('.chat-msg:last .chat-msg__text', view.content).pop().textContent;
expect(msg_txt).toEqual(msg_text);
// We send another message, for which an error will
// not be received, to test that errors appear
// after the relevant message.
msg_text = 'This message will be sent, and also receive an error';
const second_message = await view.model.sendMessage(msg_text);
await u.waitUntil(() => sizzle('.chat-msg .chat-msg__text', view.content).length === 2, 1000);
msg_txt = sizzle('.chat-msg:last .chat-msg__text', view.content).pop().textContent;
expect(msg_txt).toEqual(msg_text);
/* <message xmlns="jabber:client"
* to="scotty@enterprise.com/_converse.js-84843526"
* type="error"
* id="82bc02ce-9651-4336-baf0-fa04762ed8d2"
* from="kirk@enterprise.com.com">
* <error type="cancel">
* <remote-server-not-found xmlns="urn:ietf:params:xml:ns:xmpp-stanzas"/>
* <text xmlns="urn:ietf:params:xml:ns:xmpp-stanzas">Server-to-server connection failed: Connecting failed: connection timeout</text>
* </error>
* </message>
*/
let stanza = $msg({
'to': _converse.connection.jid,
'type': 'error',
'id': message.get('msgid'),
'from': sender_jid
})
.c('error', {'type': 'cancel'})
.c('remote-server-not-found', { 'xmlns': "urn:ietf:params:xml:ns:xmpp-stanzas" }).up()
.c('text', { 'xmlns': "urn:ietf:params:xml:ns:xmpp-stanzas" })
.t('Server-to-server connection failed: Connecting failed: connection timeout');
_converse.connection._dataRecv(mock.createRequest(stanza));
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
await u.waitUntil(() => view.content.querySelector('.chat-msg__error').textContent.trim() === error_txt);
const other_error_txt = 'Server-to-server connection failed: Connecting failed: connection timeout';
Use Karma as test runner
2020-04-22 13:11:48 +02:00
stanza = $msg({
Make the message view's `render` method async So that we first render dynamic content (e.g. images) before inserting it into the chat. Also, add the `show_images_inline` setting (which is the cause of this whole change). Updated tests to handle this new change and start using async/await instead of promise callbacks.
2018-10-13 23:25:01 +02:00
'to': _converse.connection.jid,
Use Karma as test runner
2020-04-22 13:11:48 +02:00
'type': 'error',
'id': second_message.get('id'),
'from': sender_jid
})
.c('error', {'type': 'cancel'})
.c('remote-server-not-found', { 'xmlns': "urn:ietf:params:xml:ns:xmpp-stanzas" }).up()
.c('text', { 'xmlns': "urn:ietf:params:xml:ns:xmpp-stanzas" })
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
.t(other_error_txt);
Use Karma as test runner
2020-04-22 13:11:48 +02:00
_converse.connection._dataRecv(mock.createRequest(stanza));
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
await u.waitUntil(() =>
view.content.querySelector('converse-chat-message:last-child .chat-msg__error').textContent.trim() === other_error_txt);
Move message-related tests into their own file
2018-04-29 15:40:24 +02:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
// We don't render duplicates
stanza = $msg({
Make the message view's `render` method async So that we first render dynamic content (e.g. images) before inserting it into the chat. Also, add the `show_images_inline` setting (which is the cause of this whole change). Updated tests to handle this new change and start using async/await instead of promise callbacks.
2018-10-13 23:25:01 +02:00
'to': _converse.connection.jid,
Use Karma as test runner
2020-04-22 13:11:48 +02:00
'type':'error',
'id': '6fcdeee3-000f-4ce8-a17e-9ce28f0ae104',
'from': sender_jid
})
.c('error', {'type': 'cancel'})
.c('remote-server-not-found', { 'xmlns': "urn:ietf:params:xml:ns:xmpp-stanzas" }).up()
.c('text', { 'xmlns': "urn:ietf:params:xml:ns:xmpp-stanzas" })
.t('Server-to-server connection failed: Connecting failed: connection timeout');
_converse.connection._dataRecv(mock.createRequest(stanza));
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
expect(view.content.querySelectorAll('.chat-msg__error').length).toEqual(2);
Use Karma as test runner
2020-04-22 13:11:48 +02:00
msg_text = 'This message will be sent, and also receive an error';
const third_message = await view.model.sendMessage(msg_text);
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
await u.waitUntil(() => sizzle('converse-chat-message:last-child .chat-msg__text', view.content).pop()?.textContent === msg_text);
Wait for promises before opening chats in API methods
2018-07-30 18:16:32 +02:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
// A different error message will however render
stanza = $msg({
Make the message view's `render` method async So that we first render dynamic content (e.g. images) before inserting it into the chat. Also, add the `show_images_inline` setting (which is the cause of this whole change). Updated tests to handle this new change and start using async/await instead of promise callbacks.
2018-10-13 23:25:01 +02:00
'to': _converse.connection.jid,
Use Karma as test runner
2020-04-22 13:11:48 +02:00
'type':'error',
'id': third_message.get('id'),
'from': sender_jid
})
.c('error', {'type': 'cancel'})
.c('not-allowed', { 'xmlns': "urn:ietf:params:xml:ns:xmpp-stanzas" }).up()
.c('text', { 'xmlns': "urn:ietf:params:xml:ns:xmpp-stanzas" })
.t('Something else went wrong as well');
_converse.connection._dataRecv(mock.createRequest(stanza));
regression of #1317: Don't show errors for CSI messages (#2276) * regression of #1317: Don't show errors for CSI messages * fix failing tests
2020-10-08 12:13:04 +02:00
await u.waitUntil(() => view.model.messages.length > 2);
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
await new Promise(resolve => view.model.messages.once('rendered', resolve));
regression of #1317: Don't show errors for CSI messages (#2276) * regression of #1317: Don't show errors for CSI messages * fix failing tests
2020-10-08 12:13:04 +02:00
expect(view.content.querySelectorAll('.chat-msg__error').length).toEqual(3);
Makes message with errors non-editable (#2089) * Makes message with errors non-editable
2020-06-25 10:22:44 +02:00
// Ensure messages with error are not editable
document.querySelectorAll('.chat-msg__actions').forEach(elem => {
expect(elem.querySelector('.chat-msg__action-edit')).toBe(null)
})
view.model.messages.forEach(message => {
const isEditable = message.get('editable');
isEditable && expect(isEditable).toBe(false);
})
Make the message view's `render` method async So that we first render dynamic content (e.g. images) before inserting it into the chat. Also, add the `show_images_inline` setting (which is the cause of this whole change). Updated tests to handle this new change and start using async/await instead of promise callbacks.
2018-10-13 23:25:01 +02:00
done();
}));
Use Karma as test runner
2020-04-22 13:11:48 +02:00
it("will not show to the user an error message for a CSI message",
Make `converse.initialize` an `async` function - Combine all test init functions into `initConverse` - Use `async` functions in more tests - Replace `var` with `let` and `const` in more tests - New utils method `toStanza` which converts a string to a Node
2019-02-12 14:21:45 +01:00
mock.initConverse(
Remove need to pass in spies to `initConverse` They aren't used anymore.
2019-10-11 16:38:01 +02:00
['rosterGroupsFetched', 'chatBoxesFetched'], {},
Make the message view's `render` method async So that we first render dynamic content (e.g. images) before inserting it into the chat. Also, add the `show_images_inline` setting (which is the cause of this whole change). Updated tests to handle this new change and start using async/await instead of promise callbacks.
2018-10-13 23:25:01 +02:00
async function (done, _converse) {
Mark followup messags so that they can be styled differently
2018-04-30 12:15:26 +02:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
// See #1317
// https://github.com/conversejs/converse.js/issues/1317
await mock.waitForRoster(_converse, 'current');
await mock.openControlBox(_converse);
Mark followup messags so that they can be styled differently
2018-04-30 12:15:26 +02:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
const contact_jid = mock.cur_names[5].replace(/ /g,'.').toLowerCase() + '@montague.lit';
await mock.openChatBoxFor(_converse, contact_jid);
Refactoring - Move headless one-on-one chat functionality into converse-chat - Split converse-headline into converse-headlines and converse-headlines-views - Add api in `_converse.api.chatboxes` for creating chatboxes - Add `_converse.api.controlbox.get` method
2019-11-01 16:04:55 +01:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
const messages = _converse.connection.sent_stanzas.filter(s => s.nodeName === 'message');
expect(messages.length).toBe(1);
expect(Strophe.serialize(messages[0])).toBe(
`<message id="${messages[0].getAttribute('id')}" to="tybalt@montague.lit" type="chat" xmlns="jabber:client">`+
`<active xmlns="http://jabber.org/protocol/chatstates"/>`+
`<no-store xmlns="urn:xmpp:hints"/>`+
`<no-permanent-store xmlns="urn:xmpp:hints"/>`+
`</message>`);
Make the message view's `render` method async So that we first render dynamic content (e.g. images) before inserting it into the chat. Also, add the `show_images_inline` setting (which is the cause of this whole change). Updated tests to handle this new change and start using async/await instead of promise callbacks.
2018-10-13 23:25:01 +02:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
const stanza = $msg({
'from': contact_jid,
'type': 'error',
'id': messages[0].getAttribute('id')
}).c('error', {'type': 'cancel', 'code': '503'})
.c('service-unavailable', { 'xmlns': 'urn:ietf:params:xml:ns:xmpp-stanzas' }).up()
.c('text', { 'xmlns': 'urn:ietf:params:xml:ns:xmpp-stanzas' })
.t('User session not found')
_converse.connection._dataRecv(mock.createRequest(stanza));
const view = _converse.chatboxviews.get(contact_jid);
regression of #1317: Don't show errors for CSI messages (#2276) * regression of #1317: Don't show errors for CSI messages * fix failing tests
2020-10-08 12:13:04 +02:00
const msg_text = 'This message will show!';
await view.model.sendMessage(msg_text);
await new Promise(resolve => view.model.messages.once('rendered', resolve));
Use Karma as test runner
2020-04-22 13:11:48 +02:00
expect(view.content.querySelectorAll('.chat-error').length).toEqual(0);
Make the message view's `render` method async So that we first render dynamic content (e.g. images) before inserting it into the chat. Also, add the `show_images_inline` setting (which is the cause of this whole change). Updated tests to handle this new change and start using async/await instead of promise callbacks.
2018-10-13 23:25:01 +02:00
done();
Rearrange: move non-nested tests to top of `describe`
2018-08-15 11:02:24 +02:00
}));
});
Mark followup messags so that they can be styled differently
2018-04-30 12:15:26 +02:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
it("will cause the chat area to be scrolled down only if it was at the bottom originally",
mock.initConverse(
['rosterGroupsFetched', 'chatBoxesFetched'], {},
async function (done, _converse) {
Move message-related tests into their own file
2018-04-29 15:40:24 +02:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
await mock.waitForRoster(_converse, 'current');
const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@montague.lit';
await mock.openChatBoxFor(_converse, sender_jid)
const view = _converse.api.chatviews.get(sender_jid);
// Create enough messages so that there's a scrollbar.
const promises = [];
Don't smooth-scroll upon first appearance of the chat it's annoying in overlayed view-mode where the user might be navigating around the site. Fixes #2091
2020-06-30 10:59:11 +02:00
view.content.scrollTop = 0;
view.model.set('scrolled', true);
Use Karma as test runner
2020-04-22 13:11:48 +02:00
for (let i=0; i<20; i++) {
_converse.handleMessageStanza($msg({
from: sender_jid,
to: _converse.connection.jid,
type: 'chat',
id: _converse.connection.getUniqueId(),
}).c('body').t('Message: '+i).up()
.c('active', {'xmlns': 'http://jabber.org/protocol/chatstates'}).tree());
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
promises.push(new Promise(resolve => view.model.messages.once('rendered', resolve)));
Use Karma as test runner
2020-04-22 13:11:48 +02:00
}
await Promise.all(promises);
Don't smooth-scroll upon first appearance of the chat it's annoying in overlayed view-mode where the user might be navigating around the site. Fixes #2091
2020-06-30 10:59:11 +02:00
const indicator_el = view.el.querySelector('.new-msgs-indicator');
expect(u.isVisible(indicator_el)).toBeTruthy();
Use Karma as test runner
2020-04-22 13:11:48 +02:00
expect(view.model.get('scrolled')).toBe(true);
expect(view.content.scrollTop).toBe(0);
Don't smooth-scroll upon first appearance of the chat it's annoying in overlayed view-mode where the user might be navigating around the site. Fixes #2091
2020-06-30 10:59:11 +02:00
indicator_el.click();
expect(u.isVisible(indicator_el)).toBeFalsy();
expect(view.model.get('scrolled')).toBe(false);
Use Karma as test runner
2020-04-22 13:11:48 +02:00
done();
}));
Move message-related tests into their own file
2018-04-29 15:40:24 +02:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
it("is ignored if it's intended for a different resource and filter_by_resource is set to true",
mock.initConverse(
['rosterGroupsFetched'], {},
async function (done, _converse) {
Move message-related tests into their own file
2018-04-29 15:40:24 +02:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
await mock.waitForRoster(_converse, 'current');
await u.waitUntil(() => _converse.rosterview.el.querySelectorAll('.roster-group').length)
// Send a message from a different resource
Refactor so that message attributes are parsed early It's better to parse an incoming message stanza early, than to have all kinds of methods throughout the codebase that does querySelector etc. Firstly, it allows us to catch and report errors and malicious stanzas early on. It also simplifies programming because you don't need to try and remember how to properly parse a stanza, all the work is done upfront for you.
2020-04-24 17:33:32 +02:00
spyOn(converse.env.log, 'error');
Use Karma as test runner
2020-04-22 13:11:48 +02:00
spyOn(_converse.api.chatboxes, 'create').and.callThrough();
_converse.filter_by_resource = true;
const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@montague.lit';
let msg = $msg({
from: sender_jid,
to: _converse.bare_jid+"/some-other-resource",
type: 'chat',
id: u.getUniqueId()
}).c('body').t("This message will not be shown").up()
.c('active', {'xmlns': 'http://jabber.org/protocol/chatstates'}).tree();
await _converse.handleMessageStanza(msg);
Move message-related tests into their own file
2018-04-29 15:40:24 +02:00
Refactor so that message attributes are parsed early It's better to parse an incoming message stanza early, than to have all kinds of methods throughout the codebase that does querySelector etc. Firstly, it allows us to catch and report errors and malicious stanzas early on. It also simplifies programming because you don't need to try and remember how to properly parse a stanza, all the work is done upfront for you.
2020-04-24 17:33:32 +02:00
expect(converse.env.log.error.calls.all().pop().args[0]).toBe(
"Ignoring incoming message intended for a different resource: romeo@montague.lit/some-other-resource",
Use Karma as test runner
2020-04-22 13:11:48 +02:00
);
expect(_converse.api.chatboxes.create).not.toHaveBeenCalled();
_converse.filter_by_resource = false;
Move message-related tests into their own file
2018-04-29 15:40:24 +02:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
const message = "This message sent to a different resource will be shown";
msg = $msg({
from: sender_jid,
to: _converse.bare_jid+"/some-other-resource",
type: 'chat',
id: '134234623462346'
}).c('body').t(message).up()
.c('active', {'xmlns': 'http://jabber.org/protocol/chatstates'}).tree();
await _converse.handleMessageStanza(msg);
await u.waitUntil(() => _converse.chatboxviews.keys().length > 1, 1000);
const view = _converse.chatboxviews.get(sender_jid);
await u.waitUntil(() => view.model.messages.length);
expect(_converse.api.chatboxes.create).toHaveBeenCalled();
const last_message = await u.waitUntil(() => sizzle('.chat-content:last .chat-msg__text', view.el).pop());
const msg_txt = last_message.textContent;
expect(msg_txt).toEqual(message);
done();
}));
});
Move message-related tests into their own file
2018-04-29 15:40:24 +02:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
describe("which contains an OOB URL", function () {
Move message-related tests into their own file
2018-04-29 15:40:24 +02:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
it("will render audio from oob mp3 URLs",
mock.initConverse(
['rosterGroupsFetched', 'chatBoxesFetched'], {},
async function (done, _converse) {
await mock.waitForRoster(_converse, 'current', 1);
const contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@montague.lit';
await mock.openChatBoxFor(_converse, contact_jid);
const view = _converse.api.chatviews.get(contact_jid);
spyOn(view.model, 'sendMessage').and.callThrough();
Add test for groupchat message corrections
2018-07-07 14:20:49 +02:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
let stanza = u.toStanza(`
<message from="${contact_jid}"
type="chat"
to="romeo@montague.lit/orchard">
<body>Have you heard this funny audio?</body>
<x xmlns="jabber:x:oob"><url>https://montague.lit/audio.mp3</url></x>
</message>`)
_converse.connection._dataRecv(mock.createRequest(stanza));
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
await new Promise(resolve => view.model.messages.once('rendered', resolve));
Use Karma as test runner
2020-04-22 13:11:48 +02:00
await u.waitUntil(() => view.el.querySelectorAll('.chat-content .chat-msg audio').length, 1000);
let msg = view.el.querySelector('.chat-msg .chat-msg__text');
expect(msg.classList.length).toEqual(1);
expect(u.hasClass('chat-msg__text', msg)).toBe(true);
expect(msg.textContent).toEqual('Have you heard this funny audio?');
let media = view.el.querySelector('.chat-msg .chat-msg__media');
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
expect(media.innerHTML.replace(/<!---->/g, '').replace(/(\r\n|\n|\r)/gm, "").trim()).toEqual(
`<audio controls="" src="https://montague.lit/audio.mp3"></audio> `+
`<a target="_blank" rel="noopener" href="https://montague.lit/audio.mp3">Download audio file "audio.mp3"</a>`);
Use Karma as test runner
2020-04-22 13:11:48 +02:00
// If the <url> and <body> contents is the same, don't duplicate.
stanza = u.toStanza(`
<message from="${contact_jid}"
type="chat"
to="romeo@montague.lit/orchard">
<body>https://montague.lit/audio.mp3</body>
<x xmlns="jabber:x:oob"><url>https://montague.lit/audio.mp3</url></x>
</message>`);
_converse.connection._dataRecv(mock.createRequest(stanza));
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
await new Promise(resolve => view.model.messages.once('rendered', resolve));
Use Karma as test runner
2020-04-22 13:11:48 +02:00
msg = view.el.querySelector('.chat-msg:last-child .chat-msg__text');
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
expect(msg.innerHTML.replace(/<!---->/g, '')).toEqual('Have you heard this funny audio?'); // Emtpy
Use Karma as test runner
2020-04-22 13:11:48 +02:00
media = view.el.querySelector('.chat-msg:last-child .chat-msg__media');
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
expect(media.innerHTML.replace(/<!---->/g, '').replace(/(\r\n|\n|\r)/gm, "").trim()).toEqual(
`<audio controls="" src="https://montague.lit/audio.mp3"></audio> `+
Use Karma as test runner
2020-04-22 13:11:48 +02:00
`<a target="_blank" rel="noopener" href="https://montague.lit/audio.mp3">`+
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
`Download audio file "audio.mp3"</a>`);
Use Karma as test runner
2020-04-22 13:11:48 +02:00
done();
}));
Initial support for chat markers. Updates #324
2019-01-31 19:22:30 +01:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
it("will render video from oob mp4 URLs",
Make `converse.initialize` an `async` function - Combine all test init functions into `initConverse` - Use `async` functions in more tests - Replace `var` with `let` and `const` in more tests - New utils method `toStanza` which converts a string to a Node
2019-02-12 14:21:45 +01:00
mock.initConverse(
Use Karma as test runner
2020-04-22 13:11:48 +02:00
['rosterGroupsFetched', 'chatBoxesFetched'], {},
Initial support for chat markers. Updates #324
2019-01-31 19:22:30 +01:00
async function (done, _converse) {
Use Karma as test runner
2020-04-22 13:11:48 +02:00
await mock.waitForRoster(_converse, 'current', 1);
Use shakespearean character names in tests
2019-06-03 07:58:51 +02:00
const contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@montague.lit';
Use Karma as test runner
2020-04-22 13:11:48 +02:00
await mock.openChatBoxFor(_converse, contact_jid)
Use the API in tests
2019-02-22 21:43:49 +01:00
const view = _converse.api.chatviews.get(contact_jid);
Use Karma as test runner
2020-04-22 13:11:48 +02:00
spyOn(view.model, 'sendMessage').and.callThrough();
let stanza = u.toStanza(`
<message from="${contact_jid}"
type="chat"
to="romeo@montague.lit/orchard">
<body>Have you seen this funny video?</body>
<x xmlns="jabber:x:oob"><url>https://montague.lit/video.mp4</url></x>
Make `converse.initialize` an `async` function - Combine all test init functions into `initConverse` - Use `async` functions in more tests - Replace `var` with `let` and `const` in more tests - New utils method `toStanza` which converts a string to a Node
2019-02-12 14:21:45 +01:00
</message>`);
Use Karma as test runner
2020-04-22 13:11:48 +02:00
_converse.connection._dataRecv(mock.createRequest(stanza));
await u.waitUntil(() => view.el.querySelectorAll('.chat-content .chat-msg video').length, 2000)
let msg = view.el.querySelector('.chat-msg .chat-msg__text');
expect(msg.classList.length).toBe(1);
expect(msg.textContent).toEqual('Have you seen this funny video?');
let media = view.el.querySelector('.chat-msg .chat-msg__media');
expect(media.innerHTML.replace(/(\r\n|\n|\r)/gm, "")).toEqual(
`<!----><video controls="" preload="metadata" style="max-height: 50vh" src="https://montague.lit/video.mp4"></video><!---->`);
Initial support for chat markers. Updates #324
2019-01-31 19:22:30 +01:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
// If the <url> and <body> contents is the same, don't duplicate.
stanza = u.toStanza(`
<message from="${contact_jid}"
type="chat"
to="romeo@montague.lit/orchard">
<body>https://montague.lit/video.mp4</body>
<x xmlns="jabber:x:oob"><url>https://montague.lit/video.mp4</url></x>
</message>`);
_converse.connection._dataRecv(mock.createRequest(stanza));
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
await new Promise(resolve => view.model.messages.once('rendered', resolve));
Use Karma as test runner
2020-04-22 13:11:48 +02:00
msg = view.el.querySelector('.chat-msg:last-child .chat-msg__text');
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
expect(msg.innerHTML.replace(/<!---->/g, '')).toEqual('Have you seen this funny video?');
Use Karma as test runner
2020-04-22 13:11:48 +02:00
media = view.el.querySelector('.chat-msg:last-child .chat-msg__media');
expect(media.innerHTML.replace(/(\r\n|\n|\r)/gm, "")).toEqual(
`<!----><video controls="" preload="metadata" style="max-height: 50vh" src="https://montague.lit/video.mp4"></video><!---->`);
Initial support for chat markers. Updates #324
2019-01-31 19:22:30 +01:00
done();
}));
Use Karma as test runner
2020-04-22 13:11:48 +02:00
it("will render download links for files from oob URLs",
Don't send markers to someone not on your roster Updates #324
2019-02-13 19:31:05 +01:00
mock.initConverse(
Use Karma as test runner
2020-04-22 13:11:48 +02:00
['rosterGroupsFetched', 'chatBoxesFetched'], {},
Don't send markers to someone not on your roster Updates #324
2019-02-13 19:31:05 +01:00
async function (done, _converse) {
Use Karma as test runner
2020-04-22 13:11:48 +02:00
await mock.waitForRoster(_converse, 'current', 1);
const contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@montague.lit';
await mock.openChatBoxFor(_converse, contact_jid);
const view = _converse.api.chatviews.get(contact_jid);
spyOn(view.model, 'sendMessage').and.callThrough();
Don't send markers to someone not on your roster Updates #324
2019-02-13 19:31:05 +01:00
const stanza = u.toStanza(`
Use Karma as test runner
2020-04-22 13:11:48 +02:00
<message from="${contact_jid}"
type="chat"
to="romeo@montague.lit/orchard">
<body>Have you downloaded this funny file?</body>
<x xmlns="jabber:x:oob"><url>https://montague.lit/funny.pdf</url></x>
Don't send markers to someone not on your roster Updates #324
2019-02-13 19:31:05 +01:00
</message>`);
Use Karma as test runner
2020-04-22 13:11:48 +02:00
_converse.connection._dataRecv(mock.createRequest(stanza));
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
await new Promise(resolve => view.model.messages.once('rendered', resolve));
Use Karma as test runner
2020-04-22 13:11:48 +02:00
await u.waitUntil(() => view.el.querySelectorAll('.chat-content .chat-msg a').length, 1000);
const msg = view.el.querySelector('.chat-msg .chat-msg__text');
expect(u.hasClass('chat-msg__text', msg)).toBe(true);
expect(msg.textContent).toEqual('Have you downloaded this funny file?');
const media = view.el.querySelector('.chat-msg .chat-msg__media');
expect(media.innerHTML.replace(/(\r\n|\n|\r)/gm, "")).toEqual(
`<!----><a target="_blank" rel="noopener" href="https://montague.lit/funny.pdf"><!---->Download file "funny.pdf"<!----></a><!---->`);
Don't send markers to someone not on your roster Updates #324
2019-02-13 19:31:05 +01:00
done();
}));
Use Karma as test runner
2020-04-22 13:11:48 +02:00
it("will render images from oob URLs",
Make `converse.initialize` an `async` function - Combine all test init functions into `initConverse` - Use `async` functions in more tests - Replace `var` with `let` and `const` in more tests - New utils method `toStanza` which converts a string to a Node
2019-02-12 14:21:45 +01:00
mock.initConverse(
Use Karma as test runner
2020-04-22 13:11:48 +02:00
['rosterGroupsFetched', 'chatBoxesFetched'], {},
Initial support for chat markers. Updates #324
2019-01-31 19:22:30 +01:00
async function (done, _converse) {
Use Karma as test runner
2020-04-22 13:11:48 +02:00
const base_url = 'https://conversejs.org';
await mock.waitForRoster(_converse, 'current', 1);
Use shakespearean character names in tests
2019-06-03 07:58:51 +02:00
const contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@montague.lit';
Use Karma as test runner
2020-04-22 13:11:48 +02:00
await mock.openChatBoxFor(_converse, contact_jid)
Use the API in tests
2019-02-22 21:43:49 +01:00
const view = _converse.api.chatviews.get(contact_jid);
Use Karma as test runner
2020-04-22 13:11:48 +02:00
spyOn(view.model, 'sendMessage').and.callThrough();
const url = base_url+"/logo/conversejs-filled.svg";
Initial support for chat markers. Updates #324
2019-01-31 19:22:30 +01:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
const stanza = u.toStanza(`
<message from="${contact_jid}"
Initial support for chat markers. Updates #324
2019-01-31 19:22:30 +01:00
type="chat"
Use Karma as test runner
2020-04-22 13:11:48 +02:00
to="romeo@montague.lit/orchard">
<body>Have you seen this funny image?</body>
<x xmlns="jabber:x:oob"><url>${url}</url></x>
Make `converse.initialize` an `async` function - Combine all test init functions into `initConverse` - Use `async` functions in more tests - Replace `var` with `let` and `const` in more tests - New utils method `toStanza` which converts a string to a Node
2019-02-12 14:21:45 +01:00
</message>`);
Use Karma as test runner
2020-04-22 13:11:48 +02:00
_converse.connection._dataRecv(mock.createRequest(stanza));
Fix issue #2168
2020-09-29 13:38:44 +02:00
_converse.connection._dataRecv(mock.createRequest(stanza));
await new Promise(resolve => view.model.messages.once('rendered', resolve));
await u.waitUntil(() => view.el.querySelectorAll('.chat-content .chat-msg a').length, 1000);
Use Karma as test runner
2020-04-22 13:11:48 +02:00
const msg = view.el.querySelector('.chat-msg .chat-msg__text');
expect(u.hasClass('chat-msg__text', msg)).toBe(true);
expect(msg.textContent).toEqual('Have you seen this funny image?');
const media = view.el.querySelector('.chat-msg .chat-msg__media');
Add a `renderImage` directive which handles errors
2020-07-09 08:57:25 +02:00
expect(media.innerHTML.replace(/<!---->/g, '').replace(/(\r\n|\n|\r)/gm, "")).toEqual(
Fix issue #2168
2020-09-29 13:38:44 +02:00
`<a target="_blank" rel="noopener" href="${base_url}/logo/conversejs-filled.svg">`+
`Download image file "conversejs-filled.svg"</a>`);
Initial support for chat markers. Updates #324
2019-01-31 19:22:30 +01:00
done();
}));
});
Remove the need for require.js to run tests
2020-04-22 12:10:39 +02:00
});
Use Karma as test runner
2020-04-22 13:11:48 +02:00
describe("A XEP-0333 Chat Marker", function () {
it("is sent when a markable message is received from a roster contact",
mock.initConverse(
['rosterGroupsFetched'], {},
async function (done, _converse) {
await mock.waitForRoster(_converse, 'current', 1);
const contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@montague.lit';
await mock.openChatBoxFor(_converse, contact_jid);
const view = _converse.api.chatviews.get(contact_jid);
const msgid = u.getUniqueId();
const stanza = u.toStanza(`
<message from='${contact_jid}'
id='${msgid}'
type="chat"
to='${_converse.jid}'>
<body>My lord, dispatch; read o'er these articles.</body>
<markable xmlns='urn:xmpp:chat-markers:0'/>
</message>`);
const sent_stanzas = [];
spyOn(_converse.connection, 'send').and.callFake(s => sent_stanzas.push(s));
spyOn(view.model, 'sendMarker').and.callThrough();
_converse.connection._dataRecv(mock.createRequest(stanza));
Add support for the XEP-0333 `displayed` chat marker Credit for this work goes to @deleolajide
2020-06-01 17:30:20 +02:00
await u.waitUntil(() => view.model.sendMarker.calls.count() === 2);
Use Karma as test runner
2020-04-22 13:11:48 +02:00
expect(Strophe.serialize(sent_stanzas[0])).toBe(
`<message from="romeo@montague.lit/orchard" `+
`id="${sent_stanzas[0].nodeTree.getAttribute('id')}" `+
`to="${contact_jid}" type="chat" xmlns="jabber:client">`+
`<received id="${msgid}" xmlns="urn:xmpp:chat-markers:0"/>`+
`</message>`);
done();
}));
it("is not sent when a markable message is received from someone not on the roster",
mock.initConverse(
['rosterGroupsFetched'], {'allow_non_roster_messaging': true},
async function (done, _converse) {
await mock.waitForRoster(_converse, 'current', 0);
const contact_jid = 'someone@montague.lit';
const msgid = u.getUniqueId();
const stanza = u.toStanza(`
<message from='${contact_jid}'
id='${msgid}'
type="chat"
to='${_converse.jid}'>
<body>My lord, dispatch; read o'er these articles.</body>
<markable xmlns='urn:xmpp:chat-markers:0'/>
</message>`);
const sent_stanzas = [];
spyOn(_converse.connection, 'send').and.callFake(s => sent_stanzas.push(s));
await _converse.handleMessageStanza(stanza);
const sent_messages = sent_stanzas
.map(s => _.isElement(s) ? s : s.nodeTree)
.filter(e => e.nodeName === 'message');
Use the API to read settings
2020-06-03 09:57:14 +02:00
await u.waitUntil(() => sent_messages.length === 2);
Use Karma as test runner
2020-04-22 13:11:48 +02:00
expect(Strophe.serialize(sent_messages[0])).toBe(
`<message id="${sent_messages[0].getAttribute('id')}" to="${contact_jid}" type="chat" xmlns="jabber:client">`+
`<active xmlns="http://jabber.org/protocol/chatstates"/>`+
`<no-store xmlns="urn:xmpp:hints"/>`+
`<no-permanent-store xmlns="urn:xmpp:hints"/>`+
`</message>`
);
done();
}));
it("is ignored if it's a carbon copy of one that I sent from a different client",
mock.initConverse(
['rosterGroupsFetched'], {},
async function (done, _converse) {
await mock.waitForRoster(_converse, 'current', 1);
await mock.waitUntilDiscoConfirmed(_converse, _converse.bare_jid, [], [Strophe.NS.SID]);
const contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@montague.lit';
await mock.openChatBoxFor(_converse, contact_jid);
const view = _converse.api.chatviews.get(contact_jid);
let stanza = u.toStanza(`
<message xmlns="jabber:client"
to="${_converse.bare_jid}"
type="chat"
id="2e972ea0-0050-44b7-a830-f6638a2595b3"
from="${contact_jid}">
<body>😊</body>
<markable xmlns="urn:xmpp:chat-markers:0"/>
<origin-id xmlns="urn:xmpp:sid:0" id="2e972ea0-0050-44b7-a830-f6638a2595b3"/>
<stanza-id xmlns="urn:xmpp:sid:0" id="IxVDLJ0RYbWcWvqC" by="${_converse.bare_jid}"/>
</message>`);
_converse.connection._dataRecv(mock.createRequest(stanza));
Render chat messages as web components - Render chat content as a <converse-chat-content> component - Create new component for rendering the message body - Get rid of `showMessage` method
2020-05-15 14:33:31 +02:00
await new Promise(resolve => view.model.messages.once('rendered', resolve));
Use Karma as test runner
2020-04-22 13:11:48 +02:00
expect(view.el.querySelectorAll('.chat-msg').length).toBe(1);
expect(view.model.messages.length).toBe(1);
stanza = u.toStanza(
`<message xmlns="jabber:client" to="${_converse.bare_jid}" type="chat" from="${contact_jid}">
<sent xmlns="urn:xmpp:carbons:2">
<forwarded xmlns="urn:xmpp:forward:0">
<message xmlns="jabber:client" to="${contact_jid}" type="chat" from="${_converse.bare_jid}/other-resource">
<received xmlns="urn:xmpp:chat-markers:0" id="2e972ea0-0050-44b7-a830-f6638a2595b3"/>
<store xmlns="urn:xmpp:hints"/>
<stanza-id xmlns="urn:xmpp:sid:0" id="F4TC6CvHwzqRbeHb" by="${_converse.bare_jid}"/>
</message>
</forwarded>
</sent>
</message>`);
spyOn(_converse.api, "trigger").and.callThrough();
_converse.connection._dataRecv(mock.createRequest(stanza));
await u.waitUntil(() => _converse.api.trigger.calls.count(), 500);
expect(view.el.querySelectorAll('.chat-msg').length).toBe(1);
expect(view.model.messages.length).toBe(1);
done();
}));
});
Reference in New Issue Copy Permalink