2
0

chatbox.js 90 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601
  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.initConverse(
  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.initConverse(
  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.initConverse(
  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.initConverse(
  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 = u.toStanza(`
  132. <message from="${sender_jid}"
  133. type="chat"
  134. to="dummy@localhost/resource">
  135. <body>Hey\nHave you heard the news?</body>
  136. </message>`);
  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.initConverse(
  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 = u.toStanza(`
  149. <message from="${sender_jid}"
  150. type="chat"
  151. to="dummy@localhost/resource">
  152. <composing xmlns="http://jabber.org/protocol/chatstates"/>
  153. </message>`);
  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.initConverse(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.initConverse(
  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.initConverse(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.initConverse(
  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.initConverse(
  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.initConverse(
  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.initConverse(
  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.initConverse(
  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.initConverse(
  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.initConverse(
  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("is ignored when it's a carbon copy of one of my own",
  457. mock.initConverse(
  458. null, ['rosterGroupsFetched'], {},
  459. async function (done, _converse) {
  460. test_utils.createContacts(_converse, 'current');
  461. test_utils.openControlBox();
  462. const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  463. await test_utils.openChatBoxFor(_converse, sender_jid);
  464. let stanza = u.toStanza(
  465. `<message from="${sender_jid}"
  466. type="chat"
  467. to="dummy@localhost/resource">
  468. <composing xmlns="http://jabber.org/protocol/chatstates"/>
  469. <no-store xmlns="urn:xmpp:hints"/>
  470. <no-permanent-store xmlns="urn:xmpp:hints"/>
  471. </message>`);
  472. _converse.connection._dataRecv(test_utils.createRequest(stanza));
  473. stanza = u.toStanza(
  474. `<message from="${sender_jid}"
  475. type="chat"
  476. to="dummy@localhost/resource">
  477. <paused xmlns="http://jabber.org/protocol/chatstates"/>
  478. <no-store xmlns="urn:xmpp:hints"/>
  479. <no-permanent-store xmlns="urn:xmpp:hints"/>
  480. </message>`);
  481. _converse.connection._dataRecv(test_utils.createRequest(stanza));
  482. done();
  483. }));
  484. it("does not open a new chatbox",
  485. mock.initConverse(
  486. null, ['rosterGroupsFetched'], {},
  487. async function (done, _converse) {
  488. test_utils.createContacts(_converse, 'current');
  489. test_utils.openControlBox();
  490. spyOn(_converse, 'emit');
  491. const sender_jid = mock.cur_names[1].replace(/ /g,'.').toLowerCase() + '@localhost';
  492. // <composing> state
  493. const msg = $msg({
  494. 'from': sender_jid,
  495. 'to': _converse.connection.jid,
  496. 'type': 'chat',
  497. 'id': (new Date()).getTime()
  498. }).c('composing', {'xmlns': Strophe.NS.CHATSTATES}).tree();
  499. await _converse.chatboxes.onMessage(msg);
  500. expect(_converse.emit).toHaveBeenCalledWith('message', jasmine.any(Object));
  501. done();
  502. }));
  503. describe("An active notification", function () {
  504. it("is sent when the user opens a chat box",
  505. mock.initConverse(
  506. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  507. async function (done, _converse) {
  508. test_utils.createContacts(_converse, 'current');
  509. _converse.emit('rosterContactsFetched');
  510. const contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  511. test_utils.openControlBox();
  512. test_utils.waitUntil(() => _converse.rosterview.el.querySelectorAll('.roster-group').length);
  513. spyOn(_converse.connection, 'send');
  514. await test_utils.openChatBoxFor(_converse, contact_jid);
  515. const view = _converse.chatboxviews.get(contact_jid);
  516. expect(view.model.get('chat_state')).toBe('active');
  517. expect(_converse.connection.send).toHaveBeenCalled();
  518. const $stanza = $(_converse.connection.send.calls.argsFor(0)[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. it("is sent when the user maximizes a minimized a chat box", mock.initConverse(
  527. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  528. async function (done, _converse) {
  529. test_utils.createContacts(_converse, 'current', 1);
  530. _converse.emit('rosterContactsFetched');
  531. test_utils.openControlBox();
  532. const contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  533. await test_utils.waitUntil(() => _converse.rosterview.el.querySelectorAll('.roster-group').length);
  534. await test_utils.openChatBoxFor(_converse, contact_jid);
  535. var view = _converse.chatboxviews.get(contact_jid);
  536. view.model.minimize();
  537. expect(view.model.get('chat_state')).toBe('inactive');
  538. spyOn(_converse.connection, 'send');
  539. view.model.maximize();
  540. await test_utils.waitUntil(() => view.model.get('chat_state') === 'active', 1000);
  541. expect(_converse.connection.send).toHaveBeenCalled();
  542. const calls = _.filter(_converse.connection.send.calls.all(), function (call) {
  543. return call.args[0] instanceof Strophe.Builder;
  544. });
  545. expect(calls.length).toBe(1);
  546. var $stanza = $(calls[0].args[0].tree());
  547. expect($stanza.attr('to')).toBe(contact_jid);
  548. expect($stanza.children().length).toBe(3);
  549. expect($stanza.children().get(0).tagName).toBe('active');
  550. expect($stanza.children().get(1).tagName).toBe('no-store');
  551. expect($stanza.children().get(2).tagName).toBe('no-permanent-store');
  552. done();
  553. }));
  554. });
  555. describe("A composing notification", function () {
  556. it("is sent as soon as the user starts typing a message which is not a command",
  557. mock.initConverse(
  558. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  559. async function (done, _converse) {
  560. test_utils.createContacts(_converse, 'current');
  561. _converse.emit('rosterContactsFetched');
  562. test_utils.openControlBox();
  563. const contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  564. await test_utils.waitUntil(() => _converse.rosterview.el.querySelectorAll('.roster-group').length);
  565. await test_utils.openChatBoxFor(_converse, contact_jid);
  566. var view = _converse.chatboxviews.get(contact_jid);
  567. expect(view.model.get('chat_state')).toBe('active');
  568. spyOn(_converse.connection, 'send');
  569. spyOn(_converse, 'emit');
  570. view.keyPressed({
  571. target: view.el.querySelector('textarea.chat-textarea'),
  572. keyCode: 1
  573. });
  574. expect(view.model.get('chat_state')).toBe('composing');
  575. expect(_converse.connection.send).toHaveBeenCalled();
  576. var $stanza = $(_converse.connection.send.calls.argsFor(0)[0].tree());
  577. expect($stanza.attr('to')).toBe(contact_jid);
  578. expect($stanza.children().get(0).tagName).toBe('composing');
  579. expect($stanza.children().get(1).tagName).toBe('no-store');
  580. expect($stanza.children().get(2).tagName).toBe('no-permanent-store');
  581. // The notification is not sent again
  582. view.keyPressed({
  583. target: view.el.querySelector('textarea.chat-textarea'),
  584. keyCode: 1
  585. });
  586. expect(view.model.get('chat_state')).toBe('composing');
  587. expect(_converse.emit.calls.count(), 1);
  588. done();
  589. }));
  590. it("will be shown if received",
  591. mock.initConverse(
  592. null, ['rosterGroupsFetched'], {},
  593. async function (done, _converse) {
  594. test_utils.createContacts(_converse, 'current');
  595. _converse.emit('rosterContactsFetched');
  596. test_utils.openControlBox();
  597. // See XEP-0085 http://xmpp.org/extensions/xep-0085.html#definitions
  598. spyOn(_converse, 'emit');
  599. const sender_jid = mock.cur_names[1].replace(/ /g,'.').toLowerCase() + '@localhost';
  600. await test_utils.waitUntil(() => _converse.rosterview.el.querySelectorAll('.roster-group').length);
  601. await test_utils.openChatBoxFor(_converse, sender_jid);
  602. // <composing> state
  603. let msg = $msg({
  604. from: sender_jid,
  605. to: _converse.connection.jid,
  606. type: 'chat',
  607. id: (new Date()).getTime()
  608. }).c('body').c('composing', {'xmlns': Strophe.NS.CHATSTATES}).tree();
  609. await _converse.chatboxes.onMessage(msg);
  610. expect(_converse.emit).toHaveBeenCalledWith('message', jasmine.any(Object));
  611. var view = _converse.chatboxviews.get(sender_jid);
  612. expect(view).toBeDefined();
  613. await test_utils.waitUntil(() => view.model.vcard.get('fullname') === mock.cur_names[1])
  614. // Check that the notification appears inside the chatbox in the DOM
  615. let events = view.el.querySelectorAll('.chat-state-notification');
  616. expect(events[0].textContent).toEqual(mock.cur_names[1] + ' is typing');
  617. // Check that it doesn't appear twice
  618. msg = $msg({
  619. from: sender_jid,
  620. to: _converse.connection.jid,
  621. type: 'chat',
  622. id: (new Date()).getTime()
  623. }).c('composing', {'xmlns': Strophe.NS.CHATSTATES}).tree();
  624. await _converse.chatboxes.onMessage(msg);
  625. events = view.el.querySelectorAll('.chat-state-notification');
  626. expect(events.length).toBe(1);
  627. expect(events[0].textContent).toEqual(mock.cur_names[1] + ' is typing');
  628. done();
  629. }));
  630. it("can be a composing carbon message that this user sent from a different client",
  631. mock.initConverse(
  632. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  633. async function (done, _converse) {
  634. let contact, sent_stanza, IQ_id, stanza;
  635. await test_utils.waitUntilDiscoConfirmed(_converse, 'localhost', [], ['vcard-temp']);
  636. await test_utils.waitUntil(() => _converse.xmppstatus.vcard.get('fullname'));
  637. test_utils.createContacts(_converse, 'current');
  638. _converse.emit('rosterContactsFetched');
  639. // Send a message from a different resource
  640. spyOn(_converse, 'log');
  641. const recipient_jid = mock.cur_names[5].replace(/ /g,'.').toLowerCase() + '@localhost';
  642. const view = await test_utils.openChatBoxFor(_converse, recipient_jid);
  643. var msg = $msg({
  644. 'from': _converse.bare_jid,
  645. 'id': (new Date()).getTime(),
  646. 'to': _converse.connection.jid,
  647. 'type': 'chat',
  648. 'xmlns': 'jabber:client'
  649. }).c('sent', {'xmlns': 'urn:xmpp:carbons:2'})
  650. .c('forwarded', {'xmlns': 'urn:xmpp:forward:0'})
  651. .c('message', {
  652. 'xmlns': 'jabber:client',
  653. 'from': _converse.bare_jid+'/another-resource',
  654. 'to': recipient_jid,
  655. 'type': 'chat'
  656. }).c('composing', {'xmlns': Strophe.NS.CHATSTATES}).tree();
  657. await _converse.chatboxes.onMessage(msg);
  658. await test_utils.waitUntil(() => view.model.messages.length);
  659. // Check that the chatbox and its view now exist
  660. var chatbox = _converse.chatboxes.get(recipient_jid);
  661. var chatboxview = _converse.chatboxviews.get(recipient_jid);
  662. // Check that the message was received and check the message parameters
  663. expect(chatbox.messages.length).toEqual(1);
  664. var msg_obj = chatbox.messages.models[0];
  665. expect(msg_obj.get('sender')).toEqual('me');
  666. expect(msg_obj.get('is_delayed')).toEqual(false);
  667. var $chat_content = $(chatboxview.el).find('.chat-content');
  668. var status_text = $chat_content.find('.chat-info.chat-state-notification').text();
  669. expect(status_text).toBe('Typing from another device');
  670. done();
  671. }));
  672. });
  673. describe("A paused notification", function () {
  674. it("is sent if the user has stopped typing since 30 seconds",
  675. mock.initConverse(
  676. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  677. async function (done, _converse) {
  678. test_utils.createContacts(_converse, 'current');
  679. _converse.emit('rosterContactsFetched');
  680. const contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  681. test_utils.openControlBox();
  682. await test_utils.waitUntil(() => _converse.rosterview.el.querySelectorAll('.roster-group li').length, 700);
  683. _converse.TIMEOUTS.PAUSED = 200; // Make the timeout shorter so that we can test
  684. await test_utils.openChatBoxFor(_converse, contact_jid);
  685. const view = _converse.chatboxviews.get(contact_jid);
  686. spyOn(_converse.connection, 'send');
  687. spyOn(view, 'setChatState').and.callThrough();
  688. expect(view.model.get('chat_state')).toBe('active');
  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. expect(_converse.connection.send).toHaveBeenCalled();
  695. let $stanza = $(_converse.connection.send.calls.argsFor(0)[0].tree());
  696. expect($stanza.children().get(0).tagName).toBe('composing');
  697. await test_utils.waitUntil(() => view.model.get('chat_state') === 'paused', 500);
  698. expect(_converse.connection.send).toHaveBeenCalled();
  699. var calls = _.filter(_converse.connection.send.calls.all(), function (call) {
  700. return call.args[0] instanceof Strophe.Builder;
  701. });
  702. expect(calls.length).toBe(2);
  703. $stanza = $(calls[1].args[0].tree());
  704. expect($stanza.attr('to')).toBe(contact_jid);
  705. expect($stanza.children().length).toBe(3);
  706. expect($stanza.children().get(0).tagName).toBe('paused');
  707. expect($stanza.children().get(1).tagName).toBe('no-store');
  708. expect($stanza.children().get(2).tagName).toBe('no-permanent-store');
  709. // Test #359. A paused notification should not be sent
  710. // out if the user simply types longer than the
  711. // timeout.
  712. view.keyPressed({
  713. target: view.el.querySelector('textarea.chat-textarea'),
  714. keyCode: 1
  715. });
  716. expect(view.setChatState).toHaveBeenCalled();
  717. expect(view.model.get('chat_state')).toBe('composing');
  718. view.keyPressed({
  719. target: view.el.querySelector('textarea.chat-textarea'),
  720. keyCode: 1
  721. });
  722. expect(view.model.get('chat_state')).toBe('composing');
  723. done();
  724. }));
  725. it("will be shown if received",
  726. mock.initConverse(
  727. null, ['rosterGroupsFetched'], {},
  728. async function (done, _converse) {
  729. test_utils.createContacts(_converse, 'current', 2);
  730. _converse.emit('rosterContactsFetched');
  731. test_utils.openControlBox();
  732. await test_utils.waitUntil(() => _converse.rosterview.el.querySelectorAll('.roster-group').length);
  733. // TODO: only show paused state if the previous state was composing
  734. // See XEP-0085 http://xmpp.org/extensions/xep-0085.html#definitions
  735. spyOn(_converse, 'emit').and.callThrough();
  736. const sender_jid = mock.cur_names[1].replace(/ /g,'.').toLowerCase() + '@localhost';
  737. const view = await test_utils.openChatBoxFor(_converse, sender_jid);
  738. // <paused> state
  739. const msg = $msg({
  740. from: sender_jid,
  741. to: _converse.connection.jid,
  742. type: 'chat',
  743. id: (new Date()).getTime()
  744. }).c('paused', {'xmlns': Strophe.NS.CHATSTATES}).tree();
  745. await _converse.chatboxes.onMessage(msg);
  746. expect(_converse.emit).toHaveBeenCalledWith('message', jasmine.any(Object));
  747. await test_utils.waitUntil(() => view.model.vcard.get('fullname') === mock.cur_names[1])
  748. var event = view.el.querySelector('.chat-info.chat-state-notification');
  749. expect(event.textContent).toEqual(mock.cur_names[1] + ' has stopped typing');
  750. done();
  751. }));
  752. it("can be a paused carbon message that this user sent from a different client",
  753. mock.initConverse(
  754. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  755. async function (done, _converse) {
  756. let contact, sent_stanza, IQ_id, stanza;
  757. await test_utils.waitUntilDiscoConfirmed(_converse, 'localhost', [], ['vcard-temp']);
  758. await test_utils.waitUntil(() => _converse.xmppstatus.vcard.get('fullname'));
  759. test_utils.createContacts(_converse, 'current', 6);
  760. _converse.emit('rosterContactsFetched');
  761. // Send a message from a different resource
  762. spyOn(_converse, 'log');
  763. const recipient_jid = mock.cur_names[5].replace(/ /g,'.').toLowerCase() + '@localhost';
  764. const view = await test_utils.openChatBoxFor(_converse, recipient_jid);
  765. const msg = $msg({
  766. 'from': _converse.bare_jid,
  767. 'id': (new Date()).getTime(),
  768. 'to': _converse.connection.jid,
  769. 'type': 'chat',
  770. 'xmlns': 'jabber:client'
  771. }).c('sent', {'xmlns': 'urn:xmpp:carbons:2'})
  772. .c('forwarded', {'xmlns': 'urn:xmpp:forward:0'})
  773. .c('message', {
  774. 'xmlns': 'jabber:client',
  775. 'from': _converse.bare_jid+'/another-resource',
  776. 'to': recipient_jid,
  777. 'type': 'chat'
  778. }).c('paused', {'xmlns': Strophe.NS.CHATSTATES}).tree();
  779. await _converse.chatboxes.onMessage(msg);
  780. await test_utils.waitUntil(() => view.model.messages.length);
  781. // Check that the chatbox and its view now exist
  782. var chatbox = _converse.chatboxes.get(recipient_jid);
  783. var chatboxview = _converse.chatboxviews.get(recipient_jid);
  784. // Check that the message was received and check the message parameters
  785. expect(chatbox.messages.length).toEqual(1);
  786. var msg_obj = chatbox.messages.models[0];
  787. expect(msg_obj.get('sender')).toEqual('me');
  788. expect(msg_obj.get('is_delayed')).toEqual(false);
  789. var $chat_content = $(chatboxview.el).find('.chat-content');
  790. var status_text = $chat_content.find('.chat-info.chat-state-notification').text();
  791. expect(status_text).toBe('Stopped typing on the other device');
  792. done();
  793. }));
  794. });
  795. describe("An inactive notifciation", function () {
  796. it("is sent if the user has stopped typing since 2 minutes",
  797. mock.initConverse(
  798. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  799. async function (done, _converse) {
  800. // Make the timeouts shorter so that we can test
  801. _converse.TIMEOUTS.PAUSED = 200;
  802. _converse.TIMEOUTS.INACTIVE = 200;
  803. test_utils.createContacts(_converse, 'current');
  804. _converse.emit('rosterContactsFetched');
  805. const contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  806. test_utils.openControlBox();
  807. await test_utils.waitUntil(() => _converse.rosterview.el.querySelectorAll('.roster-group').length, 1000);
  808. await test_utils.openChatBoxFor(_converse, contact_jid);
  809. const view = _converse.chatboxviews.get(contact_jid);
  810. await test_utils.waitUntil(() => view.model.get('chat_state') === 'active', 1000);
  811. console.log('chat_state set to active');
  812. expect(view.model.get('chat_state')).toBe('active');
  813. view.keyPressed({
  814. target: view.el.querySelector('textarea.chat-textarea'),
  815. keyCode: 1
  816. });
  817. await test_utils.waitUntil(() => view.model.get('chat_state') === 'composing', 500);
  818. console.log('chat_state set to composing');
  819. expect(view.model.get('chat_state')).toBe('composing');
  820. spyOn(_converse.connection, 'send');
  821. await test_utils.waitUntil(() => view.model.get('chat_state') === 'paused', 1000);
  822. await test_utils.waitUntil(() => view.model.get('chat_state') === 'inactive', 1000);
  823. console.log('chat_state set to inactive');
  824. expect(_converse.connection.send).toHaveBeenCalled();
  825. var calls = _.filter(_converse.connection.send.calls.all(), function (call) {
  826. return call.args[0] instanceof Strophe.Builder;
  827. });
  828. expect(calls.length).toBe(2);
  829. var stanza = calls[0].args[0].tree();
  830. expect(stanza.getAttribute('to')).toBe(contact_jid);
  831. expect(stanza.children.length).toBe(3);
  832. expect(stanza.children[0].tagName).toBe('paused');
  833. expect(stanza.children[1].tagName).toBe('no-store');
  834. expect(stanza.children[2].tagName).toBe('no-permanent-store');
  835. stanza = _converse.connection.send.calls.mostRecent().args[0].tree();
  836. expect(stanza.getAttribute('to')).toBe(contact_jid);
  837. expect(stanza.children.length).toBe(3);
  838. expect(stanza.children[0].tagName).toBe('inactive');
  839. expect(stanza.children[1].tagName).toBe('no-store');
  840. expect(stanza.children[2].tagName).toBe('no-permanent-store');
  841. done();
  842. }));
  843. it("is sent when the user a minimizes a chat box",
  844. mock.initConverse(
  845. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  846. async function (done, _converse) {
  847. test_utils.createContacts(_converse, 'current', 1);
  848. _converse.emit('rosterContactsFetched');
  849. test_utils.openControlBox();
  850. const contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  851. await test_utils.openChatBoxFor(_converse, contact_jid);
  852. const view = _converse.chatboxviews.get(contact_jid);
  853. spyOn(_converse.connection, 'send');
  854. view.minimize();
  855. expect(view.model.get('chat_state')).toBe('inactive');
  856. expect(_converse.connection.send).toHaveBeenCalled();
  857. var $stanza = $(_converse.connection.send.calls.argsFor(0)[0].tree());
  858. expect($stanza.attr('to')).toBe(contact_jid);
  859. expect($stanza.children().get(0).tagName).toBe('inactive');
  860. done();
  861. }));
  862. it("is sent if the user closes a chat box",
  863. mock.initConverse(
  864. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  865. async function (done, _converse) {
  866. test_utils.createContacts(_converse, 'current');
  867. _converse.emit('rosterContactsFetched');
  868. const contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  869. test_utils.openControlBox();
  870. await test_utils.waitUntil(() => _converse.rosterview.el.querySelectorAll('.roster-group').length);
  871. const view = await test_utils.openChatBoxFor(_converse, contact_jid);
  872. expect(view.model.get('chat_state')).toBe('active');
  873. spyOn(_converse.connection, 'send');
  874. view.close();
  875. expect(view.model.get('chat_state')).toBe('inactive');
  876. expect(_converse.connection.send).toHaveBeenCalled();
  877. var $stanza = $(_converse.connection.send.calls.argsFor(0)[0].tree());
  878. expect($stanza.attr('to')).toBe(contact_jid);
  879. expect($stanza.children().length).toBe(3);
  880. expect($stanza.children().get(0).tagName).toBe('inactive');
  881. expect($stanza.children().get(1).tagName).toBe('no-store');
  882. expect($stanza.children().get(2).tagName).toBe('no-permanent-store');
  883. done();
  884. }));
  885. it("will clear any other chat status notifications",
  886. mock.initConverse(
  887. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  888. async function (done, _converse) {
  889. test_utils.createContacts(_converse, 'current');
  890. _converse.emit('rosterContactsFetched');
  891. test_utils.openControlBox();
  892. const sender_jid = mock.cur_names[1].replace(/ /g,'.').toLowerCase() + '@localhost';
  893. // See XEP-0085 http://xmpp.org/extensions/xep-0085.html#definitions
  894. spyOn(_converse, 'emit');
  895. await test_utils.openChatBoxFor(_converse, sender_jid);
  896. const view = _converse.chatboxviews.get(sender_jid);
  897. expect(view.el.querySelectorAll('.chat-event').length).toBe(0);
  898. // Insert <composing> message, to also check that
  899. // text messages are inserted correctly with
  900. // temporary chat events in the chat contents.
  901. let msg = $msg({
  902. 'to': _converse.bare_jid,
  903. 'xmlns': 'jabber:client',
  904. 'from': sender_jid,
  905. 'type': 'chat'})
  906. .c('composing', {'xmlns': Strophe.NS.CHATSTATES}).up()
  907. .tree();
  908. await _converse.chatboxes.onMessage(msg);
  909. await test_utils.waitUntil(() => view.model.messages.length);
  910. expect(view.el.querySelectorAll('.chat-state-notification').length).toBe(1);
  911. msg = $msg({
  912. from: sender_jid,
  913. to: _converse.connection.jid,
  914. type: 'chat',
  915. id: (new Date()).getTime()
  916. }).c('body').c('inactive', {'xmlns': Strophe.NS.CHATSTATES}).tree();
  917. await _converse.chatboxes.onMessage(msg);
  918. await test_utils.waitUntil(() => (view.model.messages.length > 1));
  919. expect(_converse.emit).toHaveBeenCalledWith('message', jasmine.any(Object));
  920. expect(view.el.querySelectorAll('.chat-state-notification').length).toBe(0);
  921. done();
  922. }));
  923. });
  924. describe("A gone notifciation", function () {
  925. it("will be shown if received",
  926. mock.initConverse(
  927. null, ['rosterGroupsFetched'], {},
  928. async function (done, _converse) {
  929. test_utils.createContacts(_converse, 'current', 3);
  930. test_utils.openControlBox();
  931. spyOn(_converse, 'emit');
  932. const sender_jid = mock.cur_names[1].replace(/ /g,'.').toLowerCase() + '@localhost';
  933. // <paused> state
  934. const msg = $msg({
  935. from: sender_jid,
  936. to: _converse.connection.jid,
  937. type: 'chat',
  938. id: (new Date()).getTime()
  939. }).c('body').c('gone', {'xmlns': Strophe.NS.CHATSTATES}).tree();
  940. await _converse.chatboxes.onMessage(msg);
  941. expect(_converse.emit).toHaveBeenCalledWith('message', jasmine.any(Object));
  942. const view = _converse.chatboxviews.get(sender_jid);
  943. await test_utils.waitUntil(() => view.model.vcard.get('fullname') === mock.cur_names[1]);
  944. const event = view.el.querySelector('.chat-state-notification');
  945. expect(event.textContent).toEqual(mock.cur_names[1] + ' has gone away');
  946. done();
  947. }));
  948. });
  949. });
  950. });
  951. describe("Special Messages", function () {
  952. it("'/clear' can be used to clear messages in a conversation",
  953. mock.initConverse(
  954. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  955. async function (done, _converse) {
  956. test_utils.createContacts(_converse, 'current');
  957. _converse.emit('rosterContactsFetched');
  958. test_utils.openControlBox();
  959. const contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  960. spyOn(_converse, 'emit');
  961. await test_utils.openChatBoxFor(_converse, contact_jid);
  962. const view = _converse.chatboxviews.get(contact_jid);
  963. let message = 'This message is another sent from this chatbox';
  964. await test_utils.sendMessage(view, message);
  965. expect(view.model.messages.length > 0).toBeTruthy();
  966. expect(view.model.messages.browserStorage.records.length > 0).toBeTruthy();
  967. await test_utils.waitUntil(() => view.el.querySelector('.chat-msg'));
  968. message = '/clear';
  969. spyOn(view, 'clearMessages').and.callThrough();
  970. spyOn(window, 'confirm').and.callFake(function () {
  971. return true;
  972. });
  973. view.el.querySelector('.chat-textarea').value = message;
  974. view.keyPressed({
  975. target: view.el.querySelector('textarea.chat-textarea'),
  976. preventDefault: _.noop,
  977. keyCode: 13
  978. });
  979. expect(view.clearMessages).toHaveBeenCalled();
  980. expect(window.confirm).toHaveBeenCalled();
  981. expect(view.model.messages.length, 0); // The messages must be removed from the chatbox
  982. expect(view.model.messages.browserStorage.records.length, 0); // And also from browserStorage
  983. expect(_converse.emit.calls.count(), 1);
  984. expect(_converse.emit.calls.mostRecent().args, ['messageSend', message]);
  985. done();
  986. }));
  987. });
  988. describe("A Message Counter", function () {
  989. it("is incremented when the message is received and the window is not focused",
  990. mock.initConverse(
  991. null, ['rosterGroupsFetched'], {},
  992. async function (done, _converse) {
  993. test_utils.createContacts(_converse, 'current', 1);
  994. _converse.emit('rosterContactsFetched');
  995. test_utils.openControlBox();
  996. expect(_converse.msg_counter).toBe(0);
  997. const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  998. const view = await test_utils.openChatBoxFor(_converse, sender_jid)
  999. const previous_state = _converse.windowState;
  1000. const message = 'This message will increment the message counter';
  1001. const msg = $msg({
  1002. from: sender_jid,
  1003. to: _converse.connection.jid,
  1004. type: 'chat',
  1005. id: (new Date()).getTime()
  1006. }).c('body').t(message).up()
  1007. .c('active', {'xmlns': Strophe.NS.CHATSTATES}).tree();
  1008. _converse.windowState = 'hidden';
  1009. spyOn(_converse, 'emit').and.callThrough();
  1010. spyOn(_converse, 'incrementMsgCounter').and.callThrough();
  1011. spyOn(_converse, 'clearMsgCounter').and.callThrough();
  1012. await _converse.chatboxes.onMessage(msg);
  1013. await new Promise((resolve, reject) => view.once('messageInserted', resolve));
  1014. expect(_converse.incrementMsgCounter).toHaveBeenCalled();
  1015. expect(_converse.clearMsgCounter).not.toHaveBeenCalled();
  1016. expect(_converse.msg_counter).toBe(1);
  1017. expect(_converse.emit).toHaveBeenCalledWith('message', jasmine.any(Object));
  1018. _converse.windowSate = previous_state;
  1019. done();
  1020. }));
  1021. it("is cleared when the window is focused",
  1022. mock.initConverse(
  1023. null, ['rosterGroupsFetched'], {},
  1024. function (done, _converse) {
  1025. test_utils.createContacts(_converse, 'current');
  1026. test_utils.openControlBox();
  1027. _converse.windowState = 'hidden';
  1028. spyOn(_converse, 'clearMsgCounter').and.callThrough();
  1029. _converse.saveWindowState(null, 'focus');
  1030. _converse.saveWindowState(null, 'blur');
  1031. expect(_converse.clearMsgCounter).toHaveBeenCalled();
  1032. done();
  1033. }));
  1034. it("is not incremented when the message is received and the window is focused",
  1035. mock.initConverse(
  1036. null, ['rosterGroupsFetched'], {},
  1037. async function (done, _converse) {
  1038. test_utils.createContacts(_converse, 'current');
  1039. test_utils.openControlBox();
  1040. expect(_converse.msg_counter).toBe(0);
  1041. spyOn(_converse, 'incrementMsgCounter').and.callThrough();
  1042. _converse.saveWindowState(null, 'focus');
  1043. const message = 'This message will not increment the message counter';
  1044. const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost',
  1045. msg = $msg({
  1046. from: sender_jid,
  1047. to: _converse.connection.jid,
  1048. type: 'chat',
  1049. id: (new Date()).getTime()
  1050. }).c('body').t(message).up()
  1051. .c('active', {'xmlns': Strophe.NS.CHATSTATES}).tree();
  1052. await _converse.chatboxes.onMessage(msg);
  1053. expect(_converse.incrementMsgCounter).not.toHaveBeenCalled();
  1054. expect(_converse.msg_counter).toBe(0);
  1055. done();
  1056. }));
  1057. it("is incremented from zero when chatbox was closed after viewing previously received messages and the window is not focused now",
  1058. mock.initConverse(
  1059. null, ['rosterGroupsFetched'], {},
  1060. async function (done, _converse) {
  1061. test_utils.createContacts(_converse, 'current');
  1062. // initial state
  1063. expect(_converse.msg_counter).toBe(0);
  1064. const message = 'This message will always increment the message counter from zero',
  1065. sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost',
  1066. msgFactory = function () {
  1067. return $msg({
  1068. from: sender_jid,
  1069. to: _converse.connection.jid,
  1070. type: 'chat',
  1071. id: (new Date()).getTime()
  1072. })
  1073. .c('body').t(message).up()
  1074. .c('active', {'xmlns': Strophe.NS.CHATSTATES})
  1075. .tree();
  1076. };
  1077. // leave converse-chat page
  1078. _converse.windowState = 'hidden';
  1079. _converse.chatboxes.onMessage(msgFactory());
  1080. await test_utils.waitUntil(() => _converse.api.chats.get().length)
  1081. let view = _converse.chatboxviews.get(sender_jid);
  1082. await new Promise((resolve, reject) => view.once('messageInserted', resolve));
  1083. expect(_converse.msg_counter).toBe(1);
  1084. // come back to converse-chat page
  1085. _converse.saveWindowState(null, 'focus');
  1086. expect(u.isVisible(view.el)).toBeTruthy();
  1087. expect(_converse.msg_counter).toBe(0);
  1088. // close chatbox and leave converse-chat page again
  1089. view.close();
  1090. _converse.windowState = 'hidden';
  1091. // check that msg_counter is incremented from zero again
  1092. _converse.chatboxes.onMessage(msgFactory());
  1093. await test_utils.waitUntil(() => _converse.api.chats.get().length)
  1094. view = _converse.chatboxviews.get(sender_jid);
  1095. await new Promise((resolve, reject) => view.once('messageInserted', resolve));
  1096. expect(u.isVisible(view.el)).toBeTruthy();
  1097. expect(_converse.msg_counter).toBe(1);
  1098. done();
  1099. }));
  1100. });
  1101. describe("A ChatBox's Unread Message Count", function () {
  1102. it("is incremented when the message is received and ChatBoxView is scrolled up",
  1103. mock.initConverse(
  1104. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  1105. async function (done, _converse) {
  1106. test_utils.createContacts(_converse, 'current');
  1107. _converse.emit('rosterContactsFetched');
  1108. const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost',
  1109. msg = test_utils.createChatMessage(_converse, sender_jid, 'This message will be unread');
  1110. const view = await test_utils.openChatBoxFor(_converse, sender_jid)
  1111. view.model.save('scrolled', true);
  1112. await _converse.chatboxes.onMessage(msg);
  1113. await test_utils.waitUntil(() => view.model.messages.length);
  1114. expect(view.model.get('num_unread')).toBe(1);
  1115. done();
  1116. }));
  1117. it("is not incremented when the message is received and ChatBoxView is scrolled down",
  1118. mock.initConverse(
  1119. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  1120. async function (done, _converse) {
  1121. test_utils.createContacts(_converse, 'current', 1);
  1122. _converse.emit('rosterContactsFetched');
  1123. const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost',
  1124. msg = test_utils.createChatMessage(_converse, sender_jid, 'This message will be read');
  1125. await test_utils.openChatBoxFor(_converse, sender_jid);
  1126. const chatbox = _converse.chatboxes.get(sender_jid);
  1127. await _converse.chatboxes.onMessage(msg);
  1128. expect(chatbox.get('num_unread')).toBe(0);
  1129. done();
  1130. }));
  1131. it("is incremeted when message is received, chatbox is scrolled down and the window is not focused",
  1132. mock.initConverse(null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  1133. async function (done, _converse) {
  1134. test_utils.createContacts(_converse, 'current');
  1135. _converse.emit('rosterContactsFetched');
  1136. const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  1137. const msgFactory = function () {
  1138. return test_utils.createChatMessage(_converse, sender_jid, 'This message will be unread');
  1139. };
  1140. await test_utils.openChatBoxFor(_converse, sender_jid);
  1141. const chatbox = _converse.chatboxes.get(sender_jid);
  1142. _converse.windowState = 'hidden';
  1143. _converse.chatboxes.onMessage(msgFactory());
  1144. await test_utils.waitUntil(() => chatbox.messages.length);
  1145. expect(chatbox.get('num_unread')).toBe(1);
  1146. done();
  1147. }));
  1148. it("is incremeted when message is received, chatbox is scrolled up and the window is not focused",
  1149. mock.initConverse(
  1150. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  1151. async function (done, _converse) {
  1152. test_utils.createContacts(_converse, 'current', 1);
  1153. _converse.emit('rosterContactsFetched');
  1154. const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  1155. const msgFactory = () => test_utils.createChatMessage(_converse, sender_jid, 'This message will be unread');
  1156. await test_utils.openChatBoxFor(_converse, sender_jid);
  1157. const chatbox = _converse.chatboxes.get(sender_jid);
  1158. chatbox.save('scrolled', true);
  1159. _converse.windowState = 'hidden';
  1160. _converse.chatboxes.onMessage(msgFactory());
  1161. await test_utils.waitUntil(() => chatbox.messages.length);
  1162. expect(chatbox.get('num_unread')).toBe(1);
  1163. done();
  1164. }));
  1165. it("is cleared when ChatBoxView was scrolled down and the window become focused",
  1166. mock.initConverse(
  1167. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  1168. async function (done, _converse) {
  1169. test_utils.createContacts(_converse, 'current', 1);
  1170. _converse.emit('rosterContactsFetched');
  1171. const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  1172. const msgFactory = () => test_utils.createChatMessage(_converse, sender_jid, 'This message will be unread');
  1173. await test_utils.openChatBoxFor(_converse, sender_jid);
  1174. const chatbox = _converse.chatboxes.get(sender_jid);
  1175. _converse.windowState = 'hidden';
  1176. _converse.chatboxes.onMessage(msgFactory());
  1177. await test_utils.waitUntil(() => chatbox.messages.length);
  1178. expect(chatbox.get('num_unread')).toBe(1);
  1179. _converse.saveWindowState(null, 'focus');
  1180. expect(chatbox.get('num_unread')).toBe(0);
  1181. done();
  1182. }));
  1183. it("is not cleared when ChatBoxView was scrolled up and the windows become focused",
  1184. mock.initConverse(
  1185. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  1186. async function (done, _converse) {
  1187. test_utils.createContacts(_converse, 'current');
  1188. _converse.emit('rosterContactsFetched');
  1189. const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  1190. const msgFactory = () => test_utils.createChatMessage(_converse, sender_jid, 'This message will be unread');
  1191. await test_utils.openChatBoxFor(_converse, sender_jid);
  1192. const chatbox = _converse.chatboxes.get(sender_jid);
  1193. chatbox.save('scrolled', true);
  1194. _converse.windowState = 'hidden';
  1195. _converse.chatboxes.onMessage(msgFactory());
  1196. await test_utils.waitUntil(() => chatbox.messages.length);
  1197. expect(chatbox.get('num_unread')).toBe(1);
  1198. _converse.saveWindowState(null, 'focus');
  1199. expect(chatbox.get('num_unread')).toBe(1);
  1200. done();
  1201. }));
  1202. });
  1203. describe("A RosterView's Unread Message Count", function () {
  1204. it("is updated when message is received and chatbox is scrolled up",
  1205. mock.initConverse(
  1206. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  1207. async function (done, _converse) {
  1208. test_utils.createContacts(_converse, 'current');
  1209. _converse.emit('rosterContactsFetched');
  1210. let msg, indicator_el;
  1211. const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  1212. await test_utils.waitUntil(() => _converse.rosterview.el.querySelectorAll('.roster-group').length, 500);
  1213. await test_utils.openChatBoxFor(_converse, sender_jid);
  1214. const chatbox = _converse.chatboxes.get(sender_jid);
  1215. chatbox.save('scrolled', true);
  1216. msg = test_utils.createChatMessage(_converse, sender_jid, 'This message will be unread');
  1217. await _converse.chatboxes.onMessage(msg);
  1218. await test_utils.waitUntil(() => chatbox.messages.length);
  1219. const selector = 'a.open-chat:contains("' + chatbox.get('fullname') + '") .msgs-indicator';
  1220. indicator_el = sizzle(selector, _converse.rosterview.el).pop();
  1221. expect(indicator_el.textContent).toBe('1');
  1222. msg = test_utils.createChatMessage(_converse, sender_jid, 'This message will be unread too');
  1223. await _converse.chatboxes.onMessage(msg);
  1224. await test_utils.waitUntil(() => chatbox.messages.length > 1);
  1225. indicator_el = sizzle(selector, _converse.rosterview.el).pop();
  1226. expect(indicator_el.textContent).toBe('2');
  1227. done();
  1228. }));
  1229. it("is updated when message is received and chatbox is minimized",
  1230. mock.initConverse(
  1231. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  1232. async function (done, _converse) {
  1233. test_utils.createContacts(_converse, 'current', 1);
  1234. _converse.emit('rosterContactsFetched');
  1235. const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  1236. let indicator_el, msg;
  1237. await test_utils.waitUntil(() => _converse.rosterview.el.querySelectorAll('.roster-group').length, 500);
  1238. await test_utils.openChatBoxFor(_converse, sender_jid);
  1239. const chatbox = _converse.chatboxes.get(sender_jid);
  1240. var chatboxview = _converse.chatboxviews.get(sender_jid);
  1241. chatboxview.minimize();
  1242. msg = test_utils.createChatMessage(_converse, sender_jid, 'This message will be unread');
  1243. await _converse.chatboxes.onMessage(msg);
  1244. await test_utils.waitUntil(() => chatbox.messages.length);
  1245. const selector = 'a.open-chat:contains("' + chatbox.get('fullname') + '") .msgs-indicator';
  1246. indicator_el = sizzle(selector, _converse.rosterview.el).pop();
  1247. expect(indicator_el.textContent).toBe('1');
  1248. msg = test_utils.createChatMessage(_converse, sender_jid, 'This message will be unread too');
  1249. await _converse.chatboxes.onMessage(msg);
  1250. await test_utils.waitUntil(() => chatbox.messages.length > 1);
  1251. indicator_el = sizzle(selector, _converse.rosterview.el).pop();
  1252. expect(indicator_el.textContent).toBe('2');
  1253. done();
  1254. }));
  1255. it("is cleared when chatbox is maximzied after receiving messages in minimized mode",
  1256. mock.initConverse(
  1257. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  1258. async function (done, _converse) {
  1259. test_utils.createContacts(_converse, 'current', 1);
  1260. _converse.emit('rosterContactsFetched');
  1261. const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  1262. const msgFactory = () => test_utils.createChatMessage(_converse, sender_jid, 'This message will be received as unread, but eventually will be read');
  1263. await test_utils.waitUntil(() => _converse.rosterview.el.querySelectorAll('.roster-group').length, 500);
  1264. await test_utils.openChatBoxFor(_converse, sender_jid);
  1265. const chatbox = _converse.chatboxes.get(sender_jid);
  1266. const view = _converse.chatboxviews.get(sender_jid);
  1267. const msgsIndicatorSelector = 'a.open-chat:contains("' + chatbox.get('fullname') + '") .msgs-indicator';
  1268. const select_msgs_indicator = () => $(_converse.rosterview.el).find(msgsIndicatorSelector);
  1269. view.minimize();
  1270. _converse.chatboxes.onMessage(msgFactory());
  1271. await test_utils.waitUntil(() => chatbox.messages.length);
  1272. expect(select_msgs_indicator().text()).toBe('1');
  1273. _converse.chatboxes.onMessage(msgFactory());
  1274. await test_utils.waitUntil(() => chatbox.messages.length > 1);
  1275. expect(select_msgs_indicator().text()).toBe('2');
  1276. view.maximize();
  1277. expect(select_msgs_indicator().length).toBe(0);
  1278. done();
  1279. }));
  1280. it("is cleared when unread messages are viewed which were received in scrolled-up chatbox",
  1281. mock.initConverse(
  1282. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  1283. async function (done, _converse) {
  1284. test_utils.createContacts(_converse, 'current', 1);
  1285. _converse.emit('rosterContactsFetched');
  1286. const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  1287. await test_utils.waitUntil(() => _converse.rosterview.el.querySelectorAll('.roster-group').length, 500);
  1288. await test_utils.openChatBoxFor(_converse, sender_jid);
  1289. const chatbox = _converse.chatboxes.get(sender_jid);
  1290. const view = _converse.chatboxviews.get(sender_jid);
  1291. const msgFactory = () => test_utils.createChatMessage(_converse, sender_jid, 'This message will be received as unread, but eventually will be read');
  1292. const msgsIndicatorSelector = 'a.open-chat:contains("' + chatbox.get('fullname') + '") .msgs-indicator';
  1293. const select_msgs_indicator = () => $(_converse.rosterview.el).find(msgsIndicatorSelector);
  1294. chatbox.save('scrolled', true);
  1295. _converse.chatboxes.onMessage(msgFactory());
  1296. await test_utils.waitUntil(() => view.model.messages.length);
  1297. expect(select_msgs_indicator().text()).toBe('1');
  1298. view.viewUnreadMessages();
  1299. _converse.rosterview.render();
  1300. expect(select_msgs_indicator().length).toBe(0);
  1301. done();
  1302. }));
  1303. it("is not cleared after user clicks on roster view when chatbox is already opened and scrolled up",
  1304. mock.initConverse(
  1305. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  1306. async function (done, _converse) {
  1307. test_utils.createContacts(_converse, 'current');
  1308. _converse.emit('rosterContactsFetched');
  1309. const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  1310. await test_utils.waitUntil(() => _converse.rosterview.el.querySelectorAll('.roster-group').length, 500);
  1311. await test_utils.openChatBoxFor(_converse, sender_jid);
  1312. const chatbox = _converse.chatboxes.get(sender_jid);
  1313. const view = _converse.chatboxviews.get(sender_jid);
  1314. const msgFactory = function () {
  1315. return test_utils.createChatMessage(_converse, sender_jid, 'This message will be received as unread, but eventually will be read');
  1316. };
  1317. var msgsIndicatorSelector = 'a.open-chat:contains("' + chatbox.get('fullname') + '") .msgs-indicator';
  1318. const select_msgs_indicator = () => $(_converse.rosterview.el).find(msgsIndicatorSelector);
  1319. chatbox.save('scrolled', true);
  1320. _converse.chatboxes.onMessage(msgFactory());
  1321. await test_utils.waitUntil(() => view.model.messages.length);
  1322. expect(select_msgs_indicator().text()).toBe('1');
  1323. await test_utils.openChatBoxFor(_converse, sender_jid);
  1324. expect(select_msgs_indicator().text()).toBe('1');
  1325. done();
  1326. }));
  1327. });
  1328. describe("A Minimized ChatBoxView's Unread Message Count", function () {
  1329. it("is displayed when scrolled up chatbox is minimized after receiving unread messages",
  1330. mock.initConverse(
  1331. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  1332. async function (done, _converse) {
  1333. test_utils.createContacts(_converse, 'current', 1);
  1334. _converse.emit('rosterContactsFetched');
  1335. const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  1336. await test_utils.openChatBoxFor(_converse, sender_jid);
  1337. const msgFactory = function () {
  1338. return test_utils.createChatMessage(_converse, sender_jid, 'This message will be received as unread, but eventually will be read');
  1339. };
  1340. const selectUnreadMsgCount = function () {
  1341. const minimizedChatBoxView = _converse.minimized_chats.get(sender_jid);
  1342. return minimizedChatBoxView.el.querySelector('.message-count');
  1343. };
  1344. const chatbox = _converse.chatboxes.get(sender_jid);
  1345. chatbox.save('scrolled', true);
  1346. _converse.chatboxes.onMessage(msgFactory());
  1347. await test_utils.waitUntil(() => chatbox.messages.length);
  1348. const chatboxview = _converse.chatboxviews.get(sender_jid);
  1349. chatboxview.minimize();
  1350. const unread_count = selectUnreadMsgCount();
  1351. expect(u.isVisible(unread_count)).toBeTruthy();
  1352. expect(unread_count.innerHTML).toBe('1');
  1353. done();
  1354. }));
  1355. it("is incremented when message is received and windows is not focused",
  1356. mock.initConverse(
  1357. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  1358. async function (done, _converse) {
  1359. test_utils.createContacts(_converse, 'current');
  1360. _converse.emit('rosterContactsFetched');
  1361. const sender_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  1362. const view = await test_utils.openChatBoxFor(_converse, sender_jid)
  1363. const msgFactory = function () {
  1364. return test_utils.createChatMessage(_converse, sender_jid,
  1365. 'This message will be received as unread, but eventually will be read');
  1366. };
  1367. const selectUnreadMsgCount = function () {
  1368. const minimizedChatBoxView = _converse.minimized_chats.get(sender_jid);
  1369. return minimizedChatBoxView.el.querySelector('.message-count');
  1370. };
  1371. view.minimize();
  1372. _converse.chatboxes.onMessage(msgFactory());
  1373. await test_utils.waitUntil(() => view.model.messages.length);
  1374. const unread_count = selectUnreadMsgCount();
  1375. expect(u.isVisible(unread_count)).toBeTruthy();
  1376. expect(unread_count.innerHTML).toBe('1');
  1377. done();
  1378. }));
  1379. it("will render Openstreetmap-URL from geo-URI",
  1380. mock.initConverse(
  1381. null, ['rosterGroupsFetched', 'chatBoxesFetched'], {},
  1382. async function (done, _converse) {
  1383. test_utils.createContacts(_converse, 'current');
  1384. _converse.emit('rosterContactsFetched');
  1385. const base_url = document.URL.split(window.location.pathname)[0],
  1386. message = "geo:37.786971,-122.399677",
  1387. contact_jid = mock.cur_names[0].replace(/ /g,'.').toLowerCase() + '@localhost';
  1388. await test_utils.openChatBoxFor(_converse, contact_jid);
  1389. const view = _converse.chatboxviews.get(contact_jid);
  1390. spyOn(view.model, 'sendMessage').and.callThrough();
  1391. test_utils.sendMessage(view, message);
  1392. await test_utils.waitUntil(() => view.el.querySelectorAll('.chat-content .chat-msg').length, 1000);
  1393. expect(view.model.sendMessage).toHaveBeenCalled();
  1394. var msg = $(view.el).find('.chat-content').find('.chat-msg').last().find('.chat-msg__text');
  1395. expect(msg.html()).toEqual(
  1396. '<a target="_blank" rel="noopener" href="https://www.openstreetmap.org/?mlat=37.786971&amp;'+
  1397. 'mlon=-122.399677#map=18/37.786971/-122.399677">https://www.openstreetmap.org/?mlat=37.7869'+
  1398. '71&amp;mlon=-122.399677#map=18/37.786971/-122.399677</a>');
  1399. done();
  1400. }));
  1401. });
  1402. });
  1403. }));