chatbox.js 88 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568
  1. (function (root, factory) {
  2. define([
  3. "jquery",
  4. "jasmine",
  5. "mock",
  6. "test-utils"
  7. ], factory);
  8. } (this, function ($, jasmine, mock, test_utils) {
  9. "use strict";
  10. const _ = converse.env._;
  11. const $iq = converse.env.$iq;
  12. const $msg = converse.env.$msg;
  13. const Strophe = converse.env.Strophe;
  14. const u = converse.env.utils;
  15. const sizzle = converse.env.sizzle;
  16. return describe("Chatboxes", function () {
  17. describe("A Chatbox", function () {
  18. it("has a /help command to show the available commands",
  19. mock.initConverseWithPromises(
  20. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  21. async function (done, _converse) {
  22. test_utils.createContacts(_converse, 'current', 1);
  23. _converse.emit('rosterContactsFetched');
  24. test_utils.openControlBox();
  25. const contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  26. await test_utils.openChatBoxFor(_converse, contact_jid);
  27. const view = _converse.chatboxviews.get(contact_jid);
  28. test_utils.sendMessage(view, '/help');
  29. const info_messages = Array.prototype.slice.call(view.el.querySelectorAll('.chat-info:not(.chat-date)'), 0);
  30. expect(info_messages.length).toBe(3);
  31. expect(info_messages.pop().textContent).toBe('/help: Show this menu');
  32. expect(info_messages.pop().textContent).toBe('/me: Write in the third person');
  33. expect(info_messages.pop().textContent).toBe('/clear: Remove messages');
  34. const msg = $msg({
  35. from: contact_jid,
  36. to: _converse.connection.jid,
  37. type: 'chat',
  38. id: (new Date()).getTime()
  39. }).c('body').t('hello world').tree();
  40. await _converse.chatboxes.onMessage(msg);
  41. await test_utils.waitUntil(() => view.content.querySelectorAll('.chat-msg').length);
  42. expect(view.content.lastElementChild.textContent.trim().indexOf('hello world')).not.toBe(-1);
  43. done();
  44. }));
  45. it("supports the /me command",
  46. mock.initConverseWithPromises(
  47. null, ['rosterGroupsFetched'], {},
  48. async function (done, _converse) {
  49. test_utils.createContacts(_converse, 'current');
  50. await test_utils.waitUntilDiscoConfirmed(_converse, 'localhost', [], ['vcard-temp']);
  51. await test_utils.waitUntil(() => _converse.xmppstatus.vcard.get('fullname'));
  52. await test_utils.openControlBox();
  53. expect(_converse.chatboxes.length).toEqual(1);
  54. const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  55. let message = '/me is tired';
  56. const msg = $msg({
  57. from: sender_jid,
  58. to: _converse.connection.jid,
  59. type: 'chat',
  60. id: (new Date()).getTime()
  61. }).c('body').t(message).up()
  62. .c('active', {'xmlns': 'http://jabber.org/protocol/chatstates'}).tree();
  63. await _converse.chatboxes.onMessage(msg);
  64. const view = _converse.chatboxviews.get(sender_jid);
  65. await new Promise((resolve, reject) => view.once('messageInserted', resolve));
  66. expect(view.el.querySelectorAll('.chat-msg--action').length).toBe(1);
  67. expect(_.includes(view.el.querySelector('.chat-msg__author').textContent, '**Max Frankfurter')).toBeTruthy();
  68. expect(view.el.querySelector('.chat-msg__text').textContent).toBe('is tired');
  69. message = '/me is as well';
  70. await test_utils.sendMessage(view, message);
  71. expect(view.el.querySelectorAll('.chat-msg--action').length).toBe(2);
  72. await test_utils.waitUntil(() => $(view.el).find('.chat-msg__author:last').text().trim() === '**Max Mustermann');
  73. expect(sizzle('.chat-msg__text:last', view.el).pop().textContent).toBe('is as well');
  74. expect($(view.el).find('.chat-msg:last').hasClass('chat-msg--followup')).toBe(false);
  75. // Check that /me messages after a normal message don't
  76. // get the 'chat-msg--followup' class.
  77. message = 'This a normal message';
  78. await test_utils.sendMessage(view, message);
  79. let message_el = view.el.querySelector('.message:last-child');
  80. expect(u.hasClass('chat-msg--followup', message_el)).toBeFalsy();
  81. message = '/me wrote a 3rd person message';
  82. await test_utils.sendMessage(view, message);
  83. message_el = view.el.querySelector('.message:last-child');
  84. expect(view.el.querySelectorAll('.chat-msg--action').length).toBe(3);
  85. expect(sizzle('.chat-msg__text:last', view.el).pop().textContent).toBe('wrote a 3rd person message');
  86. expect(u.isVisible(sizzle('.chat-msg__author:last', view.el).pop())).toBeTruthy();
  87. expect(u.hasClass('chat-msg--followup', message_el)).toBeFalsy();
  88. done();
  89. }));
  90. it("is created when you click on a roster item", mock.initConverseWithPromises(
  91. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  92. async function (done, _converse) {
  93. test_utils.createContacts(_converse, 'current');
  94. _converse.emit('rosterContactsFetched');
  95. test_utils.openControlBox();
  96. // openControlBox was called earlier, so the controlbox is
  97. // visible, but no other chat boxes have been created.
  98. expect(_converse.chatboxes.length).toEqual(1);
  99. spyOn(_converse.chatboxviews, 'trimChats');
  100. expect(document.querySelectorAll("#conversejs .chatbox").length).toBe(1); // Controlbox is open
  101. await test_utils.waitUntil(() => _converse.rosterview.el.querySelectorAll('.roster-group li').length, 700);
  102. const online_contacts = _converse.rosterview.el.querySelectorAll('.roster-group .current-xmpp-contact a.open-chat');
  103. expect(online_contacts.length).toBe(15);
  104. let el = online_contacts[0];
  105. const jid = el.textContent.trim().replace(/ /g,'.').toLowerCase() + '@localhost';
  106. el.click();
  107. await test_utils.waitUntil(() => _converse.chatboxes.length == 2);
  108. const chatboxview = _converse.chatboxviews.get(jid);
  109. expect(_converse.chatboxviews.trimChats).toHaveBeenCalled();
  110. // Check that new chat boxes are created to the left of the
  111. // controlbox (but to the right of all existing chat boxes)
  112. expect(document.querySelectorAll("#conversejs .chatbox").length).toBe(2);
  113. expect(document.querySelectorAll("#conversejs .chatbox")[1].id).toBe(chatboxview.model.get('box_id'));
  114. online_contacts[1].click();
  115. await test_utils.waitUntil(() => _converse.chatboxes.length == 3);
  116. el = online_contacts[1];
  117. const new_jid = el.textContent.trim().replace(/ /g,'.').toLowerCase() + '@localhost';
  118. const new_chatboxview = _converse.chatboxviews.get(new_jid);
  119. expect(_converse.chatboxviews.trimChats).toHaveBeenCalled();
  120. // Check that new chat boxes are created to the left of the
  121. // controlbox (but to the right of all existing chat boxes)
  122. expect(document.querySelectorAll("#conversejs .chatbox").length).toBe(3);
  123. expect(document.querySelectorAll("#conversejs .chatbox")[2].id).toBe(chatboxview.model.get('box_id'));
  124. expect(document.querySelectorAll("#conversejs .chatbox")[1].id).toBe(new_chatboxview.model.get('box_id'));
  125. done();
  126. }));
  127. it("opens when a new message is received", mock.initConverseWithPromises(
  128. null, ['rosterGroupsFetched'], {'allow_non_roster_messaging': true},
  129. async function (done, _converse) {
  130. const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  131. const stanza = Strophe.xmlHtmlNode(
  132. "<message from='"+sender_jid+"'"+
  133. " type='chat'"+
  134. " to='dummy@localhost/resource'>"+
  135. " <body>Hey\nHave you heard the news?</body>"+
  136. "</message>").firstChild;
  137. const message_promise = new Promise(resolve => _converse.api.listen.on('message', resolve));
  138. _converse.connection._dataRecv(test_utils.createRequest(stanza));
  139. await test_utils.waitUntil(() => message_promise);
  140. expect(_converse.chatboxviews.keys().length).toBe(2);
  141. done();
  142. }));
  143. it("doesn't open when a message without body is received", mock.initConverseWithPromises(
  144. null, ['rosterGroupsFetched'], {},
  145. async function (done, _converse) {
  146. test_utils.createContacts(_converse, 'current', 1);
  147. const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  148. const stanza = Strophe.xmlHtmlNode(`
  149. <message from="${sender_jid}"
  150. type="chat"
  151. to="dummy@localhost/resource">
  152. <composing xmlns="http://jabber.org/protocol/chatstates"/>
  153. </message>`).firstChild;
  154. const message_promise = new Promise(resolve => _converse.api.listen.on('message', resolve))
  155. _converse.connection._dataRecv(test_utils.createRequest(stanza));
  156. await test_utils.waitUntil(() => message_promise);
  157. expect(_converse.chatboxviews.keys().length).toBe(1);
  158. done();
  159. }));
  160. it("can be trimmed to conserve space",
  161. mock.initConverseWithPromises(null, ['rosterGroupsFetched'], {},
  162. async function (done, _converse) {
  163. spyOn(_converse.chatboxviews, 'trimChats');
  164. const trimmed_chatboxes = _converse.minimized_chats;
  165. spyOn(trimmed_chatboxes, 'addChat').and.callThrough();
  166. spyOn(trimmed_chatboxes, 'removeChat').and.callThrough();
  167. test_utils.createContacts(_converse, 'current');
  168. _converse.emit('rosterContactsFetched');
  169. test_utils.openControlBox();
  170. let jid, chatboxview;
  171. // openControlBox was called earlier, so the controlbox is
  172. // visible, but no other chat boxes have been created.
  173. expect(_converse.chatboxes.length).toEqual(1);
  174. expect(document.querySelectorAll("#conversejs .chatbox").length).toBe(1); // Controlbox is open
  175. _converse.rosterview.update(); // XXX: Hack to make sure $roster element is attached.
  176. await test_utils.waitUntil(() => _converse.rosterview.el.querySelectorAll('.roster-group li').length);
  177. // Test that they can be maximized again
  178. const online_contacts = _converse.rosterview.el.querySelectorAll('.roster-group .current-xmpp-contact a.open-chat');
  179. expect(online_contacts.length).toBe(15);
  180. let i;
  181. for (i=0; i<online_contacts.length; i++) {
  182. const el = online_contacts[i];
  183. el.click();
  184. }
  185. await test_utils.waitUntil(() => _converse.chatboxes.length == 16);
  186. expect(_converse.chatboxviews.trimChats.calls.count()).toBe(16);
  187. for (i=0; i<online_contacts.length; i++) {
  188. const el = online_contacts[i];
  189. jid = _.trim(el.textContent.trim()).replace(/ /g,'.').toLowerCase() + '@localhost';
  190. chatboxview = _converse.chatboxviews.get(jid);
  191. spyOn(chatboxview, 'minimize').and.callThrough();
  192. chatboxview.model.set({'minimized': true});
  193. expect(trimmed_chatboxes.addChat).toHaveBeenCalled();
  194. expect(chatboxview.minimize).toHaveBeenCalled();
  195. }
  196. await test_utils.waitUntil(() => _converse.chatboxviews.keys().length);
  197. var key = _converse.chatboxviews.keys()[1];
  198. const trimmedview = trimmed_chatboxes.get(key);
  199. const chatbox = trimmedview.model;
  200. spyOn(chatbox, 'maximize').and.callThrough();
  201. spyOn(trimmedview, 'restore').and.callThrough();
  202. trimmedview.delegateEvents();
  203. trimmedview.el.querySelector("a.restore-chat").click();
  204. expect(trimmedview.restore).toHaveBeenCalled();
  205. expect(chatbox.maximize).toHaveBeenCalled();
  206. expect(_converse.chatboxviews.trimChats.calls.count()).toBe(17);
  207. done();
  208. }));
  209. it("can be opened in minimized mode initially",
  210. mock.initConverseWithPromises(
  211. null, ['rosterGroupsFetched'], {},
  212. function (done, _converse) {
  213. test_utils.createContacts(_converse, 'current');
  214. var sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  215. var chat = _converse.api.chats.create(sender_jid, {
  216. minimized: true
  217. });
  218. var chatBoxView = _converse.chatboxviews.get(sender_jid);
  219. expect(u.isVisible(chatBoxView.el)).toBeFalsy();
  220. var minimized_chat = _converse.minimized_chats.get(sender_jid);
  221. expect(minimized_chat).toBeTruthy();
  222. expect($(minimized_chat.el).is(':visible')).toBeTruthy();
  223. done();
  224. }));
  225. it("is focused if its already open and you click on its corresponding roster item",
  226. mock.initConverseWithPromises(null, ['rosterGroupsFetched', 'chatBoxesFetched'], {}, function (done, _converse) {
  227. test_utils.createContacts(_converse, 'current');
  228. _converse.emit('rosterContactsFetched');
  229. test_utils.openControlBox();
  230. const contact_jid = mock.cur_names[2].replace(/ /g,'.').toLowerCase() + '@localhost';
  231. let el, jid;
  232. // openControlBox was called earlier, so the controlbox is
  233. // visible, but no other chat boxes have been created.
  234. expect(_converse.chatboxes.length).toEqual(1);
  235. test_utils.openChatBoxFor(_converse, contact_jid)
  236. .then((view) => {
  237. el = sizzle('a.open-chat:contains("'+view.model.getDisplayName()+'")', _converse.rosterview.el).pop();
  238. jid = el.textContent.replace(/ /g,'.').toLowerCase() + '@localhost';
  239. spyOn(_converse, 'emit');
  240. el.click();
  241. return test_utils.waitUntil(() => _converse.emit.calls.count(), 500);
  242. }).then(() => {
  243. expect(_converse.chatboxes.length).toEqual(2);
  244. expect(_converse.emit).toHaveBeenCalledWith('chatBoxFocused', jasmine.any(Object));
  245. done();
  246. });
  247. }));
  248. it("can be saved to, and retrieved from, browserStorage",
  249. mock.initConverseWithPromises(
  250. null, ['rosterGroupsFetched', 'chatBoxesFetched',], {},
  251. async function (done, _converse) {
  252. test_utils.createContacts(_converse, 'current');
  253. _converse.emit('rosterContactsFetched');
  254. test_utils.openControlBox();
  255. spyOn(_converse, 'emit');
  256. spyOn(_converse.chatboxviews, 'trimChats');
  257. test_utils.openControlBox();
  258. test_utils.openChatBoxes(_converse, 6);
  259. await test_utils.waitUntil(() => _converse.chatboxes.length == 7);
  260. expect(_converse.chatboxviews.trimChats).toHaveBeenCalled();
  261. // We instantiate a new ChatBoxes collection, which by default
  262. // will be empty.
  263. const newchatboxes = new _converse.ChatBoxes();
  264. expect(newchatboxes.length).toEqual(0);
  265. // The chatboxes will then be fetched from browserStorage inside the
  266. // onConnected method
  267. newchatboxes.onConnected();
  268. expect(newchatboxes.length).toEqual(7);
  269. // Check that the chatboxes items retrieved from browserStorage
  270. // have the same attributes values as the original ones.
  271. const attrs = ['id', 'box_id', 'visible'];
  272. let new_attrs, old_attrs;
  273. for (var i=0; i<attrs.length; i++) {
  274. new_attrs = _.map(_.map(newchatboxes.models, 'attributes'), attrs[i]);
  275. old_attrs = _.map(_.map(_converse.chatboxes.models, 'attributes'), attrs[i]);
  276. expect(_.isEqual(new_attrs, old_attrs)).toEqual(true);
  277. }
  278. _converse.rosterview.render();
  279. done();
  280. }));
  281. it("can be closed by clicking a DOM element with class 'close-chatbox-button'",
  282. mock.initConverseWithPromises(
  283. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  284. async function (done, _converse) {
  285. test_utils.createContacts(_converse, 'current');
  286. _converse.emit('rosterContactsFetched');
  287. test_utils.openControlBox();
  288. const contact_jid = mock.cur_names[7].replace(/ /g,'.').toLowerCase() + '@localhost';
  289. await test_utils.waitUntil(() => _converse.rosterview.el.querySelectorAll('.roster-group').length);
  290. await test_utils.openChatBoxFor(_converse, contact_jid);
  291. const controlview = _converse.chatboxviews.get('controlbox'), // The controlbox is currently open
  292. chatview = _converse.chatboxviews.get(contact_jid);
  293. spyOn(chatview, 'close').and.callThrough();
  294. spyOn(controlview, 'close').and.callThrough();
  295. spyOn(_converse, 'emit');
  296. // We need to rebind all events otherwise our spy won't be called
  297. controlview.delegateEvents();
  298. chatview.delegateEvents();
  299. controlview.el.querySelector('.close-chatbox-button').click();
  300. expect(controlview.close).toHaveBeenCalled();
  301. expect(_converse.emit).toHaveBeenCalledWith('chatBoxClosed', jasmine.any(Object));
  302. expect(_converse.emit.calls.count(), 1);
  303. chatview.el.querySelector('.close-chatbox-button').click();
  304. expect(chatview.close).toHaveBeenCalled();
  305. expect(_converse.emit).toHaveBeenCalledWith('chatBoxClosed', jasmine.any(Object));
  306. expect(_converse.emit.calls.count(), 2);
  307. done();
  308. }));
  309. it("can be minimized by clicking a DOM element with class 'toggle-chatbox-button'",
  310. mock.initConverseWithPromises(
  311. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  312. async function (done, _converse) {
  313. test_utils.createContacts(_converse, 'current');
  314. _converse.emit('rosterContactsFetched');
  315. test_utils.openControlBox();
  316. const contact_jid = mock.cur_names[7].replace(/ /g,'.').toLowerCase() + '@localhost';
  317. await test_utils.waitUntil(() => _converse.rosterview.el.querySelectorAll('.roster-group').length);
  318. await test_utils.openChatBoxFor(_converse, contact_jid);
  319. const trimmed_chatboxes = _converse.minimized_chats;
  320. const chatview = _converse.chatboxviews.get(contact_jid);
  321. spyOn(chatview, 'minimize').and.callThrough();
  322. spyOn(_converse, 'emit');
  323. // We need to rebind all events otherwise our spy won't be called
  324. chatview.delegateEvents();
  325. chatview.el.querySelector('.toggle-chatbox-button').click();
  326. expect(chatview.minimize).toHaveBeenCalled();
  327. expect(_converse.emit).toHaveBeenCalledWith('chatBoxMinimized', jasmine.any(Object));
  328. expect(_converse.emit.calls.count(), 2);
  329. expect(u.isVisible(chatview.el)).toBeFalsy();
  330. expect(chatview.model.get('minimized')).toBeTruthy();
  331. chatview.el.querySelector('.toggle-chatbox-button').click();
  332. const trimmedview = trimmed_chatboxes.get(chatview.model.get('id'));
  333. spyOn(trimmedview, 'restore').and.callThrough();
  334. trimmedview.delegateEvents();
  335. trimmedview.el.querySelector("a.restore-chat").click();
  336. expect(trimmedview.restore).toHaveBeenCalled();
  337. expect(_converse.emit).toHaveBeenCalledWith('chatBoxMaximized', jasmine.any(Object));
  338. await test_utils.waitUntil(() => u.isVisible(chatview.el.querySelector('.chat-body')), 500);
  339. expect($(chatview.el).find('.toggle-chatbox-button').hasClass('fa-minus')).toBeTruthy();
  340. expect($(chatview.el).find('.toggle-chatbox-button').hasClass('fa-plus')).toBeFalsy();
  341. expect(chatview.model.get('minimized')).toBeFalsy();
  342. done();
  343. }));
  344. it("will be removed from browserStorage when closed",
  345. mock.initConverseWithPromises(
  346. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  347. async function (done, _converse) {
  348. test_utils.createContacts(_converse, 'current');
  349. _converse.emit('rosterContactsFetched');
  350. test_utils.openControlBox();
  351. await test_utils.waitUntil(() => _converse.rosterview.el.querySelectorAll('.roster-group').length);
  352. spyOn(_converse, 'emit');
  353. spyOn(_converse.chatboxviews, 'trimChats');
  354. _converse.chatboxes.browserStorage._clear();
  355. test_utils.closeControlBox();
  356. expect(_converse.emit).toHaveBeenCalledWith('chatBoxClosed', jasmine.any(Object));
  357. expect(_converse.chatboxes.length).toEqual(1);
  358. expect(_converse.chatboxes.pluck('id')).toEqual(['controlbox']);
  359. test_utils.openChatBoxes(_converse, 6);
  360. await test_utils.waitUntil(() => _converse.chatboxes.length == 7)
  361. expect(_converse.chatboxviews.trimChats).toHaveBeenCalled();
  362. expect(_converse.chatboxes.length).toEqual(7);
  363. expect(_converse.emit).toHaveBeenCalledWith('chatBoxOpened', jasmine.any(Object));
  364. test_utils.closeAllChatBoxes(_converse);
  365. expect(_converse.chatboxes.length).toEqual(1);
  366. expect(_converse.chatboxes.pluck('id')).toEqual(['controlbox']);
  367. expect(_converse.emit).toHaveBeenCalledWith('chatBoxClosed', jasmine.any(Object));
  368. var newchatboxes = new _converse.ChatBoxes();
  369. expect(newchatboxes.length).toEqual(0);
  370. expect(_converse.chatboxes.pluck('id')).toEqual(['controlbox']);
  371. // onConnected will fetch chatboxes in browserStorage, but
  372. // because there aren't any open chatboxes, there won't be any
  373. // in browserStorage either. XXX except for the controlbox
  374. newchatboxes.onConnected();
  375. expect(newchatboxes.length).toEqual(1);
  376. expect(newchatboxes.models[0].id).toBe("controlbox");
  377. done();
  378. }));
  379. describe("A chat toolbar", function () {
  380. it("can be found on each chat box",
  381. mock.initConverseWithPromises(
  382. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  383. async function (done, _converse) {
  384. test_utils.createContacts(_converse, 'current', 3);
  385. _converse.emit('rosterContactsFetched');
  386. test_utils.openControlBox();
  387. const contact_jid = mock.cur_names[2].replace(/ /g,'.').toLowerCase() + '@localhost';
  388. await test_utils.openChatBoxFor(_converse, contact_jid);
  389. const chatbox = _converse.chatboxes.get(contact_jid);
  390. const view = _converse.chatboxviews.get(contact_jid);
  391. expect(chatbox).toBeDefined();
  392. expect(view).toBeDefined();
  393. const toolbar = view.el.querySelector('ul.chat-toolbar');
  394. expect(_.isElement(toolbar)).toBe(true);
  395. expect(toolbar.querySelectorAll(':scope > li').length).toBe(2);
  396. done();
  397. }));
  398. it("contains a button for inserting emojis",
  399. mock.initConverseWithPromises(
  400. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  401. async function (done, _converse) {
  402. test_utils.createContacts(_converse, 'current');
  403. _converse.emit('rosterContactsFetched');
  404. test_utils.openControlBox();
  405. const contact_jid = mock.cur_names[2].replace(/ /g,'.').toLowerCase() + '@localhost';
  406. await test_utils.openChatBoxFor(_converse, contact_jid);
  407. const view = _converse.chatboxviews.get(contact_jid);
  408. const toolbar = view.el.querySelector('ul.chat-toolbar');
  409. expect(toolbar.querySelectorAll('li.toggle-smiley').length).toBe(1);
  410. // Register spies
  411. spyOn(view, 'toggleEmojiMenu').and.callThrough();
  412. spyOn(view, 'insertEmoji').and.callThrough();
  413. view.delegateEvents(); // We need to rebind all events otherwise our spy won't be called
  414. toolbar.querySelector('li.toggle-smiley').click();
  415. await test_utils.waitUntil(() => u.isVisible(view.el.querySelector('.toggle-smiley .emoji-picker-container')));
  416. var picker = view.el.querySelector('.toggle-smiley .emoji-picker-container');
  417. var items = picker.querySelectorAll('.emoji-picker li');
  418. items[0].click()
  419. expect(view.insertEmoji).toHaveBeenCalled();
  420. expect(view.el.querySelector('textarea.chat-textarea').value).toBe(':grinning: ');
  421. toolbar.querySelector('li.toggle-smiley').click(); // Close the panel again
  422. done();
  423. }));
  424. it("can contain a button for starting a call",
  425. mock.initConverseWithPromises(
  426. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  427. async function (done, _converse) {
  428. test_utils.createContacts(_converse, 'current');
  429. _converse.emit('rosterContactsFetched');
  430. test_utils.openControlBox();
  431. let toolbar, call_button;
  432. const contact_jid = mock.cur_names[2].replace(/ /g,'.').toLowerCase() + '@localhost';
  433. spyOn(_converse, 'emit');
  434. // First check that the button doesn't show if it's not enabled
  435. // via "visible_toolbar_buttons"
  436. _converse.visible_toolbar_buttons.call = false;
  437. await test_utils.openChatBoxFor(_converse, contact_jid);
  438. let view = _converse.chatboxviews.get(contact_jid);
  439. toolbar = view.el.querySelector('ul.chat-toolbar');
  440. call_button = toolbar.querySelector('.toggle-call');
  441. expect(_.isNull(call_button)).toBeTruthy();
  442. view.close();
  443. // Now check that it's shown if enabled and that it emits
  444. // callButtonClicked
  445. _converse.visible_toolbar_buttons.call = true; // enable the button
  446. await test_utils.openChatBoxFor(_converse, contact_jid);
  447. view = _converse.chatboxviews.get(contact_jid);
  448. toolbar = view.el.querySelector('ul.chat-toolbar');
  449. call_button = toolbar.querySelector('.toggle-call');
  450. call_button.click();
  451. expect(_converse.emit).toHaveBeenCalledWith('callButtonClicked', jasmine.any(Object));
  452. done();
  453. }));
  454. });
  455. describe("A Chat Status Notification", function () {
  456. it("does not open a new chatbox",
  457. mock.initConverseWithPromises(
  458. null, ['rosterGroupsFetched'], {},
  459. async function (done, _converse) {
  460. test_utils.createContacts(_converse, 'current');
  461. test_utils.openControlBox();
  462. spyOn(_converse, 'emit');
  463. const sender_jid = mock.cur_names[1].replace(/ /g,'.').toLowerCase() + '@localhost';
  464. // <composing> state
  465. const msg = $msg({
  466. 'from': sender_jid,
  467. 'to': _converse.connection.jid,
  468. 'type': 'chat',
  469. 'id': (new Date()).getTime()
  470. }).c('composing', {'xmlns': Strophe.NS.CHATSTATES}).tree();
  471. await _converse.chatboxes.onMessage(msg);
  472. expect(_converse.emit).toHaveBeenCalledWith('message', jasmine.any(Object));
  473. done();
  474. }));
  475. describe("An active notification", function () {
  476. it("is sent when the user opens a chat box",
  477. mock.initConverseWithPromises(
  478. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  479. async function (done, _converse) {
  480. test_utils.createContacts(_converse, 'current');
  481. _converse.emit('rosterContactsFetched');
  482. const contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  483. test_utils.openControlBox();
  484. test_utils.waitUntil(() => _converse.rosterview.el.querySelectorAll('.roster-group').length);
  485. spyOn(_converse.connection, 'send');
  486. await test_utils.openChatBoxFor(_converse, contact_jid);
  487. const view = _converse.chatboxviews.get(contact_jid);
  488. expect(view.model.get('chat_state')).toBe('active');
  489. expect(_converse.connection.send).toHaveBeenCalled();
  490. const $stanza = $(_converse.connection.send.calls.argsFor(0)[0].tree());
  491. expect($stanza.attr('to')).toBe(contact_jid);
  492. expect($stanza.children().length).toBe(3);
  493. expect($stanza.children().get(0).tagName).toBe('active');
  494. expect($stanza.children().get(1).tagName).toBe('no-store');
  495. expect($stanza.children().get(2).tagName).toBe('no-permanent-store');
  496. done();
  497. }));
  498. it("is sent when the user maximizes a minimized a chat box", mock.initConverseWithPromises(
  499. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  500. async function (done, _converse) {
  501. test_utils.createContacts(_converse, 'current', 1);
  502. _converse.emit('rosterContactsFetched');
  503. test_utils.openControlBox();
  504. const contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  505. await test_utils.waitUntil(() => _converse.rosterview.el.querySelectorAll('.roster-group').length);
  506. await test_utils.openChatBoxFor(_converse, contact_jid);
  507. var view = _converse.chatboxviews.get(contact_jid);
  508. view.model.minimize();
  509. expect(view.model.get('chat_state')).toBe('inactive');
  510. spyOn(_converse.connection, 'send');
  511. view.model.maximize();
  512. await test_utils.waitUntil(() => view.model.get('chat_state') === 'active', 1000);
  513. expect(_converse.connection.send).toHaveBeenCalled();
  514. const calls = _.filter(_converse.connection.send.calls.all(), function (call) {
  515. return call.args[0] instanceof Strophe.Builder;
  516. });
  517. expect(calls.length).toBe(1);
  518. var $stanza = $(calls[0].args[0].tree());
  519. expect($stanza.attr('to')).toBe(contact_jid);
  520. expect($stanza.children().length).toBe(3);
  521. expect($stanza.children().get(0).tagName).toBe('active');
  522. expect($stanza.children().get(1).tagName).toBe('no-store');
  523. expect($stanza.children().get(2).tagName).toBe('no-permanent-store');
  524. done();
  525. }));
  526. });
  527. describe("A composing notification", function () {
  528. it("is sent as soon as the user starts typing a message which is not a command",
  529. mock.initConverseWithPromises(
  530. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  531. async function (done, _converse) {
  532. test_utils.createContacts(_converse, 'current');
  533. _converse.emit('rosterContactsFetched');
  534. test_utils.openControlBox();
  535. const contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  536. await test_utils.waitUntil(() => _converse.rosterview.el.querySelectorAll('.roster-group').length);
  537. await test_utils.openChatBoxFor(_converse, contact_jid);
  538. var view = _converse.chatboxviews.get(contact_jid);
  539. expect(view.model.get('chat_state')).toBe('active');
  540. spyOn(_converse.connection, 'send');
  541. spyOn(_converse, 'emit');
  542. view.keyPressed({
  543. target: view.el.querySelector('textarea.chat-textarea'),
  544. keyCode: 1
  545. });
  546. expect(view.model.get('chat_state')).toBe('composing');
  547. expect(_converse.connection.send).toHaveBeenCalled();
  548. var $stanza = $(_converse.connection.send.calls.argsFor(0)[0].tree());
  549. expect($stanza.attr('to')).toBe(contact_jid);
  550. expect($stanza.children().get(0).tagName).toBe('composing');
  551. expect($stanza.children().get(1).tagName).toBe('no-store');
  552. expect($stanza.children().get(2).tagName).toBe('no-permanent-store');
  553. // The notification is not sent again
  554. view.keyPressed({
  555. target: view.el.querySelector('textarea.chat-textarea'),
  556. keyCode: 1
  557. });
  558. expect(view.model.get('chat_state')).toBe('composing');
  559. expect(_converse.emit.calls.count(), 1);
  560. done();
  561. }));
  562. it("will be shown if received",
  563. mock.initConverseWithPromises(
  564. null, ['rosterGroupsFetched'], {},
  565. async function (done, _converse) {
  566. test_utils.createContacts(_converse, 'current');
  567. test_utils.openControlBox();
  568. // See XEP-0085 http://xmpp.org/extensions/xep-0085.html#definitions
  569. spyOn(_converse, 'emit');
  570. const sender_jid = mock.cur_names[1].replace(/ /g,'.').toLowerCase() + '@localhost';
  571. test_utils.openChatBoxFor(_converse, sender_jid);
  572. // <composing> state
  573. let msg = $msg({
  574. from: sender_jid,
  575. to: _converse.connection.jid,
  576. type: 'chat',
  577. id: (new Date()).getTime()
  578. }).c('body').c('composing', {'xmlns': Strophe.NS.CHATSTATES}).tree();
  579. await _converse.chatboxes.onMessage(msg);
  580. expect(_converse.emit).toHaveBeenCalledWith('message', jasmine.any(Object));
  581. var view = _converse.chatboxviews.get(sender_jid);
  582. expect(view).toBeDefined();
  583. await test_utils.waitUntil(() => view.model.vcard.get('fullname') === mock.cur_names[1])
  584. // Check that the notification appears inside the chatbox in the DOM
  585. let events = view.el.querySelectorAll('.chat-state-notification');
  586. expect(events.length).toBe(1);
  587. expect(events[0].textContent).toEqual(mock.cur_names[1] + ' is typing');
  588. // Check that it doesn't appear twice
  589. msg = $msg({
  590. from: sender_jid,
  591. to: _converse.connection.jid,
  592. type: 'chat',
  593. id: (new Date()).getTime()
  594. }).c('body').c('composing', {'xmlns': Strophe.NS.CHATSTATES}).tree();
  595. await _converse.chatboxes.onMessage(msg);
  596. events = view.el.querySelectorAll('.chat-state-notification');
  597. expect(events.length).toBe(1);
  598. expect(events[0].textContent).toEqual(mock.cur_names[1] + ' is typing');
  599. done();
  600. }));
  601. it("can be a composing carbon message that this user sent from a different client",
  602. mock.initConverseWithPromises(
  603. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  604. async function (done, _converse) {
  605. let contact, sent_stanza, IQ_id, stanza;
  606. await test_utils.waitUntilDiscoConfirmed(_converse, 'localhost', [], ['vcard-temp']);
  607. await test_utils.waitUntil(() => _converse.xmppstatus.vcard.get('fullname'));
  608. test_utils.createContacts(_converse, 'current');
  609. _converse.emit('rosterContactsFetched');
  610. // Send a message from a different resource
  611. spyOn(_converse, 'log');
  612. const recipient_jid = mock.cur_names[5].replace(/ /g,'.').toLowerCase() + '@localhost';
  613. const view = await test_utils.openChatBoxFor(_converse, recipient_jid);
  614. var msg = $msg({
  615. 'from': _converse.bare_jid,
  616. 'id': (new Date()).getTime(),
  617. 'to': _converse.connection.jid,
  618. 'type': 'chat',
  619. 'xmlns': 'jabber:client'
  620. }).c('sent', {'xmlns': 'urn:xmpp:carbons:2'})
  621. .c('forwarded', {'xmlns': 'urn:xmpp:forward:0'})
  622. .c('message', {
  623. 'xmlns': 'jabber:client',
  624. 'from': _converse.bare_jid+'/another-resource',
  625. 'to': recipient_jid,
  626. 'type': 'chat'
  627. }).c('composing', {'xmlns': Strophe.NS.CHATSTATES}).tree();
  628. await _converse.chatboxes.onMessage(msg);
  629. await test_utils.waitUntil(() => view.model.messages.length);
  630. // Check that the chatbox and its view now exist
  631. var chatbox = _converse.chatboxes.get(recipient_jid);
  632. var chatboxview = _converse.chatboxviews.get(recipient_jid);
  633. // Check that the message was received and check the message parameters
  634. expect(chatbox.messages.length).toEqual(1);
  635. var msg_obj = chatbox.messages.models[0];
  636. expect(msg_obj.get('sender')).toEqual('me');
  637. expect(msg_obj.get('is_delayed')).toEqual(false);
  638. var $chat_content = $(chatboxview.el).find('.chat-content');
  639. var status_text = $chat_content.find('.chat-info.chat-state-notification').text();
  640. expect(status_text).toBe('Typing from another device');
  641. done();
  642. }));
  643. });
  644. describe("A paused notification", function () {
  645. it("is sent if the user has stopped typing since 30 seconds",
  646. mock.initConverseWithPromises(
  647. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  648. async function (done, _converse) {
  649. test_utils.createContacts(_converse, 'current');
  650. _converse.emit('rosterContactsFetched');
  651. const contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  652. test_utils.openControlBox();
  653. await test_utils.waitUntil(() => _converse.rosterview.el.querySelectorAll('.roster-group li').length, 700);
  654. _converse.TIMEOUTS.PAUSED = 200; // Make the timeout shorter so that we can test
  655. await test_utils.openChatBoxFor(_converse, contact_jid);
  656. const view = _converse.chatboxviews.get(contact_jid);
  657. spyOn(_converse.connection, 'send');
  658. spyOn(view, 'setChatState').and.callThrough();
  659. expect(view.model.get('chat_state')).toBe('active');
  660. view.keyPressed({
  661. target: view.el.querySelector('textarea.chat-textarea'),
  662. keyCode: 1
  663. });
  664. expect(view.model.get('chat_state')).toBe('composing');
  665. expect(_converse.connection.send).toHaveBeenCalled();
  666. let $stanza = $(_converse.connection.send.calls.argsFor(0)[0].tree());
  667. expect($stanza.children().get(0).tagName).toBe('composing');
  668. await test_utils.waitUntil(() => view.model.get('chat_state') === 'paused', 500);
  669. expect(_converse.connection.send).toHaveBeenCalled();
  670. var calls = _.filter(_converse.connection.send.calls.all(), function (call) {
  671. return call.args[0] instanceof Strophe.Builder;
  672. });
  673. expect(calls.length).toBe(2);
  674. $stanza = $(calls[1].args[0].tree());
  675. expect($stanza.attr('to')).toBe(contact_jid);
  676. expect($stanza.children().length).toBe(3);
  677. expect($stanza.children().get(0).tagName).toBe('paused');
  678. expect($stanza.children().get(1).tagName).toBe('no-store');
  679. expect($stanza.children().get(2).tagName).toBe('no-permanent-store');
  680. // Test #359. A paused notification should not be sent
  681. // out if the user simply types longer than the
  682. // timeout.
  683. view.keyPressed({
  684. target: view.el.querySelector('textarea.chat-textarea'),
  685. keyCode: 1
  686. });
  687. expect(view.setChatState).toHaveBeenCalled();
  688. expect(view.model.get('chat_state')).toBe('composing');
  689. view.keyPressed({
  690. target: view.el.querySelector('textarea.chat-textarea'),
  691. keyCode: 1
  692. });
  693. expect(view.model.get('chat_state')).toBe('composing');
  694. done();
  695. }));
  696. it("will be shown if received",
  697. mock.initConverseWithPromises(
  698. null, ['rosterGroupsFetched'], {},
  699. async function (done, _converse) {
  700. test_utils.createContacts(_converse, 'current');
  701. test_utils.openControlBox();
  702. await test_utils.waitUntil(() => _converse.rosterview.el.querySelectorAll('.roster-group').length);
  703. // TODO: only show paused state if the previous state was composing
  704. // See XEP-0085 http://xmpp.org/extensions/xep-0085.html#definitions
  705. spyOn(_converse, 'emit');
  706. const sender_jid = mock.cur_names[1].replace(/ /g,'.').toLowerCase() + '@localhost';
  707. // <paused> state
  708. const msg = $msg({
  709. from: sender_jid,
  710. to: _converse.connection.jid,
  711. type: 'chat',
  712. id: (new Date()).getTime()
  713. }).c('body').c('paused', {'xmlns': Strophe.NS.CHATSTATES}).tree();
  714. await _converse.chatboxes.onMessage(msg);
  715. expect(_converse.emit).toHaveBeenCalledWith('message', jasmine.any(Object));
  716. const view = _converse.chatboxviews.get(sender_jid);
  717. await new Promise((resolve, reject) => view.once('messageInserted', resolve));
  718. await test_utils.waitUntil(() => view.model.vcard.get('fullname') === mock.cur_names[1])
  719. var event = view.el.querySelector('.chat-info.chat-state-notification');
  720. expect(event.textContent).toEqual(mock.cur_names[1] + ' has stopped typing');
  721. done();
  722. }));
  723. it("can be a paused carbon message that this user sent from a different client",
  724. mock.initConverseWithPromises(
  725. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  726. async function (done, _converse) {
  727. let contact, sent_stanza, IQ_id, stanza;
  728. await test_utils.waitUntilDiscoConfirmed(_converse, 'localhost', [], ['vcard-temp']);
  729. await test_utils.waitUntil(() => _converse.xmppstatus.vcard.get('fullname'));
  730. test_utils.createContacts(_converse, 'current', 6);
  731. _converse.emit('rosterContactsFetched');
  732. // Send a message from a different resource
  733. spyOn(_converse, 'log');
  734. const recipient_jid = mock.cur_names[5].replace(/ /g,'.').toLowerCase() + '@localhost';
  735. const view = await test_utils.openChatBoxFor(_converse, recipient_jid);
  736. const msg = $msg({
  737. 'from': _converse.bare_jid,
  738. 'id': (new Date()).getTime(),
  739. 'to': _converse.connection.jid,
  740. 'type': 'chat',
  741. 'xmlns': 'jabber:client'
  742. }).c('sent', {'xmlns': 'urn:xmpp:carbons:2'})
  743. .c('forwarded', {'xmlns': 'urn:xmpp:forward:0'})
  744. .c('message', {
  745. 'xmlns': 'jabber:client',
  746. 'from': _converse.bare_jid+'/another-resource',
  747. 'to': recipient_jid,
  748. 'type': 'chat'
  749. }).c('paused', {'xmlns': Strophe.NS.CHATSTATES}).tree();
  750. await _converse.chatboxes.onMessage(msg);
  751. await test_utils.waitUntil(() => view.model.messages.length);
  752. // Check that the chatbox and its view now exist
  753. var chatbox = _converse.chatboxes.get(recipient_jid);
  754. var chatboxview = _converse.chatboxviews.get(recipient_jid);
  755. // Check that the message was received and check the message parameters
  756. expect(chatbox.messages.length).toEqual(1);
  757. var msg_obj = chatbox.messages.models[0];
  758. expect(msg_obj.get('sender')).toEqual('me');
  759. expect(msg_obj.get('is_delayed')).toEqual(false);
  760. var $chat_content = $(chatboxview.el).find('.chat-content');
  761. var status_text = $chat_content.find('.chat-info.chat-state-notification').text();
  762. expect(status_text).toBe('Stopped typing on the other device');
  763. done();
  764. }));
  765. });
  766. describe("An inactive notifciation", function () {
  767. it("is sent if the user has stopped typing since 2 minutes",
  768. mock.initConverseWithPromises(
  769. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  770. async function (done, _converse) {
  771. // Make the timeouts shorter so that we can test
  772. _converse.TIMEOUTS.PAUSED = 200;
  773. _converse.TIMEOUTS.INACTIVE = 200;
  774. test_utils.createContacts(_converse, 'current');
  775. _converse.emit('rosterContactsFetched');
  776. const contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  777. test_utils.openControlBox();
  778. await test_utils.waitUntil(() => _converse.rosterview.el.querySelectorAll('.roster-group').length, 1000);
  779. await test_utils.openChatBoxFor(_converse, contact_jid);
  780. const view = _converse.chatboxviews.get(contact_jid);
  781. await test_utils.waitUntil(() => view.model.get('chat_state') === 'active', 1000);
  782. console.log('chat_state set to active');
  783. expect(view.model.get('chat_state')).toBe('active');
  784. view.keyPressed({
  785. target: view.el.querySelector('textarea.chat-textarea'),
  786. keyCode: 1
  787. });
  788. await test_utils.waitUntil(() => view.model.get('chat_state') === 'composing', 500);
  789. console.log('chat_state set to composing');
  790. expect(view.model.get('chat_state')).toBe('composing');
  791. spyOn(_converse.connection, 'send');
  792. await test_utils.waitUntil(() => view.model.get('chat_state') === 'paused', 1000);
  793. await test_utils.waitUntil(() => view.model.get('chat_state') === 'inactive', 1000);
  794. console.log('chat_state set to inactive');
  795. expect(_converse.connection.send).toHaveBeenCalled();
  796. var calls = _.filter(_converse.connection.send.calls.all(), function (call) {
  797. return call.args[0] instanceof Strophe.Builder;
  798. });
  799. expect(calls.length).toBe(2);
  800. var stanza = calls[0].args[0].tree();
  801. expect(stanza.getAttribute('to')).toBe(contact_jid);
  802. expect(stanza.children.length).toBe(3);
  803. expect(stanza.children[0].tagName).toBe('paused');
  804. expect(stanza.children[1].tagName).toBe('no-store');
  805. expect(stanza.children[2].tagName).toBe('no-permanent-store');
  806. stanza = _converse.connection.send.calls.mostRecent().args[0].tree();
  807. expect(stanza.getAttribute('to')).toBe(contact_jid);
  808. expect(stanza.children.length).toBe(3);
  809. expect(stanza.children[0].tagName).toBe('inactive');
  810. expect(stanza.children[1].tagName).toBe('no-store');
  811. expect(stanza.children[2].tagName).toBe('no-permanent-store');
  812. done();
  813. }));
  814. it("is sent when the user a minimizes a chat box",
  815. mock.initConverseWithPromises(
  816. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  817. async function (done, _converse) {
  818. test_utils.createContacts(_converse, 'current', 1);
  819. _converse.emit('rosterContactsFetched');
  820. test_utils.openControlBox();
  821. const contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  822. await test_utils.openChatBoxFor(_converse, contact_jid);
  823. const view = _converse.chatboxviews.get(contact_jid);
  824. spyOn(_converse.connection, 'send');
  825. view.minimize();
  826. expect(view.model.get('chat_state')).toBe('inactive');
  827. expect(_converse.connection.send).toHaveBeenCalled();
  828. var $stanza = $(_converse.connection.send.calls.argsFor(0)[0].tree());
  829. expect($stanza.attr('to')).toBe(contact_jid);
  830. expect($stanza.children().get(0).tagName).toBe('inactive');
  831. done();
  832. }));
  833. it("is sent if the user closes a chat box",
  834. mock.initConverseWithPromises(
  835. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  836. async function (done, _converse) {
  837. test_utils.createContacts(_converse, 'current');
  838. _converse.emit('rosterContactsFetched');
  839. const contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  840. test_utils.openControlBox();
  841. await test_utils.waitUntil(() => _converse.rosterview.el.querySelectorAll('.roster-group').length);
  842. const view = await test_utils.openChatBoxFor(_converse, contact_jid);
  843. expect(view.model.get('chat_state')).toBe('active');
  844. spyOn(_converse.connection, 'send');
  845. view.close();
  846. expect(view.model.get('chat_state')).toBe('inactive');
  847. expect(_converse.connection.send).toHaveBeenCalled();
  848. var $stanza = $(_converse.connection.send.calls.argsFor(0)[0].tree());
  849. expect($stanza.attr('to')).toBe(contact_jid);
  850. expect($stanza.children().length).toBe(3);
  851. expect($stanza.children().get(0).tagName).toBe('inactive');
  852. expect($stanza.children().get(1).tagName).toBe('no-store');
  853. expect($stanza.children().get(2).tagName).toBe('no-permanent-store');
  854. done();
  855. }));
  856. it("will clear any other chat status notifications",
  857. mock.initConverseWithPromises(
  858. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  859. async function (done, _converse) {
  860. test_utils.createContacts(_converse, 'current');
  861. _converse.emit('rosterContactsFetched');
  862. test_utils.openControlBox();
  863. const sender_jid = mock.cur_names[1].replace(/ /g,'.').toLowerCase() + '@localhost';
  864. // See XEP-0085 http://xmpp.org/extensions/xep-0085.html#definitions
  865. spyOn(_converse, 'emit');
  866. await test_utils.openChatBoxFor(_converse, sender_jid);
  867. const view = _converse.chatboxviews.get(sender_jid);
  868. expect(view.el.querySelectorAll('.chat-event').length).toBe(0);
  869. // Insert <composing> message, to also check that
  870. // text messages are inserted correctly with
  871. // temporary chat events in the chat contents.
  872. let msg = $msg({
  873. 'to': _converse.bare_jid,
  874. 'xmlns': 'jabber:client',
  875. 'from': sender_jid,
  876. 'type': 'chat'})
  877. .c('composing', {'xmlns': Strophe.NS.CHATSTATES}).up()
  878. .tree();
  879. await _converse.chatboxes.onMessage(msg);
  880. await test_utils.waitUntil(() => view.model.messages.length);
  881. expect(view.el.querySelectorAll('.chat-state-notification').length).toBe(1);
  882. msg = $msg({
  883. from: sender_jid,
  884. to: _converse.connection.jid,
  885. type: 'chat',
  886. id: (new Date()).getTime()
  887. }).c('body').c('inactive', {'xmlns': Strophe.NS.CHATSTATES}).tree();
  888. await _converse.chatboxes.onMessage(msg);
  889. await test_utils.waitUntil(() => (view.model.messages.length > 1));
  890. expect(_converse.emit).toHaveBeenCalledWith('message', jasmine.any(Object));
  891. expect(view.el.querySelectorAll('.chat-state-notification').length).toBe(0);
  892. done();
  893. }));
  894. });
  895. describe("A gone notifciation", function () {
  896. it("will be shown if received",
  897. mock.initConverseWithPromises(
  898. null, ['rosterGroupsFetched'], {},
  899. async function (done, _converse) {
  900. test_utils.createContacts(_converse, 'current', 3);
  901. test_utils.openControlBox();
  902. spyOn(_converse, 'emit');
  903. const sender_jid = mock.cur_names[1].replace(/ /g,'.').toLowerCase() + '@localhost';
  904. // <paused> state
  905. const msg = $msg({
  906. from: sender_jid,
  907. to: _converse.connection.jid,
  908. type: 'chat',
  909. id: (new Date()).getTime()
  910. }).c('body').c('gone', {'xmlns': Strophe.NS.CHATSTATES}).tree();
  911. await _converse.chatboxes.onMessage(msg);
  912. expect(_converse.emit).toHaveBeenCalledWith('message', jasmine.any(Object));
  913. const view = _converse.chatboxviews.get(sender_jid);
  914. await test_utils.waitUntil(() => view.model.vcard.get('fullname') === mock.cur_names[1]);
  915. const event = view.el.querySelector('.chat-state-notification');
  916. expect(event.textContent).toEqual(mock.cur_names[1] + ' has gone away');
  917. done();
  918. }));
  919. });
  920. });
  921. });
  922. describe("Special Messages", function () {
  923. it("'/clear' can be used to clear messages in a conversation",
  924. mock.initConverseWithPromises(
  925. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  926. async function (done, _converse) {
  927. test_utils.createContacts(_converse, 'current');
  928. _converse.emit('rosterContactsFetched');
  929. test_utils.openControlBox();
  930. const contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  931. spyOn(_converse, 'emit');
  932. await test_utils.openChatBoxFor(_converse, contact_jid);
  933. const view = _converse.chatboxviews.get(contact_jid);
  934. let message = 'This message is another sent from this chatbox';
  935. await test_utils.sendMessage(view, message);
  936. expect(view.model.messages.length > 0).toBeTruthy();
  937. expect(view.model.messages.browserStorage.records.length > 0).toBeTruthy();
  938. await test_utils.waitUntil(() => view.el.querySelector('.chat-msg'));
  939. message = '/clear';
  940. spyOn(view, 'clearMessages').and.callThrough();
  941. spyOn(window, 'confirm').and.callFake(function () {
  942. return true;
  943. });
  944. view.el.querySelector('.chat-textarea').value = message;
  945. view.keyPressed({
  946. target: view.el.querySelector('textarea.chat-textarea'),
  947. preventDefault: _.noop,
  948. keyCode: 13
  949. });
  950. expect(view.clearMessages).toHaveBeenCalled();
  951. expect(window.confirm).toHaveBeenCalled();
  952. expect(view.model.messages.length, 0); // The messages must be removed from the chatbox
  953. expect(view.model.messages.browserStorage.records.length, 0); // And also from browserStorage
  954. expect(_converse.emit.calls.count(), 1);
  955. expect(_converse.emit.calls.mostRecent().args, ['messageSend', message]);
  956. done();
  957. }));
  958. });
  959. describe("A Message Counter", function () {
  960. it("is incremented when the message is received and the window is not focused",
  961. mock.initConverseWithPromises(
  962. null, ['rosterGroupsFetched'], {},
  963. async function (done, _converse) {
  964. test_utils.createContacts(_converse, 'current', 1);
  965. _converse.emit('rosterContactsFetched');
  966. test_utils.openControlBox();
  967. expect(_converse.msg_counter).toBe(0);
  968. const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  969. const view = await test_utils.openChatBoxFor(_converse, sender_jid)
  970. const previous_state = _converse.windowState;
  971. const message = 'This message will increment the message counter';
  972. const msg = $msg({
  973. from: sender_jid,
  974. to: _converse.connection.jid,
  975. type: 'chat',
  976. id: (new Date()).getTime()
  977. }).c('body').t(message).up()
  978. .c('active', {'xmlns': Strophe.NS.CHATSTATES}).tree();
  979. _converse.windowState = 'hidden';
  980. spyOn(_converse, 'emit').and.callThrough();
  981. spyOn(_converse, 'incrementMsgCounter').and.callThrough();
  982. spyOn(_converse, 'clearMsgCounter').and.callThrough();
  983. await _converse.chatboxes.onMessage(msg);
  984. await new Promise((resolve, reject) => view.once('messageInserted', resolve));
  985. expect(_converse.incrementMsgCounter).toHaveBeenCalled();
  986. expect(_converse.clearMsgCounter).not.toHaveBeenCalled();
  987. expect(_converse.msg_counter).toBe(1);
  988. expect(_converse.emit).toHaveBeenCalledWith('message', jasmine.any(Object));
  989. _converse.windowSate = previous_state;
  990. done();
  991. }));
  992. it("is cleared when the window is focused",
  993. mock.initConverseWithPromises(
  994. null, ['rosterGroupsFetched'], {},
  995. function (done, _converse) {
  996. test_utils.createContacts(_converse, 'current');
  997. test_utils.openControlBox();
  998. _converse.windowState = 'hidden';
  999. spyOn(_converse, 'clearMsgCounter').and.callThrough();
  1000. _converse.saveWindowState(null, 'focus');
  1001. _converse.saveWindowState(null, 'blur');
  1002. expect(_converse.clearMsgCounter).toHaveBeenCalled();
  1003. done();
  1004. }));
  1005. it("is not incremented when the message is received and the window is focused",
  1006. mock.initConverseWithPromises(
  1007. null, ['rosterGroupsFetched'], {},
  1008. async function (done, _converse) {
  1009. test_utils.createContacts(_converse, 'current');
  1010. test_utils.openControlBox();
  1011. expect(_converse.msg_counter).toBe(0);
  1012. spyOn(_converse, 'incrementMsgCounter').and.callThrough();
  1013. _converse.saveWindowState(null, 'focus');
  1014. const message = 'This message will not increment the message counter';
  1015. const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost',
  1016. msg = $msg({
  1017. from: sender_jid,
  1018. to: _converse.connection.jid,
  1019. type: 'chat',
  1020. id: (new Date()).getTime()
  1021. }).c('body').t(message).up()
  1022. .c('active', {'xmlns': Strophe.NS.CHATSTATES}).tree();
  1023. await _converse.chatboxes.onMessage(msg);
  1024. expect(_converse.incrementMsgCounter).not.toHaveBeenCalled();
  1025. expect(_converse.msg_counter).toBe(0);
  1026. done();
  1027. }));
  1028. it("is incremented from zero when chatbox was closed after viewing previously received messages and the window is not focused now",
  1029. mock.initConverseWithPromises(
  1030. null, ['rosterGroupsFetched'], {},
  1031. async function (done, _converse) {
  1032. test_utils.createContacts(_converse, 'current');
  1033. // initial state
  1034. expect(_converse.msg_counter).toBe(0);
  1035. const message = 'This message will always increment the message counter from zero',
  1036. sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost',
  1037. msgFactory = function () {
  1038. return $msg({
  1039. from: sender_jid,
  1040. to: _converse.connection.jid,
  1041. type: 'chat',
  1042. id: (new Date()).getTime()
  1043. })
  1044. .c('body').t(message).up()
  1045. .c('active', {'xmlns': Strophe.NS.CHATSTATES})
  1046. .tree();
  1047. };
  1048. // leave converse-chat page
  1049. _converse.windowState = 'hidden';
  1050. _converse.chatboxes.onMessage(msgFactory());
  1051. await test_utils.waitUntil(() => _converse.api.chats.get().length)
  1052. let view = _converse.chatboxviews.get(sender_jid);
  1053. await new Promise((resolve, reject) => view.once('messageInserted', resolve));
  1054. expect(_converse.msg_counter).toBe(1);
  1055. // come back to converse-chat page
  1056. _converse.saveWindowState(null, 'focus');
  1057. expect(u.isVisible(view.el)).toBeTruthy();
  1058. expect(_converse.msg_counter).toBe(0);
  1059. // close chatbox and leave converse-chat page again
  1060. view.close();
  1061. _converse.windowState = 'hidden';
  1062. // check that msg_counter is incremented from zero again
  1063. _converse.chatboxes.onMessage(msgFactory());
  1064. await test_utils.waitUntil(() => _converse.api.chats.get().length)
  1065. view = _converse.chatboxviews.get(sender_jid);
  1066. await new Promise((resolve, reject) => view.once('messageInserted', resolve));
  1067. expect(u.isVisible(view.el)).toBeTruthy();
  1068. expect(_converse.msg_counter).toBe(1);
  1069. done();
  1070. }));
  1071. });
  1072. describe("A ChatBox's Unread Message Count", function () {
  1073. it("is incremented when the message is received and ChatBoxView is scrolled up",
  1074. mock.initConverseWithPromises(
  1075. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  1076. async function (done, _converse) {
  1077. test_utils.createContacts(_converse, 'current');
  1078. _converse.emit('rosterContactsFetched');
  1079. const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost',
  1080. msg = test_utils.createChatMessage(_converse, sender_jid, 'This message will be unread');
  1081. const view = await test_utils.openChatBoxFor(_converse, sender_jid)
  1082. view.model.save('scrolled', true);
  1083. await _converse.chatboxes.onMessage(msg);
  1084. await test_utils.waitUntil(() => view.model.messages.length);
  1085. expect(view.model.get('num_unread')).toBe(1);
  1086. done();
  1087. }));
  1088. it("is not incremented when the message is received and ChatBoxView is scrolled down",
  1089. mock.initConverseWithPromises(
  1090. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  1091. async function (done, _converse) {
  1092. test_utils.createContacts(_converse, 'current', 1);
  1093. _converse.emit('rosterContactsFetched');
  1094. const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost',
  1095. msg = test_utils.createChatMessage(_converse, sender_jid, 'This message will be read');
  1096. await test_utils.openChatBoxFor(_converse, sender_jid);
  1097. const chatbox = _converse.chatboxes.get(sender_jid);
  1098. await _converse.chatboxes.onMessage(msg);
  1099. expect(chatbox.get('num_unread')).toBe(0);
  1100. done();
  1101. }));
  1102. it("is incremeted when message is received, chatbox is scrolled down and the window is not focused",
  1103. mock.initConverseWithPromises(null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  1104. async function (done, _converse) {
  1105. test_utils.createContacts(_converse, 'current');
  1106. _converse.emit('rosterContactsFetched');
  1107. const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  1108. const msgFactory = function () {
  1109. return test_utils.createChatMessage(_converse, sender_jid, 'This message will be unread');
  1110. };
  1111. await test_utils.openChatBoxFor(_converse, sender_jid);
  1112. const chatbox = _converse.chatboxes.get(sender_jid);
  1113. _converse.windowState = 'hidden';
  1114. _converse.chatboxes.onMessage(msgFactory());
  1115. await test_utils.waitUntil(() => chatbox.messages.length);
  1116. expect(chatbox.get('num_unread')).toBe(1);
  1117. done();
  1118. }));
  1119. it("is incremeted when message is received, chatbox is scrolled up and the window is not focused",
  1120. mock.initConverseWithPromises(
  1121. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  1122. async function (done, _converse) {
  1123. test_utils.createContacts(_converse, 'current', 1);
  1124. _converse.emit('rosterContactsFetched');
  1125. const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  1126. const msgFactory = () => test_utils.createChatMessage(_converse, sender_jid, 'This message will be unread');
  1127. await test_utils.openChatBoxFor(_converse, sender_jid);
  1128. const chatbox = _converse.chatboxes.get(sender_jid);
  1129. chatbox.save('scrolled', true);
  1130. _converse.windowState = 'hidden';
  1131. _converse.chatboxes.onMessage(msgFactory());
  1132. await test_utils.waitUntil(() => chatbox.messages.length);
  1133. expect(chatbox.get('num_unread')).toBe(1);
  1134. done();
  1135. }));
  1136. it("is cleared when ChatBoxView was scrolled down and the window become focused",
  1137. mock.initConverseWithPromises(
  1138. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  1139. async function (done, _converse) {
  1140. test_utils.createContacts(_converse, 'current', 1);
  1141. _converse.emit('rosterContactsFetched');
  1142. const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  1143. const msgFactory = () => test_utils.createChatMessage(_converse, sender_jid, 'This message will be unread');
  1144. await test_utils.openChatBoxFor(_converse, sender_jid);
  1145. const chatbox = _converse.chatboxes.get(sender_jid);
  1146. _converse.windowState = 'hidden';
  1147. _converse.chatboxes.onMessage(msgFactory());
  1148. await test_utils.waitUntil(() => chatbox.messages.length);
  1149. expect(chatbox.get('num_unread')).toBe(1);
  1150. _converse.saveWindowState(null, 'focus');
  1151. expect(chatbox.get('num_unread')).toBe(0);
  1152. done();
  1153. }));
  1154. it("is not cleared when ChatBoxView was scrolled up and the windows become focused",
  1155. mock.initConverseWithPromises(
  1156. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  1157. async function (done, _converse) {
  1158. test_utils.createContacts(_converse, 'current');
  1159. _converse.emit('rosterContactsFetched');
  1160. const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  1161. const msgFactory = () => test_utils.createChatMessage(_converse, sender_jid, 'This message will be unread');
  1162. await test_utils.openChatBoxFor(_converse, sender_jid);
  1163. const chatbox = _converse.chatboxes.get(sender_jid);
  1164. chatbox.save('scrolled', true);
  1165. _converse.windowState = 'hidden';
  1166. _converse.chatboxes.onMessage(msgFactory());
  1167. await test_utils.waitUntil(() => chatbox.messages.length);
  1168. expect(chatbox.get('num_unread')).toBe(1);
  1169. _converse.saveWindowState(null, 'focus');
  1170. expect(chatbox.get('num_unread')).toBe(1);
  1171. done();
  1172. }));
  1173. });
  1174. describe("A RosterView's Unread Message Count", function () {
  1175. it("is updated when message is received and chatbox is scrolled up",
  1176. mock.initConverseWithPromises(
  1177. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  1178. async function (done, _converse) {
  1179. test_utils.createContacts(_converse, 'current');
  1180. _converse.emit('rosterContactsFetched');
  1181. let msg, indicator_el;
  1182. const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  1183. await test_utils.waitUntil(() => _converse.rosterview.el.querySelectorAll('.roster-group').length, 500);
  1184. await test_utils.openChatBoxFor(_converse, sender_jid);
  1185. const chatbox = _converse.chatboxes.get(sender_jid);
  1186. chatbox.save('scrolled', true);
  1187. msg = test_utils.createChatMessage(_converse, sender_jid, 'This message will be unread');
  1188. await _converse.chatboxes.onMessage(msg);
  1189. await test_utils.waitUntil(() => chatbox.messages.length);
  1190. const selector = 'a.open-chat:contains("' + chatbox.get('fullname') + '") .msgs-indicator';
  1191. indicator_el = sizzle(selector, _converse.rosterview.el).pop();
  1192. expect(indicator_el.textContent).toBe('1');
  1193. msg = test_utils.createChatMessage(_converse, sender_jid, 'This message will be unread too');
  1194. await _converse.chatboxes.onMessage(msg);
  1195. await test_utils.waitUntil(() => chatbox.messages.length > 1);
  1196. indicator_el = sizzle(selector, _converse.rosterview.el).pop();
  1197. expect(indicator_el.textContent).toBe('2');
  1198. done();
  1199. }));
  1200. it("is updated when message is received and chatbox is minimized",
  1201. mock.initConverseWithPromises(
  1202. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  1203. async function (done, _converse) {
  1204. test_utils.createContacts(_converse, 'current', 1);
  1205. _converse.emit('rosterContactsFetched');
  1206. const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  1207. let indicator_el, msg;
  1208. await test_utils.waitUntil(() => _converse.rosterview.el.querySelectorAll('.roster-group').length, 500);
  1209. await test_utils.openChatBoxFor(_converse, sender_jid);
  1210. const chatbox = _converse.chatboxes.get(sender_jid);
  1211. var chatboxview = _converse.chatboxviews.get(sender_jid);
  1212. chatboxview.minimize();
  1213. msg = test_utils.createChatMessage(_converse, sender_jid, 'This message will be unread');
  1214. await _converse.chatboxes.onMessage(msg);
  1215. await test_utils.waitUntil(() => chatbox.messages.length);
  1216. const selector = 'a.open-chat:contains("' + chatbox.get('fullname') + '") .msgs-indicator';
  1217. indicator_el = sizzle(selector, _converse.rosterview.el).pop();
  1218. expect(indicator_el.textContent).toBe('1');
  1219. msg = test_utils.createChatMessage(_converse, sender_jid, 'This message will be unread too');
  1220. await _converse.chatboxes.onMessage(msg);
  1221. await test_utils.waitUntil(() => chatbox.messages.length > 1);
  1222. indicator_el = sizzle(selector, _converse.rosterview.el).pop();
  1223. expect(indicator_el.textContent).toBe('2');
  1224. done();
  1225. }));
  1226. it("is cleared when chatbox is maximzied after receiving messages in minimized mode",
  1227. mock.initConverseWithPromises(
  1228. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  1229. async function (done, _converse) {
  1230. test_utils.createContacts(_converse, 'current', 1);
  1231. _converse.emit('rosterContactsFetched');
  1232. const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  1233. const msgFactory = () => test_utils.createChatMessage(_converse, sender_jid, 'This message will be received as unread, but eventually will be read');
  1234. await test_utils.waitUntil(() => _converse.rosterview.el.querySelectorAll('.roster-group').length, 500);
  1235. await test_utils.openChatBoxFor(_converse, sender_jid);
  1236. const chatbox = _converse.chatboxes.get(sender_jid);
  1237. const view = _converse.chatboxviews.get(sender_jid);
  1238. const msgsIndicatorSelector = 'a.open-chat:contains("' + chatbox.get('fullname') + '") .msgs-indicator';
  1239. const select_msgs_indicator = () => $(_converse.rosterview.el).find(msgsIndicatorSelector);
  1240. view.minimize();
  1241. _converse.chatboxes.onMessage(msgFactory());
  1242. await test_utils.waitUntil(() => chatbox.messages.length);
  1243. expect(select_msgs_indicator().text()).toBe('1');
  1244. _converse.chatboxes.onMessage(msgFactory());
  1245. await test_utils.waitUntil(() => chatbox.messages.length > 1);
  1246. expect(select_msgs_indicator().text()).toBe('2');
  1247. view.maximize();
  1248. expect(select_msgs_indicator().length).toBe(0);
  1249. done();
  1250. }));
  1251. it("is cleared when unread messages are viewed which were received in scrolled-up chatbox",
  1252. mock.initConverseWithPromises(
  1253. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  1254. async function (done, _converse) {
  1255. test_utils.createContacts(_converse, 'current', 1);
  1256. _converse.emit('rosterContactsFetched');
  1257. const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  1258. await test_utils.waitUntil(() => _converse.rosterview.el.querySelectorAll('.roster-group').length, 500);
  1259. await test_utils.openChatBoxFor(_converse, sender_jid);
  1260. const chatbox = _converse.chatboxes.get(sender_jid);
  1261. const view = _converse.chatboxviews.get(sender_jid);
  1262. const msgFactory = () => test_utils.createChatMessage(_converse, sender_jid, 'This message will be received as unread, but eventually will be read');
  1263. const msgsIndicatorSelector = 'a.open-chat:contains("' + chatbox.get('fullname') + '") .msgs-indicator';
  1264. const select_msgs_indicator = () => $(_converse.rosterview.el).find(msgsIndicatorSelector);
  1265. chatbox.save('scrolled', true);
  1266. _converse.chatboxes.onMessage(msgFactory());
  1267. await test_utils.waitUntil(() => view.model.messages.length);
  1268. expect(select_msgs_indicator().text()).toBe('1');
  1269. view.viewUnreadMessages();
  1270. _converse.rosterview.render();
  1271. expect(select_msgs_indicator().length).toBe(0);
  1272. done();
  1273. }));
  1274. it("is not cleared after user clicks on roster view when chatbox is already opened and scrolled up",
  1275. mock.initConverseWithPromises(
  1276. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  1277. async function (done, _converse) {
  1278. test_utils.createContacts(_converse, 'current');
  1279. _converse.emit('rosterContactsFetched');
  1280. const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  1281. await test_utils.waitUntil(() => _converse.rosterview.el.querySelectorAll('.roster-group').length, 500);
  1282. await test_utils.openChatBoxFor(_converse, sender_jid);
  1283. const chatbox = _converse.chatboxes.get(sender_jid);
  1284. const view = _converse.chatboxviews.get(sender_jid);
  1285. const msgFactory = function () {
  1286. return test_utils.createChatMessage(_converse, sender_jid, 'This message will be received as unread, but eventually will be read');
  1287. };
  1288. var msgsIndicatorSelector = 'a.open-chat:contains("' + chatbox.get('fullname') + '") .msgs-indicator';
  1289. const select_msgs_indicator = () => $(_converse.rosterview.el).find(msgsIndicatorSelector);
  1290. chatbox.save('scrolled', true);
  1291. _converse.chatboxes.onMessage(msgFactory());
  1292. await test_utils.waitUntil(() => view.model.messages.length);
  1293. expect(select_msgs_indicator().text()).toBe('1');
  1294. await test_utils.openChatBoxFor(_converse, sender_jid);
  1295. expect(select_msgs_indicator().text()).toBe('1');
  1296. done();
  1297. }));
  1298. });
  1299. describe("A Minimized ChatBoxView's Unread Message Count", function () {
  1300. it("is displayed when scrolled up chatbox is minimized after receiving unread messages",
  1301. mock.initConverseWithPromises(
  1302. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  1303. async function (done, _converse) {
  1304. test_utils.createContacts(_converse, 'current', 1);
  1305. _converse.emit('rosterContactsFetched');
  1306. const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  1307. await test_utils.openChatBoxFor(_converse, sender_jid);
  1308. const msgFactory = function () {
  1309. return test_utils.createChatMessage(_converse, sender_jid, 'This message will be received as unread, but eventually will be read');
  1310. };
  1311. const selectUnreadMsgCount = function () {
  1312. const minimizedChatBoxView = _converse.minimized_chats.get(sender_jid);
  1313. return minimizedChatBoxView.el.querySelector('.message-count');
  1314. };
  1315. const chatbox = _converse.chatboxes.get(sender_jid);
  1316. chatbox.save('scrolled', true);
  1317. _converse.chatboxes.onMessage(msgFactory());
  1318. await test_utils.waitUntil(() => chatbox.messages.length);
  1319. const chatboxview = _converse.chatboxviews.get(sender_jid);
  1320. chatboxview.minimize();
  1321. const unread_count = selectUnreadMsgCount();
  1322. expect(u.isVisible(unread_count)).toBeTruthy();
  1323. expect(unread_count.innerHTML).toBe('1');
  1324. done();
  1325. }));
  1326. it("is incremented when message is received and windows is not focused",
  1327. mock.initConverseWithPromises(
  1328. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  1329. async function (done, _converse) {
  1330. test_utils.createContacts(_converse, 'current');
  1331. _converse.emit('rosterContactsFetched');
  1332. const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  1333. const view = await test_utils.openChatBoxFor(_converse, sender_jid)
  1334. const msgFactory = function () {
  1335. return test_utils.createChatMessage(_converse, sender_jid,
  1336. 'This message will be received as unread, but eventually will be read');
  1337. };
  1338. const selectUnreadMsgCount = function () {
  1339. const minimizedChatBoxView = _converse.minimized_chats.get(sender_jid);
  1340. return minimizedChatBoxView.el.querySelector('.message-count');
  1341. };
  1342. view.minimize();
  1343. _converse.chatboxes.onMessage(msgFactory());
  1344. await test_utils.waitUntil(() => view.model.messages.length);
  1345. const unread_count = selectUnreadMsgCount();
  1346. expect(u.isVisible(unread_count)).toBeTruthy();
  1347. expect(unread_count.innerHTML).toBe('1');
  1348. done();
  1349. }));
  1350. it("will render Openstreetmap-URL from geo-URI",
  1351. mock.initConverseWithPromises(
  1352. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  1353. async function (done, _converse) {
  1354. test_utils.createContacts(_converse, 'current');
  1355. _converse.emit('rosterContactsFetched');
  1356. const base_url = document.URL.split(window.location.pathname)[0],
  1357. message = "geo:37.786971,-122.399677",
  1358. contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  1359. await test_utils.openChatBoxFor(_converse, contact_jid);
  1360. const view = _converse.chatboxviews.get(contact_jid);
  1361. spyOn(view.model, 'sendMessage').and.callThrough();
  1362. test_utils.sendMessage(view, message);
  1363. await test_utils.waitUntil(() => view.el.querySelectorAll('.chat-content .chat-msg').length, 1000);
  1364. expect(view.model.sendMessage).toHaveBeenCalled();
  1365. var msg = $(view.el).find('.chat-content').find('.chat-msg').last().find('.chat-msg__text');
  1366. expect(msg.html()).toEqual(
  1367. '<a target="_blank" rel="noopener" href="https://www.openstreetmap.org/?mlat=37.786971&amp;'+
  1368. 'mlon=-122.399677#map=18/37.786971/-122.399677">https://www.openstreetmap.org/?mlat=37.7869'+
  1369. '71&amp;mlon=-122.399677#map=18/37.786971/-122.399677</a>');
  1370. done();
  1371. }));
  1372. });
  1373. });
  1374. }));