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

1553 lines
83 KiB
JavaScript
Raw Normal View History

Remove global lodash
2020-12-29 12:52:53 +01:00
/*global mock, converse, _ */
Use Karma as test runner
2020-04-22 13:11:48 +02:00
Remove global lodash
2020-12-29 12:52:53 +01:00
const { Promise, Strophe, $msg, dayjs, sizzle } = converse.env;
Use Karma as test runner
2020-04-22 13:11:48 +02:00
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",
MUC: Fix error message logging
2021-01-29 11:08:28 +01:00
mock.initConverse(['chatBoxesFetched'], {},
Re-add support for a new messages indicator Fixes #2040
2020-06-01 16:05:00 +02:00
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'));
Work on turning chat views into custom elements The eventual goal is to avoid UI-related stanza processing if the relevant chats aren't in the DOM. With the current architecture, chatboxes are created (and the stanzas related to them processed) even if `#conversejs` isn't in the DOM. * Initial work on making controlbox an element * Create a shared base class * Ceate ChatBoxViews proxy * Update sass now that certain classes are moved to converse-chats element
2020-12-08 12:54:14 +01:00
const msg_el = await u.waitUntil(() => view.querySelector('converse-chat-message'));
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
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'));
Work on turning chat views into custom elements The eventual goal is to avoid UI-related stanza processing if the relevant chats aren't in the DOM. With the current architecture, chatboxes are created (and the stanzas related to them processed) even if `#conversejs` isn't in the DOM. * Initial work on making controlbox an element * Create a shared base class * Ceate ChatBoxViews proxy * Update sass now that certain classes are moved to converse-chats element
2020-12-08 12:54:14 +01:00
await u.waitUntil(() => view.querySelectorAll('converse-chat-message').length === 2);
const last_msg_el = view.querySelector('converse-chat-message:last-child');
Re-add support for a new messages indicator Fixes #2040
2020-06-01 16:05:00 +02:00
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(
MUC: Fix error message logging
2021-01-29 11:08:28 +01:00
['chatBoxesFetched'], {},
Use Karma as test runner
2020-04-22 13:11:48 +02:00
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",
MUC: Fix error message logging
2021-01-29 11:08:28 +01:00
mock.initConverse([], {}, async function (done, _converse) {
Use Karma as test runner
2020-04-22 13:11:48 +02:00
await mock.waitForRoster(_converse, 'current');
await mock.openControlBox(_converse);
const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@montague.lit';
MUC: Fix error message logging
2021-01-29 11:08:28 +01:00
const rosterview = document.querySelector('converse-roster');
await u.waitUntil(() => rosterview.querySelectorAll('.roster-group').length)
Use Karma as test runner
2020-04-22 13:11:48 +02:00
_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 `converse-chat-content` declaratively
2021-02-08 11:27:42 +01:00
await u.waitUntil(() => view.querySelectorAll('.chat-msg').length === 2);
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 `converse-chat-content` declaratively
2021-02-08 11:27:42 +01:00
await u.waitUntil(() => view.querySelectorAll('.chat-msg').length === 3);
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 `converse-chat-content` declaratively
2021-02-08 11:27:42 +01:00
await u.waitUntil(() => view.querySelectorAll('.chat-msg').length === 4);
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 `converse-chat-content` declaratively
2021-02-08 11:27:42 +01:00
await u.waitUntil(() => view.querySelectorAll('.chat-msg').length === 5);
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 `converse-chat-content` declaratively
2021-02-08 11:27:42 +01:00
await u.waitUntil(() => view.querySelectorAll('.chat-msg').length === 6);
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);
Work on turning chat views into custom elements The eventual goal is to avoid UI-related stanza processing if the relevant chats aren't in the DOM. With the current architecture, chatboxes are created (and the stanzas related to them processed) even if `#conversejs` isn't in the DOM. * Initial work on making controlbox an element * Create a shared base class * Ceate ChatBoxViews proxy * Update sass now that certain classes are moved to converse-chats element
2020-12-08 12:54:14 +01:00
const csntext = await u.waitUntil(() => view.querySelector('.chat-content__notifications').textContent);
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(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();
Render `converse-chat-content` declaratively
2021-02-08 11:27:42 +01:00
Use Karma as test runner
2020-04-22 13:11:48 +02:00
await _converse.handleMessageStanza(msg);
Render `converse-chat-content` declaratively
2021-02-08 11:27:42 +01:00
await u.waitUntil(() => view.querySelectorAll('.chat-msg').length === 7);
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",
MUC: Fix error message logging
2021-01-29 11:08:28 +01:00
mock.initConverse([], {}, 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",
MUC: Fix error message logging
2021-01-29 11:08:28 +01:00
mock.initConverse([], {}, async function (done, _converse) {
Use Karma as test runner
2020-04-22 13:11:48 +02:00
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",
MUC: Fix error message logging
2021-01-29 11:08:28 +01:00
mock.initConverse([], {}, async function (done, _converse) {
Use Karma as test runner
2020-04-22 13:11:48 +02:00
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
Work on turning chat views into custom elements The eventual goal is to avoid UI-related stanza processing if the relevant chats aren't in the DOM. With the current architecture, chatboxes are created (and the stanzas related to them processed) even if `#conversejs` isn't in the DOM. * Initial work on making controlbox an element * Create a shared base class * Ceate ChatBoxViews proxy * Update sass now that certain classes are moved to converse-chats element
2020-12-08 12:54:14 +01:00
const msg_el = await u.waitUntil(() => view.querySelector('.chat-content .chat-msg .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_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",
MUC: Fix error message logging
2021-01-29 11:08:28 +01:00
mock.initConverse([], {}, async function (done, _converse) {
Use Karma as test runner
2020-04-22 13:11:48 +02:00
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",
MUC: Fix error message logging
2021-01-29 11:08:28 +01:00
mock.initConverse(['chatBoxesFetched'], {}, async function (done, _converse) {
Use Karma as test runner
2020-04-22 13:11:48 +02:00
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';
MUC: Fix error message logging
2021-01-29 11:08:28 +01:00
const rosterview = document.querySelector('converse-roster');
await u.waitUntil(() => rosterview.querySelectorAll('.roster-group').length);
Use Karma as test runner
2020-04-22 13:11:48 +02:00
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 `converse-chat-content` declaratively
2021-02-08 11:27:42 +01:00
await u.waitUntil(() => view.querySelectorAll('.chat-msg').length);
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')
Render `converse-chat-content` declaratively
2021-02-08 11:27:42 +01:00
expect(view.querySelector('.chat-msg .chat-msg__text').textContent).toEqual(message);
expect(view.querySelector('.chat-msg__time').textContent.match(/^[0-9][0-9]:[0-9][0-9]/)).toBeTruthy();
expect(view.querySelector('span.chat-msg__author').textContent.trim()).toBe('Juliet Capulet');
Use Karma as test runner
2020-04-22 13:11:48 +02:00
Render `converse-chat-content` declaratively
2021-02-08 11:27:42 +01:00
expect(view.querySelectorAll('.date-separator').length).toEqual(1);
let day = view.querySelector('.date-separator');
Use Karma as test runner
2020-04-22 13:11:48 +02:00
expect(day.getAttribute('class')).toEqual('message date-separator');
expect(day.getAttribute('data-isodate')).toEqual(dayjs(one_day_ago.startOf('day')).toISOString());
Render `converse-chat-content` declaratively
2021-02-08 11:27:42 +01:00
let time = view.querySelector('time.separator-text');
Use Karma as test runner
2020-04-22 13:11:48 +02:00
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 `converse-chat-content` declaratively
2021-02-08 11:27:42 +01:00
await u.waitUntil(() => view.querySelectorAll('.chat-msg').length === 2);
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.
Render `converse-chat-content` declaratively
2021-02-08 11:27:42 +01:00
expect(view.querySelectorAll('time.separator-text').length).toEqual(2); // There are now two time elements
Use Karma as test runner
2020-04-22 13:11:48 +02:00
const message_date = new Date();
Render `converse-chat-content` declaratively
2021-02-08 11:27:42 +01:00
day = sizzle('.date-separator:last', view);
Use Karma as test runner
2020-04-22 13:11:48 +02:00
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());
Render `converse-chat-content` declaratively
2021-02-08 11:27:42 +01:00
time = sizzle('time.separator-text:last', view).pop();
Use Karma as test runner
2020-04-22 13:11:48 +02:00
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);
Render `converse-chat-content` declaratively
2021-02-08 11:27:42 +01:00
const msg_txt = sizzle('.chat-msg:last .chat-msg__text', view).pop().textContent;
Use Karma as test runner
2020-04-22 13:11:48 +02:00
expect(msg_txt).toEqual(message);
Render `converse-chat-content` declaratively
2021-02-08 11:27:42 +01:00
expect(view.querySelector('converse-chat-message:last-child .chat-msg__text').textContent).toEqual(message);
expect(view.querySelector('converse-chat-message:last-child .chat-msg__time').textContent.match(/^[0-9][0-9]:[0-9][0-9]/)).toBeTruthy();
expect(view.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",
MUC: Fix error message logging
2021-01-29 11:08:28 +01:00
mock.initConverse(['chatBoxesFetched'], {}, async function (done, _converse) {
Use Karma as test runner
2020-04-22 13:11:48 +02:00
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();
Remove reference to view.el in tests
2021-02-09 16:40:59 +01:00
const msg = sizzle('.chat-content .chat-msg:last .chat-msg__text', view).pop();
Use Karma as test runner
2020-04-22 13:11:48 +02:00
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",
MUC: Fix error message logging
2021-01-29 11:08:28 +01:00
mock.initConverse(['chatBoxesFetched'], {}, async function (done, _converse) {
Use Karma as test runner
2020-04-22 13:11:48 +02:00
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();
Turn the bottom panel into a custom element
2021-02-11 15:05:04 +01:00
await mock.sendMessage(view, message);
Use Karma as test runner
2020-04-22 13:11:48 +02:00
expect(view.model.sendMessage).toHaveBeenCalled();
Render `converse-chat-content` declaratively
2021-02-08 11:27:42 +01:00
await u.waitUntil(() => view.querySelectorAll('.chat-msg__text').length);
Remove reference to view.el in tests
2021-02-09 16:40:59 +01:00
const msg = sizzle('.chat-content .chat-msg:last .chat-msg__text', view).pop();
Use Karma as test runner
2020-04-22 13:11:48 +02:00
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",
MUC: Fix error message logging
2021-01-29 11:08:28 +01:00
mock.initConverse(['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';
Turn the bottom panel into a custom element
2021-02-11 15:05:04 +01:00
await mock.sendMessage(view, message);
Render `converse-chat-content` declaratively
2021-02-08 11:27:42 +01:00
await u.waitUntil(() => view.querySelectorAll('.chat-msg__text').length);
Remove reference to view.el in tests
2021-02-09 16:40:59 +01:00
let msg = sizzle('.chat-content .chat-msg:last .chat-msg__text', view).pop();
Removes query params from urls as set in config
2020-08-27 23:26:51 +02:00
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';
Turn the bottom panel into a custom element
2021-02-11 15:05:04 +01:00
await mock.sendMessage(view, message);
Render `converse-chat-content` declaratively
2021-02-08 11:27:42 +01:00
await u.waitUntil(() => view.querySelectorAll('.chat-msg__text').length === 2);
Remove reference to view.el in tests
2021-02-09 16:40:59 +01:00
msg = sizzle('.chat-content .chat-msg:last .chat-msg__text', view).pop();
Turn the bottom panel into a custom element
2021-02-11 15:05:04 +01:00
expect(msg.textContent).toEqual(message);
Test string value for `filter_url_query_params`
2020-09-01 07:26:20 +02:00
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();
}));
MUC: Fix error message logging
2021-01-29 11:08:28 +01:00
it("will render newlines", mock.initConverse(['chatBoxesFetched'], {}, async function (done, _converse) {
Use Karma as test runner
2020-04-22 13:11:48 +02:00
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 `converse-chat-content` declaratively
2021-02-08 11:27:42 +01:00
await u.waitUntil(() => view.querySelectorAll('.chat-msg__text').length);
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.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 `converse-chat-content` declaratively
2021-02-08 11:27:42 +01:00
await u.waitUntil(() => view.querySelectorAll('.chat-msg__text').length === 2);
const text = view.content.querySelector('converse-chat-message:last-child .chat-msg__text').innerHTML.replace(/<!---->/g, '');
expect(text).toBe('Hey\n\u200B\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 `converse-chat-content` declaratively
2021-02-08 11:27:42 +01:00
await u.waitUntil(() => view.querySelectorAll('.chat-msg__text').length === 3);
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.querySelector('converse-chat-message:last-child .chat-msg__text').innerHTML.replace(/<!---->/g, '')).toBe('Hey\nHave you heard\nthe news?');
Don't collapse newlines. This causes index offset issues with any rich elements in the message. We could try to fix the offsets, or alternatively replace the collapsed newlines with spaces (to maintain the original offsets), but I don't think it's worth the effort since I'm not sure that it's a good idea to collapse newlines in the first place.
2021-01-18 11:27:01 +01:00
stanza = u.toStanza(`
<message from="${contact_jid}"
type="chat"
to="romeo@montague.lit/orchard">
<body>Hey\nHave you heard\n\n\nthe news?\nhttps://conversejs.org</body>
</message>`);
_converse.connection._dataRecv(mock.createRequest(stanza));
Render `converse-chat-content` declaratively
2021-02-08 11:27:42 +01:00
await u.waitUntil(() => view.querySelectorAll('.chat-msg__text').length === 4);
Decided to still collapse newlines... and to solve the offset issue by replacing excessive newlines with the zero-width space unicode character.
2021-01-18 12:11:48 +01:00
await u.waitUntil(() => {
const text = view.content.querySelector('converse-chat-message:last-child .chat-msg__text').innerHTML.replace(/<!---->/g, '');
return text === 'Hey\nHave you heard\n\u200B\nthe news?\n<a target="_blank" rel="noopener" href="https://conversejs.org/">https://conversejs.org</a>';
});
Use Karma as test runner
2020-04-22 13:11:48 +02:00
done();
}));
MUC: Fix error message logging
2021-01-29 11:08:28 +01:00
it("will render images from their URLs", mock.initConverse(['chatBoxesFetched'], {}, async function (done, _converse) {
Use Karma as test runner
2020-04-22 13:11:48 +02:00
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();
Turn the bottom panel into a custom element
2021-02-11 15:05:04 +01:00
await mock.sendMessage(view, message);
Work on turning chat views into custom elements The eventual goal is to avoid UI-related stanza processing if the relevant chats aren't in the DOM. With the current architecture, chatboxes are created (and the stanzas related to them processed) even if `#conversejs` isn't in the DOM. * Initial work on making controlbox an element * Create a shared base class * Ceate ChatBoxViews proxy * Update sass now that certain classes are moved to converse-chats element
2020-12-08 12:54:14 +01:00
await u.waitUntil(() => view.querySelectorAll('.chat-content .chat-image').length, 1000)
Use Karma as test runner
2020-04-22 13:11:48 +02:00
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";
Turn the bottom panel into a custom element
2021-02-11 15:05:04 +01:00
await mock.sendMessage(view, message);
Work on turning chat views into custom elements The eventual goal is to avoid UI-related stanza processing if the relevant chats aren't in the DOM. With the current architecture, chatboxes are created (and the stanzas related to them processed) even if `#conversejs` isn't in the DOM. * Initial work on making controlbox an element * Create a shared base class * Ceate ChatBoxViews proxy * Update sass now that certain classes are moved to converse-chats element
2020-12-08 12:54:14 +01:00
await u.waitUntil(() => view.querySelectorAll('.chat-content .chat-image').length === 2, 1000);
Use Karma as test runner
2020-04-22 13:11:48 +02:00
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";
Turn the bottom panel into a custom element
2021-02-11 15:05:04 +01:00
await mock.sendMessage(view, message);
Work on turning chat views into custom elements The eventual goal is to avoid UI-related stanza processing if the relevant chats aren't in the DOM. With the current architecture, chatboxes are created (and the stanzas related to them processed) even if `#conversejs` isn't in the DOM. * Initial work on making controlbox an element * Create a shared base class * Ceate ChatBoxViews proxy * Update sass now that certain classes are moved to converse-chats element
2020-12-08 12:54:14 +01:00
await u.waitUntil(() => view.querySelectorAll('.chat-content .chat-image').length === 4, 1000);
Use Karma as test runner
2020-04-22 13:11:48 +02:00
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';
Turn the bottom panel into a custom element
2021-02-11 15:05:04 +01:00
await mock.sendMessage(view, message);
Work on turning chat views into custom elements The eventual goal is to avoid UI-related stanza processing if the relevant chats aren't in the DOM. With the current architecture, chatboxes are created (and the stanzas related to them processed) even if `#conversejs` isn't in the DOM. * Initial work on making controlbox an element * Create a shared base class * Ceate ChatBoxViews proxy * Update sass now that certain classes are moved to converse-chats element
2020-12-08 12:54:14 +01:00
await u.waitUntil(() => view.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
Work on turning chat views into custom elements The eventual goal is to avoid UI-related stanza processing if the relevant chats aren't in the DOM. With the current architecture, chatboxes are created (and the stanzas related to them processed) even if `#conversejs` isn't in the DOM. * Initial work on making controlbox an element * Create a shared base class * Ceate ChatBoxViews proxy * Update sass now that certain classes are moved to converse-chats element
2020-12-08 12:54:14 +01:00
await u.waitUntil(() => Array.from(view.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(
MUC: Fix error message logging
2021-01-29 11:08:28 +01:00
['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();
Turn the bottom panel into a custom element
2021-02-11 15:05:04 +01:00
await mock.sendMessage(view, message);
Work on turning chat views into custom elements The eventual goal is to avoid UI-related stanza processing if the relevant chats aren't in the DOM. With the current architecture, chatboxes are created (and the stanzas related to them processed) even if `#conversejs` isn't in the DOM. * Initial work on making controlbox an element * Create a shared base class * Ceate ChatBoxViews proxy * Update sass now that certain classes are moved to converse-chats element
2020-12-08 12:54:14 +01:00
await u.waitUntil(() => view.querySelectorAll('.chat-content .chat-msg').length === 1);
Properly test for `show_images_inline`
2020-08-31 20:58:39 +02:00
adds option to whitelist image domains
2020-08-28 01:05:12 +02:00
message = base_url+"/logo/conversejs-filled.svg";
Turn the bottom panel into a custom element
2021-02-11 15:05:04 +01:00
await mock.sendMessage(view, message);
Work on turning chat views into custom elements The eventual goal is to avoid UI-related stanza processing if the relevant chats aren't in the DOM. With the current architecture, chatboxes are created (and the stanzas related to them processed) even if `#conversejs` isn't in the DOM. * Initial work on making controlbox an element * Create a shared base class * Ceate ChatBoxViews proxy * Update sass now that certain classes are moved to converse-chats element
2020-12-08 12:54:14 +01:00
await u.waitUntil(() => view.querySelectorAll('.chat-content .chat-msg').length === 2, 1000);
await u.waitUntil(() => view.querySelectorAll('.chat-content .chat-image').length === 1, 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(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(
MUC: Fix error message logging
2021-01-29 11:08:28 +01:00
['chatBoxesFetched'], {},
Add a `renderImage` directive which handles errors
2020-07-09 08:57:25 +02:00
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();
Turn the bottom panel into a custom element
2021-02-11 15:05:04 +01:00
await mock.sendMessage(view, message);
Work on turning chat views into custom elements The eventual goal is to avoid UI-related stanza processing if the relevant chats aren't in the DOM. With the current architecture, chatboxes are created (and the stanzas related to them processed) even if `#conversejs` isn't in the DOM. * Initial work on making controlbox an element * Create a shared base class * Ceate ChatBoxViews proxy * Update sass now that certain classes are moved to converse-chats element
2020-12-08 12:54:14 +01:00
await u.waitUntil(() => view.querySelectorAll('.chat-content .chat-image').length, 1000)
Add a `renderImage` directive which handles errors
2020-07-09 08:57:25 +02:00
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();
}));
Fixes infinite loop bug when appending .png to allowed image urls
2021-02-08 22:55:04 +01:00
it("will fall back to rendering URLs that match image_urls_regex as URLs",
mock.initConverse(
['rosterGroupsFetched', 'chatBoxesFetched'], {
'show_images_inline': ['twimg.com'],
'image_urls_regex': /^https?:\/\/(www.)?(pbs\.twimg\.com\/)/i
},
async function (done, _converse) {
await mock.waitForRoster(_converse, 'current');
const message = "https://pbs.twimg.com/media/string?format=jpg&name=small";
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();
Turn the bottom panel into a custom element
2021-02-11 15:05:04 +01:00
await mock.sendMessage(view, message);
Fixes infinite loop bug when appending .png to allowed image urls
2021-02-08 22:55:04 +01:00
expect(view.model.sendMessage).toHaveBeenCalled();
Remove reference to view.el in tests
2021-02-09 16:40:59 +01:00
await u.waitUntil(() => view.querySelector('.chat-content .chat-msg'), 1000);
const msg = view.querySelector('.chat-content .chat-msg .chat-msg__text');
Fixes infinite loop bug when appending .png to allowed image urls
2021-02-08 22:55:04 +01:00
await u.waitUntil(() => msg.innerHTML.replace(/<!---->/g, '').trim() ==
`<a target="_blank" rel="noopener" href="https://pbs.twimg.com/media/string?format=jpg&amp;name=small">https://pbs.twimg.com/media/string?format=jpg&amp;name=small</a>`, 1000);
done();
}));
Use Karma as test runner
2020-04-22 13:11:48 +02:00
it("will render the message time as configured",
mock.initConverse(
MUC: Fix error message logging
2021-01-29 11:08:28 +01:00
['chatBoxesFetched'], {},
Use Karma as test runner
2020-04-22 13:11:48 +02:00
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];
Work on turning chat views into custom elements The eventual goal is to avoid UI-related stanza processing if the relevant chats aren't in the DOM. With the current architecture, chatboxes are created (and the stanzas related to them processed) even if `#conversejs` isn't in the DOM. * Initial work on making controlbox an element * Create a shared base class * Ceate ChatBoxViews proxy * Update sass now that certain classes are moved to converse-chats element
2020-12-08 12:54:14 +01:00
const msg_author = view.querySelector('.chat-content .chat-msg:last-child .chat-msg__author');
Use Karma as test runner
2020-04-22 13:11:48 +02:00
expect(msg_author.textContent.trim()).toBe('Romeo Montague');
Work on turning chat views into custom elements The eventual goal is to avoid UI-related stanza processing if the relevant chats aren't in the DOM. With the current architecture, chatboxes are created (and the stanzas related to them processed) even if `#conversejs` isn't in the DOM. * Initial work on making controlbox an element * Create a shared base class * Ceate ChatBoxViews proxy * Update sass now that certain classes are moved to converse-chats element
2020-12-08 12:54:14 +01:00
const msg_time = view.querySelector('.chat-content .chat-msg:last-child .chat-msg__time');
Use Karma as test runner
2020-04-22 13:11:48 +02:00
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(
MUC: Fix error message logging
2021-01-29 11:08:28 +01:00
[], {'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;
MUC: Fix error message logging
2021-01-29 11:08:28 +01:00
const rosterview = document.querySelector('converse-roster');
await u.waitUntil(() => rosterview.querySelectorAll('.roster-group').length, 300);
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';
_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(
MUC: Fix error message logging
2021-01-29 11:08:28 +01:00
['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]);
Remove reference to view.el in tests
2021-02-09 16:40:59 +01:00
expect(sizzle('.chat-content .chat-msg:last .chat-msg__text', view).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(
MUC: Fix error message logging
2021-01-29 11:08:28 +01:00
['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());
Remove reference to view.el in tests
2021-02-09 16:40:59 +01:00
const message_el = sizzle('.chat-content .chat-msg:last .chat-msg__text', view).pop();
Use Karma as test runner
2020-04-22 13:11:48 +02:00
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",
MUC: Fix error message logging
2021-01-29 11:08:28 +01:00
mock.initConverse([], {}, 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);
MUC: Fix error message logging
2021-01-29 11:08:28 +01:00
const rosterview = document.querySelector('converse-roster');
await u.waitUntil(() => rosterview.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",
MUC: Fix error message logging
2021-01-29 11:08:28 +01:00
mock.initConverse([], {}, 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);
MUC: Fix error message logging
2021-01-29 11:08:28 +01:00
const rosterview = document.querySelector('converse-roster');
await u.waitUntil(() => rosterview.querySelectorAll('.roster-group').length, 300);
Use Karma as test runner
2020-04-22 13:11:48 +02:00
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",
MUC: Fix error message logging
2021-01-29 11:08:28 +01:00
mock.initConverse([], {'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 `converse-chat-content` declaratively
2021-02-08 11:27:42 +01:00
await u.waitUntil(() => view.querySelectorAll('.chat-msg').length);
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);
Work on turning chat views into custom elements The eventual goal is to avoid UI-related stanza processing if the relevant chats aren't in the DOM. With the current architecture, chatboxes are created (and the stanzas related to them processed) even if `#conversejs` isn't in the DOM. * Initial work on making controlbox an element * Create a shared base class * Ceate ChatBoxViews proxy * Update sass now that certain classes are moved to converse-chats element
2020-12-08 12:54:14 +01:00
await u.waitUntil(() => view.querySelector('.chat-msg__author').textContent.trim() === 'Mercutio');
let author_el = view.querySelector('.chat-msg__author');
Use Karma as test runner
2020-04-22 13:11:48 +02:00
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])
Work on turning chat views into custom elements The eventual goal is to avoid UI-related stanza processing if the relevant chats aren't in the DOM. With the current architecture, chatboxes are created (and the stanzas related to them processed) even if `#conversejs` isn't in the DOM. * Initial work on making controlbox an element * Create a shared base class * Ceate ChatBoxViews proxy * Update sass now that certain classes are moved to converse-chats element
2020-12-08 12:54:14 +01:00
author_el = view.querySelector('.chat-msg__author');
Render `converse-chat-content` declaratively
2021-02-08 11:27:42 +01:00
expect(author_el.textContent.trim().includes('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(
MUC: Fix error message logging
2021-01-29 11:08:28 +01:00
[], {'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 `converse-chat-content` declaratively
2021-02-08 11:27:42 +01:00
await u.waitUntil(() => view.querySelectorAll('.chat-msg').length);
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
Work on turning chat views into custom elements The eventual goal is to avoid UI-related stanza processing if the relevant chats aren't in the DOM. With the current architecture, chatboxes are created (and the stanzas related to them processed) even if `#conversejs` isn't in the DOM. * Initial work on making controlbox an element * Create a shared base class * Ceate ChatBoxViews proxy * Update sass now that certain classes are moved to converse-chats element
2020-12-08 12:54:14 +01:00
await u.waitUntil(() => view.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",
MUC: Fix error message logging
2021-01-29 11:08:28 +01:00
mock.initConverse(['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', 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 `converse-chat-content` declaratively
2021-02-08 11:27:42 +01:00
await u.waitUntil(() => view.querySelectorAll('.chat-msg').length);
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 `converse-chat-content` declaratively
2021-02-08 11:27:42 +01:00
await u.waitUntil(() => view.querySelectorAll('.chat-msg__error').length === 3);
Makes message with errors non-editable (#2089) * Makes message with errors non-editable
2020-06-25 10:22:44 +02:00
Render `converse-chat-content` declaratively
2021-02-08 11:27:42 +01:00
// Ensure messages with error are not editable or retractable
await u.waitUntil(() => !view.model.messages.models.reduce((acc, m) => acc || m.get('editable'), false), 1000);
view.querySelectorAll('.chat-msg').forEach(el => {
expect(el.querySelector('.chat-msg__action-edit')).toBe(null)
expect(el.querySelector('.chat-msg__action-retract')).toBe(null)
Makes message with errors non-editable (#2089) * Makes message with errors non-editable
2020-06-25 10:22:44 +02:00
})
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(
MUC: Fix error message logging
2021-01-29 11:08:28 +01:00
['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);
Render `converse-chat-content` declaratively
2021-02-08 11:27:42 +01:00
await u.waitUntil(() => view.querySelectorAll('.chat-msg__text').length);
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",
MUC: Fix error message logging
2021-01-29 11:08:28 +01:00
mock.initConverse(['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);
Work on turning chat views into custom elements The eventual goal is to avoid UI-related stanza processing if the relevant chats aren't in the DOM. With the current architecture, chatboxes are created (and the stanzas related to them processed) even if `#conversejs` isn't in the DOM. * Initial work on making controlbox an element * Create a shared base class * Ceate ChatBoxViews proxy * Update sass now that certain classes are moved to converse-chats element
2020-12-08 12:54:14 +01:00
const indicator_el = view.querySelector('.new-msgs-indicator');
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
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",
MUC: Fix error message logging
2021-01-29 11:08:28 +01:00
mock.initConverse([], {}, 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');
MUC: Fix error message logging
2021-01-29 11:08:28 +01:00
const rosterview = document.querySelector('converse-roster');
await u.waitUntil(() => rosterview.querySelectorAll('.roster-group').length)
Use Karma as test runner
2020-04-22 13:11:48 +02:00
// 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();
Remove reference to view.el in tests
2021-02-09 16:40:59 +01:00
const last_message = await u.waitUntil(() => sizzle('.chat-content:last .chat-msg__text', view).pop());
Use Karma as test runner
2020-04-22 13:11:48 +02:00
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(
MUC: Fix error message logging
2021-01-29 11:08:28 +01:00
['chatBoxesFetched'], {},
Use Karma as test runner
2020-04-22 13:11:48 +02:00
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));
Work on turning chat views into custom elements The eventual goal is to avoid UI-related stanza processing if the relevant chats aren't in the DOM. With the current architecture, chatboxes are created (and the stanzas related to them processed) even if `#conversejs` isn't in the DOM. * Initial work on making controlbox an element * Create a shared base class * Ceate ChatBoxViews proxy * Update sass now that certain classes are moved to converse-chats element
2020-12-08 12:54:14 +01:00
await u.waitUntil(() => view.querySelectorAll('.chat-content .chat-msg audio').length, 1000);
let msg = view.querySelector('.chat-msg .chat-msg__text');
Use Karma as test runner
2020-04-22 13:11:48 +02:00
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?');
Work on turning chat views into custom elements The eventual goal is to avoid UI-related stanza processing if the relevant chats aren't in the DOM. With the current architecture, chatboxes are created (and the stanzas related to them processed) even if `#conversejs` isn't in the DOM. * Initial work on making controlbox an element * Create a shared base class * Ceate ChatBoxViews proxy * Update sass now that certain classes are moved to converse-chats element
2020-12-08 12:54:14 +01:00
let media = view.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));
Work on turning chat views into custom elements The eventual goal is to avoid UI-related stanza processing if the relevant chats aren't in the DOM. With the current architecture, chatboxes are created (and the stanzas related to them processed) even if `#conversejs` isn't in the DOM. * Initial work on making controlbox an element * Create a shared base class * Ceate ChatBoxViews proxy * Update sass now that certain classes are moved to converse-chats element
2020-12-08 12:54:14 +01:00
msg = view.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
Work on turning chat views into custom elements The eventual goal is to avoid UI-related stanza processing if the relevant chats aren't in the DOM. With the current architecture, chatboxes are created (and the stanzas related to them processed) even if `#conversejs` isn't in the DOM. * Initial work on making controlbox an element * Create a shared base class * Ceate ChatBoxViews proxy * Update sass now that certain classes are moved to converse-chats element
2020-12-08 12:54:14 +01:00
media = view.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(
MUC: Fix error message logging
2021-01-29 11:08:28 +01:00
['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));
Work on turning chat views into custom elements The eventual goal is to avoid UI-related stanza processing if the relevant chats aren't in the DOM. With the current architecture, chatboxes are created (and the stanzas related to them processed) even if `#conversejs` isn't in the DOM. * Initial work on making controlbox an element * Create a shared base class * Ceate ChatBoxViews proxy * Update sass now that certain classes are moved to converse-chats element
2020-12-08 12:54:14 +01:00
await u.waitUntil(() => view.querySelectorAll('.chat-content .chat-msg video').length, 2000)
let msg = view.querySelector('.chat-msg .chat-msg__text');
Use Karma as test runner
2020-04-22 13:11:48 +02:00
expect(msg.classList.length).toBe(1);
expect(msg.textContent).toEqual('Have you seen this funny video?');
Work on turning chat views into custom elements The eventual goal is to avoid UI-related stanza processing if the relevant chats aren't in the DOM. With the current architecture, chatboxes are created (and the stanzas related to them processed) even if `#conversejs` isn't in the DOM. * Initial work on making controlbox an element * Create a shared base class * Ceate ChatBoxViews proxy * Update sass now that certain classes are moved to converse-chats element
2020-12-08 12:54:14 +01:00
let media = view.querySelector('.chat-msg .chat-msg__media');
Use Karma as test runner
2020-04-22 13:11:48 +02:00
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));
Work on turning chat views into custom elements The eventual goal is to avoid UI-related stanza processing if the relevant chats aren't in the DOM. With the current architecture, chatboxes are created (and the stanzas related to them processed) even if `#conversejs` isn't in the DOM. * Initial work on making controlbox an element * Create a shared base class * Ceate ChatBoxViews proxy * Update sass now that certain classes are moved to converse-chats element
2020-12-08 12:54:14 +01:00
msg = view.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?');
Work on turning chat views into custom elements The eventual goal is to avoid UI-related stanza processing if the relevant chats aren't in the DOM. With the current architecture, chatboxes are created (and the stanzas related to them processed) even if `#conversejs` isn't in the DOM. * Initial work on making controlbox an element * Create a shared base class * Ceate ChatBoxViews proxy * Update sass now that certain classes are moved to converse-chats element
2020-12-08 12:54:14 +01:00
media = view.querySelector('.chat-msg:last-child .chat-msg__media');
Use Karma as test runner
2020-04-22 13:11:48 +02:00
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(
MUC: Fix error message logging
2021-01-29 11:08:28 +01:00
['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));
Work on turning chat views into custom elements The eventual goal is to avoid UI-related stanza processing if the relevant chats aren't in the DOM. With the current architecture, chatboxes are created (and the stanzas related to them processed) even if `#conversejs` isn't in the DOM. * Initial work on making controlbox an element * Create a shared base class * Ceate ChatBoxViews proxy * Update sass now that certain classes are moved to converse-chats element
2020-12-08 12:54:14 +01:00
await u.waitUntil(() => view.querySelectorAll('.chat-content .chat-msg a').length, 1000);
const msg = view.querySelector('.chat-msg .chat-msg__text');
Use Karma as test runner
2020-04-22 13:11:48 +02:00
expect(u.hasClass('chat-msg__text', msg)).toBe(true);
expect(msg.textContent).toEqual('Have you downloaded this funny file?');
Work on turning chat views into custom elements The eventual goal is to avoid UI-related stanza processing if the relevant chats aren't in the DOM. With the current architecture, chatboxes are created (and the stanzas related to them processed) even if `#conversejs` isn't in the DOM. * Initial work on making controlbox an element * Create a shared base class * Ceate ChatBoxViews proxy * Update sass now that certain classes are moved to converse-chats element
2020-12-08 12:54:14 +01:00
const media = view.querySelector('.chat-msg .chat-msg__media');
Use Karma as test runner
2020-04-22 13:11:48 +02:00
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(
MUC: Fix error message logging
2021-01-29 11:08:28 +01:00
['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));
Work on turning chat views into custom elements The eventual goal is to avoid UI-related stanza processing if the relevant chats aren't in the DOM. With the current architecture, chatboxes are created (and the stanzas related to them processed) even if `#conversejs` isn't in the DOM. * Initial work on making controlbox an element * Create a shared base class * Ceate ChatBoxViews proxy * Update sass now that certain classes are moved to converse-chats element
2020-12-08 12:54:14 +01:00
await u.waitUntil(() => view.querySelectorAll('.chat-content .chat-msg a').length, 1000);
const msg = view.querySelector('.chat-msg .chat-msg__text');
Use Karma as test runner
2020-04-22 13:11:48 +02:00
expect(u.hasClass('chat-msg__text', msg)).toBe(true);
expect(msg.textContent).toEqual('Have you seen this funny image?');
Work on turning chat views into custom elements The eventual goal is to avoid UI-related stanza processing if the relevant chats aren't in the DOM. With the current architecture, chatboxes are created (and the stanzas related to them processed) even if `#conversejs` isn't in the DOM. * Initial work on making controlbox an element * Create a shared base class * Ceate ChatBoxViews proxy * Update sass now that certain classes are moved to converse-chats element
2020-12-08 12:54:14 +01:00
const media = view.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
});
Reference in New Issue Copy Permalink