Debian Codegraph @

packages/messaging/tests/src/index.spec.ts

raw
1 // Copyright (c) Jupyter Development Team.
2 // Distributed under the terms of the Modified BSD License.
3 /*-----------------------------------------------------------------------------
4 | Copyright (c) 2014-2017, PhosphorJS Contributors
5 |
6 | Distributed under the terms of the BSD 3-Clause License.
7 |
8 | The full license is in the file LICENSE, distributed with this software.
9 |----------------------------------------------------------------------------*/
10 import { expect } from 'chai';
11
12 import {
13 ConflatableMessage,
14 IMessageHandler,
15 IMessageHook,
16 Message,
17 MessageHook,
18 MessageLoop
19 } from '@lumino/messaging';
20
21 class Handler implements IMessageHandler {
22 messages: string[] = [];
23
24 processMessage(msg: Message): void {
25 this.messages.push(msg.type);
26 }
27 }
28
29 class BadHandler implements IMessageHandler {
30 processMessage(msg: Message): void {
31 throw new Error('process error');
32 }
33 }
34
35 class GlobalHandler extends Handler {
36 static messages: string[] = [];
37
38 processMessage(msg: Message): void {
39 super.processMessage(msg);
40 GlobalHandler.messages.push(msg.type);
41 }
42 }
43
44 class LogHook implements IMessageHook {
45 preventTypes: string[] = [];
46
47 messages: string[] = [];
48
49 handlers: IMessageHandler[] = [];
50
51 messageHook(handler: IMessageHandler, msg: Message): boolean {
52 this.messages.push(msg.type);
53 this.handlers.push(handler);
54 return this.preventTypes.indexOf(msg.type) === -1;
55 }
56 }
57
58 const defer = (() => {
59 let ok = typeof requestAnimationFrame === 'function';
60 return ok ? requestAnimationFrame : setImmediate;
61 })();
62
63 describe('@lumino/messaging', () => {
64 describe('Message', () => {
65 describe('#constructor()', () => {
66 it('should require a single message type argument', () => {
67 let msg = new Message('test');
68 expect(msg).to.be.an.instanceof(Message);
69 });
70 });
71
72 describe('#type', () => {
73 it('should return the message type', () => {
74 let msg = new Message('test');
75 expect(msg.type).to.equal('test');
76 });
77 });
78
79 describe('#isConflatable', () => {
80 it('should be `false` by default', () => {
81 let msg = new Message('test');
82 expect(msg.isConflatable).to.equal(false);
83 });
84 });
85
86 describe('#conflate()', () => {
87 it('should return `false` by default', () => {
88 let msg = new Message('test');
89 let other = new Message('test');
90 expect(msg.conflate(other)).to.equal(false);
91 });
92 });
93 });
94
95 describe('ConflatableMessage', () => {
96 describe('#constructor()', () => {
97 it('should require a single message type argument', () => {
98 let msg = new ConflatableMessage('test');
99 expect(msg).to.be.an.instanceof(ConflatableMessage);
100 });
101
102 it('should extend the base `Message` class', () => {
103 let msg = new ConflatableMessage('test');
104 expect(msg).to.be.an.instanceof(Message);
105 });
106 });
107
108 describe('#isConflatable', () => {
109 it('should be `true` by default', () => {
110 let msg = new ConflatableMessage('test');
111 expect(msg.isConflatable).to.equal(true);
112 });
113 });
114
115 describe('#conflate()', () => {
116 it('should return `true` by default', () => {
117 let msg = new ConflatableMessage('test');
118 let other = new ConflatableMessage('test');
119 expect(msg.conflate(other)).to.equal(true);
120 });
121 });
122 });
123
124 describe('IMessageHandler', () => {
125 describe('#processMessage()', () => {
126 it('should process the messages sent to the handler', () => {
127 let handler = new Handler();
128 MessageLoop.sendMessage(handler, new Message('one'));
129 MessageLoop.sendMessage(handler, new Message('two'));
130 MessageLoop.sendMessage(handler, new Message('three'));
131 expect(handler.messages).to.deep.equal(['one', 'two', 'three']);
132 });
133 });
134 });
135
136 describe('IMessageHook', () => {
137 describe('#messageHook()', () => {
138 it('should be called for every message sent to a handler', () => {
139 let handler = new Handler();
140 let logHook = new LogHook();
141 MessageLoop.installMessageHook(handler, logHook);
142 MessageLoop.sendMessage(handler, new Message('one'));
143 MessageLoop.sendMessage(handler, new Message('two'));
144 MessageLoop.sendMessage(handler, new Message('three'));
145 expect(handler.messages).to.deep.equal(['one', 'two', 'three']);
146 expect(logHook.messages).to.deep.equal(['one', 'two', 'three']);
147 expect(logHook.handlers.length).to.equal(3);
148 for (let i of [0, 1, 2]) {
149 expect(logHook.handlers[i]).to.equal(handler);
150 }
151 });
152
153 it('should block messages which do not pass the hook', () => {
154 let handler1 = new Handler();
155 let handler2 = new Handler();
156 let logHook = new LogHook();
157 logHook.preventTypes = ['one', 'two'];
158 MessageLoop.installMessageHook(handler1, logHook);
159 MessageLoop.installMessageHook(handler2, logHook);
160 MessageLoop.sendMessage(handler1, new Message('one'));
161 MessageLoop.sendMessage(handler2, new Message('one'));
162 MessageLoop.sendMessage(handler1, new Message('two'));
163 MessageLoop.sendMessage(handler2, new Message('two'));
164 MessageLoop.sendMessage(handler1, new Message('three'));
165 MessageLoop.sendMessage(handler2, new Message('three'));
166 expect(handler1.messages).to.deep.equal(['three']);
167 expect(handler2.messages).to.deep.equal(['three']);
168 expect(logHook.messages).to.deep.equal([
169 'one',
170 'one',
171 'two',
172 'two',
173 'three',
174 'three'
175 ]);
176 expect(logHook.handlers.length).to.equal(6);
177 for (let i of [0, 2, 4]) {
178 expect(logHook.handlers[i]).to.equal(handler1);
179 expect(logHook.handlers[i + 1]).to.equal(handler2);
180 }
181 });
182 });
183 });
184
185 describe('MessageLoop', () => {
186 describe('sendMessage()', () => {
187 it('should send a message to the handler to process immediately', () => {
188 let handler = new Handler();
189 expect(handler.messages).to.deep.equal([]);
190 MessageLoop.sendMessage(handler, new Message('one'));
191 expect(handler.messages).to.deep.equal(['one']);
192 MessageLoop.sendMessage(handler, new Message('two'));
193 expect(handler.messages).to.deep.equal(['one', 'two']);
194 });
195
196 it('should not conflate the message', () => {
197 let handler = new Handler();
198 let msg = new ConflatableMessage('one');
199 MessageLoop.sendMessage(handler, msg);
200 MessageLoop.sendMessage(handler, msg);
201 MessageLoop.sendMessage(handler, msg);
202 expect(handler.messages).to.deep.equal(['one', 'one', 'one']);
203 });
204
205 it('should first run the message through the message hooks', () => {
206 let handler = new Handler();
207 let logHook1 = new LogHook();
208 let logHook2 = new LogHook();
209 logHook1.preventTypes = ['one'];
210 logHook2.preventTypes = ['two'];
211 MessageLoop.installMessageHook(handler, logHook1);
212 MessageLoop.installMessageHook(handler, logHook2);
213 MessageLoop.sendMessage(handler, new Message('one'));
214 MessageLoop.sendMessage(handler, new Message('two'));
215 MessageLoop.sendMessage(handler, new Message('three'));
216 expect(handler.messages).to.deep.equal(['three']);
217 expect(logHook1.messages).to.deep.equal(['one', 'three']);
218 expect(logHook2.messages).to.deep.equal(['one', 'two', 'three']);
219 });
220
221 it('should stop dispatching on the first `false` hook result', () => {
222 let handler = new Handler();
223 let logHook1 = new LogHook();
224 let logHook2 = new LogHook();
225 let logHook3 = new LogHook();
226 logHook1.preventTypes = ['one'];
227 logHook2.preventTypes = ['one'];
228 logHook3.preventTypes = ['one'];
229 MessageLoop.installMessageHook(handler, logHook1);
230 MessageLoop.installMessageHook(handler, logHook2);
231 MessageLoop.installMessageHook(handler, logHook3);
232 MessageLoop.sendMessage(handler, new Message('one'));
233 MessageLoop.sendMessage(handler, new Message('two'));
234 MessageLoop.sendMessage(handler, new Message('three'));
235 expect(handler.messages).to.deep.equal(['two', 'three']);
236 expect(logHook1.messages).to.deep.equal(['two', 'three']);
237 expect(logHook2.messages).to.deep.equal(['two', 'three']);
238 expect(logHook3.messages).to.deep.equal(['one', 'two', 'three']);
239 });
240
241 it('should ignore exceptions in handlers', () => {
242 let handler = new BadHandler();
243 let msg = new Message('one');
244 expect(() => {
245 MessageLoop.sendMessage(handler, msg);
246 }).to.not.throw(Error);
247 });
248
249 it('should ignore exceptions in hooks', () => {
250 let handler = new Handler();
251 let msg = new Message('one');
252 MessageLoop.installMessageHook(handler, (): boolean => {
253 throw '';
254 });
255 expect(() => {
256 MessageLoop.sendMessage(handler, msg);
257 }).to.not.throw(Error);
258 });
259 });
260
261 describe('postMessage()', () => {
262 it('should post a message to the handler in the future', done => {
263 let handler = new Handler();
264 expect(handler.messages).to.deep.equal([]);
265 MessageLoop.postMessage(handler, new Message('one'));
266 MessageLoop.postMessage(handler, new Message('two'));
267 MessageLoop.postMessage(handler, new Message('three'));
268 expect(handler.messages).to.deep.equal([]);
269 defer(() => {
270 expect(handler.messages).to.deep.equal(['one', 'two', 'three']);
271 done();
272 });
273 });
274
275 it('should conflate a conflatable message', done => {
276 let handler = new Handler();
277 let one = new Message('one');
278 let two = new Message('two');
279 let three = new ConflatableMessage('three');
280 expect(handler.messages).to.deep.equal([]);
281 MessageLoop.postMessage(handler, one);
282 MessageLoop.postMessage(handler, two);
283 MessageLoop.postMessage(handler, three);
284 MessageLoop.postMessage(handler, three);
285 MessageLoop.postMessage(handler, three);
286 MessageLoop.postMessage(handler, three);
287 expect(handler.messages).to.deep.equal([]);
288 defer(() => {
289 expect(handler.messages).to.deep.equal(['one', 'two', 'three']);
290 done();
291 });
292 });
293
294 it('should not conflate a non-conflatable message', done => {
295 let handler = new Handler();
296 let cf1 = new Message('one');
297 let cf2 = new ConflatableMessage('one');
298 expect(handler.messages).to.deep.equal([]);
299 MessageLoop.postMessage(handler, cf1);
300 MessageLoop.postMessage(handler, cf2);
301 expect(handler.messages).to.deep.equal([]);
302 defer(() => {
303 expect(handler.messages).to.deep.equal(['one', 'one']);
304 done();
305 });
306 });
307
308 it('should not conflate messages for different handlers', done => {
309 let h1 = new Handler();
310 let h2 = new Handler();
311 let msg = new ConflatableMessage('one');
312 MessageLoop.postMessage(h1, msg);
313 MessageLoop.postMessage(h2, msg);
314 defer(() => {
315 expect(h1.messages).to.deep.equal(['one']);
316 expect(h2.messages).to.deep.equal(['one']);
317 done();
318 });
319 });
320
321 it('should obey global order of posted messages', done => {
322 let handler1 = new GlobalHandler();
323 let handler2 = new GlobalHandler();
324 let handler3 = new GlobalHandler();
325 MessageLoop.postMessage(handler3, new Message('one'));
326 MessageLoop.postMessage(handler1, new Message('two'));
327 MessageLoop.postMessage(handler2, new Message('three'));
328 MessageLoop.postMessage(handler1, new Message('A'));
329 MessageLoop.postMessage(handler2, new Message('B'));
330 MessageLoop.postMessage(handler3, new Message('C'));
331 expect(handler1.messages).to.deep.equal([]);
332 expect(handler2.messages).to.deep.equal([]);
333 expect(handler3.messages).to.deep.equal([]);
334 expect(GlobalHandler.messages).to.deep.equal([]);
335 defer(() => {
336 expect(GlobalHandler.messages).to.deep.equal([
337 'one',
338 'two',
339 'three',
340 'A',
341 'B',
342 'C'
343 ]);
344 expect(handler1.messages).to.deep.equal(['two', 'A']);
345 expect(handler2.messages).to.deep.equal(['three', 'B']);
346 expect(handler3.messages).to.deep.equal(['one', 'C']);
347 done();
348 });
349 });
350 });
351
352 describe('installMessageHook()', () => {
353 it('should install a hook for a handler', () => {
354 let handler = new Handler();
355 let logHook = new LogHook();
356 logHook.preventTypes = ['one'];
357 MessageLoop.installMessageHook(handler, logHook);
358 expect(handler.messages).to.deep.equal([]);
359 MessageLoop.sendMessage(handler, new Message('one'));
360 expect(handler.messages).to.deep.equal([]);
361 });
362
363 it('should install a new hook in front of any others', () => {
364 let handler = new Handler();
365 let logHook1 = new LogHook();
366 let logHook2 = new LogHook();
367 logHook1.preventTypes = ['one'];
368 logHook2.preventTypes = ['two'];
369 MessageLoop.installMessageHook(handler, logHook1);
370 MessageLoop.sendMessage(handler, new Message('two'));
371 MessageLoop.installMessageHook(handler, logHook2);
372 MessageLoop.sendMessage(handler, new Message('two'));
373 MessageLoop.sendMessage(handler, new Message('two'));
374 MessageLoop.sendMessage(handler, new Message('three'));
375 MessageLoop.sendMessage(handler, new Message('one'));
376 expect(handler.messages).to.deep.equal(['two', 'three']);
377 expect(logHook1.messages).to.deep.equal(['two', 'three', 'one']);
378 expect(logHook2.messages).to.deep.equal(['two', 'two', 'three', 'one']);
379 });
380
381 it('should not allow a hook to be installed multiple times', () => {
382 let handler = new Handler();
383 let logHook1 = new LogHook();
384 let logHook2 = new LogHook();
385 MessageLoop.installMessageHook(handler, logHook1);
386 MessageLoop.installMessageHook(handler, logHook2);
387 MessageLoop.installMessageHook(handler, logHook1);
388 MessageLoop.sendMessage(handler, new Message('one'));
389 MessageLoop.sendMessage(handler, new Message('two'));
390 expect(handler.messages).to.deep.equal(['one', 'two']);
391 expect(logHook1.messages).to.deep.equal(['one', 'two']);
392 expect(logHook2.messages).to.deep.equal(['one', 'two']);
393 });
394 });
395
396 describe('removeMessageHook()', () => {
397 it('should remove a previously installed hook', () => {
398 let handler = new Handler();
399 let logHook1 = new LogHook();
400 let logHook2 = new LogHook();
401 logHook1.preventTypes = ['one'];
402 logHook2.preventTypes = ['two'];
403 MessageLoop.sendMessage(handler, new Message('one'));
404 MessageLoop.sendMessage(handler, new Message('two'));
405 MessageLoop.installMessageHook(handler, logHook1);
406 MessageLoop.installMessageHook(handler, logHook2);
407 MessageLoop.sendMessage(handler, new Message('one'));
408 MessageLoop.sendMessage(handler, new Message('two'));
409 MessageLoop.removeMessageHook(handler, logHook2);
410 MessageLoop.removeMessageHook(handler, logHook1);
411 MessageLoop.sendMessage(handler, new Message('one'));
412 MessageLoop.sendMessage(handler, new Message('two'));
413 expect(handler.messages).to.deep.equal(['one', 'two', 'one', 'two']);
414 expect(logHook1.messages).to.deep.equal(['one']);
415 expect(logHook2.messages).to.deep.equal(['one', 'two']);
416 });
417
418 it('should be a no-op if the hook was not installed', () => {
419 let handler = new Handler();
420 let logHook = new LogHook();
421 logHook.preventTypes = ['one'];
422 MessageLoop.sendMessage(handler, new Message('one'));
423 MessageLoop.removeMessageHook(handler, logHook);
424 MessageLoop.sendMessage(handler, new Message('one'));
425 expect(handler.messages).to.deep.equal(['one', 'one']);
426 });
427
428 it('should be safe to remove a hook while dispatching', () => {
429 let handler = new Handler();
430 let logHook1 = new LogHook();
431 let logHook2 = new LogHook();
432 let logHook3 = new LogHook();
433 let remHook: MessageHook = (handler: IMessageHandler, msg: Message) => {
434 let result = logHook3.messageHook(handler, msg);
435 MessageLoop.removeMessageHook(handler, remHook);
436 return result;
437 };
438 MessageLoop.installMessageHook(handler, logHook1);
439 MessageLoop.installMessageHook(handler, remHook);
440 MessageLoop.installMessageHook(handler, logHook2);
441 MessageLoop.sendMessage(handler, new Message('one'));
442 MessageLoop.sendMessage(handler, new Message('two'));
443 MessageLoop.sendMessage(handler, new Message('three'));
444 expect(handler.messages).to.deep.equal(['one', 'two', 'three']);
445 expect(logHook1.messages).to.deep.equal(['one', 'two', 'three']);
446 expect(logHook3.messages).to.deep.equal(['one']);
447 expect(logHook2.messages).to.deep.equal(['one', 'two', 'three']);
448 });
449 });
450
451 describe('clearData()', () => {
452 it('should remove all message data associated with a handler', done => {
453 let h1 = new Handler();
454 let h2 = new Handler();
455 let logHook = new LogHook();
456 MessageLoop.installMessageHook(h1, logHook);
457 MessageLoop.postMessage(h1, new Message('one'));
458 MessageLoop.postMessage(h2, new Message('one'));
459 MessageLoop.postMessage(h1, new Message('two'));
460 MessageLoop.postMessage(h2, new Message('two'));
461 MessageLoop.postMessage(h1, new Message('three'));
462 MessageLoop.postMessage(h2, new Message('three'));
463 MessageLoop.clearData(h1);
464 defer(() => {
465 expect(h1.messages).to.deep.equal([]);
466 expect(h2.messages).to.deep.equal(['one', 'two', 'three']);
467 expect(logHook.messages).to.deep.equal([]);
468 done();
469 });
470 });
471 });
472
473 describe('flush()', () => {
474 it('should immediately process all posted messages', () => {
475 const expected = ['one', 'two', 'three', 'six', 'four', 'five'];
476 let h1 = new Handler();
477 let h2 = new Handler();
478 MessageLoop.postMessage(h1, new Message('one'));
479 MessageLoop.postMessage(h2, new Message('one'));
480 MessageLoop.postMessage(h1, new Message('two'));
481 MessageLoop.postMessage(h2, new Message('two'));
482 MessageLoop.postMessage(h1, new Message('three'));
483 MessageLoop.postMessage(h2, new Message('three'));
484
485 MessageLoop.flush();
486
487 MessageLoop.postMessage(h1, new Message('four'));
488 MessageLoop.postMessage(h2, new Message('four'));
489 MessageLoop.postMessage(h1, new Message('five'));
490 MessageLoop.postMessage(h2, new Message('five'));
491
492 MessageLoop.sendMessage(h1, new Message('six'));
493 MessageLoop.sendMessage(h2, new Message('six'));
494
495 MessageLoop.flush();
496
497 expect(h1.messages).to.deep.equal(expected);
498 expect(h2.messages).to.deep.equal(expected);
499 });
500
501 it('should ignore recursive calls', () => {
502 let h1 = new Handler();
503 let h2 = new Handler();
504
505 MessageLoop.installMessageHook(h1, (h, m) => {
506 if (m.type === 'two') {
507 MessageLoop.postMessage(h, new Message('four'));
508 MessageLoop.postMessage(h, new Message('five'));
509 MessageLoop.postMessage(h, new Message('six'));
510 MessageLoop.flush();
511 }
512 return true;
513 });
514
515 MessageLoop.postMessage(h1, new Message('one'));
516 MessageLoop.postMessage(h2, new Message('one'));
517 MessageLoop.postMessage(h1, new Message('two'));
518 MessageLoop.postMessage(h2, new Message('two'));
519 MessageLoop.postMessage(h1, new Message('three'));
520 MessageLoop.postMessage(h2, new Message('three'));
521
522 MessageLoop.flush();
523
524 expect(h1.messages).to.deep.equal(['one', 'two', 'three']);
525 expect(h2.messages).to.deep.equal(['one', 'two', 'three']);
526
527 MessageLoop.flush();
528
529 expect(h1.messages).to.deep.equal([
530 'one',
531 'two',
532 'three',
533 'four',
534 'five',
535 'six'
536 ]);
537 expect(h2.messages).to.deep.equal(['one', 'two', 'three']);
538 });
539 });
540
541 describe('getExceptionHandler()', () => {
542 it('should default to an exception handler', () => {
543 expect(MessageLoop.getExceptionHandler()).to.be.a('function');
544 });
545 });
546
547 describe('setExceptionHandler()', () => {
548 afterEach(() => {
549 MessageLoop.setExceptionHandler(console.error);
550 });
551
552 it('should set the exception handler', () => {
553 let handler = (err: Error) => {
554 console.error(err);
555 };
556 MessageLoop.setExceptionHandler(handler);
557 expect(MessageLoop.getExceptionHandler()).to.equal(handler);
558 });
559
560 it('should return the old exception handler', () => {
561 let handler = (err: Error) => {
562 console.error(err);
563 };
564 let old1 = MessageLoop.setExceptionHandler(handler);
565 let old2 = MessageLoop.setExceptionHandler(old1);
566 expect(old1).to.equal(console.error);
567 expect(old2).to.equal(handler);
568 });
569
570 it('should invoke the exception handler on a message handler exception', () => {
571 let called = false;
572 let handler = new BadHandler();
573 MessageLoop.setExceptionHandler(() => {
574 called = true;
575 });
576 expect(called).to.equal(false);
577 MessageLoop.sendMessage(handler, new Message('foo'));
578 expect(called).to.equal(true);
579 });
580
581 it('should invoke the exception handler on a message hook exception', () => {
582 let called = false;
583 let handler = new Handler();
584 MessageLoop.setExceptionHandler(() => {
585 called = true;
586 });
587 expect(called).to.equal(false);
588 MessageLoop.sendMessage(handler, new Message('foo'));
589 expect(called).to.equal(false);
590 MessageLoop.installMessageHook(handler, () => {
591 throw 'error';
592 });
593 expect(called).to.equal(false);
594 MessageLoop.sendMessage(handler, new Message('foo'));
595 expect(called).to.equal(true);
596 });
597 });
598 });
599 });