@coasys/ad4m 0.13.1-staging.4 → 0.13.1-staging.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (63) hide show
  1. package/lib/index.cjs +807 -275
  2. package/lib/index.js +804 -276
  3. package/lib/src/Ad4mClient.d.ts +6 -0
  4. package/lib/src/Ad4mClient.js +8 -0
  5. package/lib/src/apiClient.d.ts +32 -0
  6. package/lib/src/apiClient.js +132 -13
  7. package/lib/src/generated/api/AgentMessage.d.ts +10 -0
  8. package/lib/src/generated/api/AgentMessage.js +2 -0
  9. package/lib/src/generated/api/AgentReply.d.ts +9 -0
  10. package/lib/src/generated/api/AgentReply.js +2 -0
  11. package/lib/src/generated/api/RpcMethods.d.ts +6 -0
  12. package/lib/src/generated/api/RpcMethods.js +1 -0
  13. package/lib/src/generated/api/RunAgentRequest.d.ts +26 -0
  14. package/lib/src/generated/api/RunAgentRequest.js +1 -0
  15. package/lib/src/generated/api/index.d.ts +3 -0
  16. package/lib/src/index.d.ts +1 -0
  17. package/lib/src/index.js +1 -0
  18. package/lib/src/model/Ad4mModel.d.ts +7 -0
  19. package/lib/src/model/Ad4mModel.js +16 -13
  20. package/lib/src/model/ModelQueryBuilder.d.ts +2 -0
  21. package/lib/src/model/ModelQueryBuilder.js +36 -57
  22. package/lib/src/model/types.d.ts +6 -0
  23. package/lib/src/neighbourhood/SfuManager.d.ts +15 -0
  24. package/lib/src/neighbourhood/SfuManager.js +39 -2
  25. package/lib/src/perspectives/LiveQuery.d.ts +40 -4
  26. package/lib/src/perspectives/LiveQuery.js +94 -10
  27. package/lib/src/perspectives/Mentioning.d.ts +37 -0
  28. package/lib/src/perspectives/Mentioning.js +58 -0
  29. package/lib/src/perspectives/PerspectiveClient.d.ts +26 -2
  30. package/lib/src/perspectives/PerspectiveClient.js +19 -4
  31. package/lib/src/perspectives/PerspectiveProxy.d.ts +34 -3
  32. package/lib/src/perspectives/PerspectiveProxy.js +52 -16
  33. package/lib/src/perspectives/TextContent.d.ts +4 -0
  34. package/lib/src/perspectives/TextContent.js +4 -0
  35. package/lib/src/perspectives/WakerSubscriptionManager.d.ts +104 -12
  36. package/lib/src/perspectives/WakerSubscriptionManager.js +252 -66
  37. package/package.json +2 -2
  38. package/src/Ad4mClient.ts +9 -0
  39. package/src/apiClient.test.ts +467 -3
  40. package/src/apiClient.ts +133 -13
  41. package/src/generated/api/AgentMessage.ts +10 -0
  42. package/src/generated/api/AgentReply.ts +10 -0
  43. package/src/generated/api/RpcMethods.ts +4 -0
  44. package/src/generated/api/RunAgentRequest.ts +26 -0
  45. package/src/generated/api/index.ts +3 -0
  46. package/src/index.ts +1 -0
  47. package/src/model/Ad4mModel.test.ts +128 -364
  48. package/src/model/Ad4mModel.ts +16 -17
  49. package/src/model/ModelQueryBuilder.ts +39 -59
  50. package/src/model/types.ts +6 -0
  51. package/src/model/write-round-trips.test.ts +215 -0
  52. package/src/neighbourhood/SfuManager.test.ts +151 -2
  53. package/src/neighbourhood/SfuManager.ts +38 -1
  54. package/src/perspectives/LiveQuery.test.ts +173 -1
  55. package/src/perspectives/LiveQuery.ts +110 -10
  56. package/src/perspectives/Mentioning.test.ts +78 -0
  57. package/src/perspectives/Mentioning.ts +42 -0
  58. package/src/perspectives/PerspectiveClient.ts +36 -4
  59. package/src/perspectives/PerspectiveProxy.test.ts +24 -2
  60. package/src/perspectives/PerspectiveProxy.ts +61 -16
  61. package/src/perspectives/TextContent.ts +4 -0
  62. package/src/perspectives/WakerSubscriptionManager.test.ts +608 -152
  63. package/src/perspectives/WakerSubscriptionManager.ts +313 -67
@@ -17,6 +17,11 @@ class TestSocket {
17
17
  static autoOpen = false
18
18
  /** Fire onclose some time after close(), like browsers and `ws`. */
19
19
  static asyncClose = false
20
+ /** close() never fires onclose: a dead TCP connection, whose close frame
21
+ * no peer answers, can stay CLOSING for minutes. */
22
+ static closeHangs = false
23
+ /** Answer `ping` with `pong`, as the executor does while calls run. */
24
+ static answersPings = true
20
25
 
21
26
  readyState = 0
22
27
  sent: AnyMsg[] = []
@@ -29,9 +34,17 @@ class TestSocket {
29
34
  TestSocket.instances.push(this)
30
35
  if (TestSocket.autoOpen) queueMicrotask(() => this.open())
31
36
  }
32
- send(data: string) { this.sent.push(JSON.parse(data)) }
37
+ send(data: string) {
38
+ const msg = JSON.parse(data)
39
+ this.sent.push(msg)
40
+ if (msg.type === 'ping' && TestSocket.answersPings) {
41
+ queueMicrotask(() => { if (this.readyState === 1) this.reply({ type: 'pong' }) })
42
+ }
43
+ }
33
44
  close() {
34
- if (TestSocket.asyncClose) {
45
+ if (TestSocket.closeHangs) {
46
+ this.readyState = 2
47
+ } else if (TestSocket.asyncClose) {
35
48
  this.readyState = 2
36
49
  setTimeout(() => this.drop(), 5)
37
50
  } else {
@@ -56,6 +69,8 @@ beforeEach(() => {
56
69
  TestSocket.instances = []
57
70
  TestSocket.autoOpen = true
58
71
  TestSocket.asyncClose = false
72
+ TestSocket.closeHangs = false
73
+ TestSocket.answersPings = true
59
74
  client = new ApiClient(url, undefined, TestSocket as unknown as new (url: string) => WebSocket)
60
75
  })
61
76
  afterEach(() => client.closeAll())
@@ -305,6 +320,191 @@ describe('ApiClient retries idempotent reads once after a reconnect', () => {
305
320
  })
306
321
  })
307
322
 
323
+ describe('ApiClient notices a socket that went silent', () => {
324
+ // A network switch leaves the old socket OPEN: no FIN or RST ever arrives,
325
+ // so no close event comes, and nothing the client sends gets an answer.
326
+ beforeEach(() => {
327
+ TestSocket.autoOpen = false
328
+ TestSocket.closeHangs = true
329
+ TestSocket.answersPings = false
330
+ jest.useFakeTimers()
331
+ })
332
+ afterEach(() => jest.useRealTimers())
333
+
334
+ it('drops a socket whose ping goes unanswered and redials; a pending write fails, a pending read is resent', async () => {
335
+ open()
336
+ socket(0).open()
337
+ const write = outcomeOf(call('perspective.addLink', { uuid: 'u' }, { timeoutMs: 120_000 }))
338
+ const read = call<string[]>('perspective.all', {}, { timeoutMs: 120_000 })
339
+ expect(socket(0).sent.map(m => m.type)).toEqual(['events.watch', 'perspective.addLink', 'perspective.all'])
340
+
341
+ // Silent from here on: no pong, no reply, no close event.
342
+ await jest.advanceTimersByTimeAsync(20_000)
343
+ expect(socket(0).sent.some(m => m.type === 'ping')).toBe(true)
344
+ expect(socket(0).readyState).toBe(2)
345
+ expect(write()).toMatchObject({ name: 'RpcError', status: 503 })
346
+
347
+ await jest.advanceTimersByTimeAsync(500)
348
+ expect(TestSocket.instances).toHaveLength(2)
349
+ socket(1).open()
350
+ const sent = socket(1).sent.map(m => m.type)
351
+ expect(sent).toContain('events.watch')
352
+ expect(sent).toContain('perspective.all')
353
+ socket(1).reply({ id: socket(1).sent.find(m => m.type === 'perspective.all')!.id, result: ['p'] })
354
+ await expect(read).resolves.toEqual(['p'])
355
+
356
+ const next = call<number>('agent.status')
357
+ socket(1).reply({ id: socket(1).sent.at(-1)!.id, result: 1 })
358
+ await expect(next).resolves.toBe(1)
359
+
360
+ // The dead socket's close event, if it ever comes, leaves its successor alone.
361
+ socket(0).drop()
362
+ await jest.advanceTimersByTimeAsync(1_000)
363
+ expect(TestSocket.instances).toHaveLength(2)
364
+ expect(socket(1).readyState).toBe(1)
365
+ })
366
+
367
+ it('keeps a socket while a large write it sent may still be crossing a slow link', async () => {
368
+ // The executor reads a ping only after the frame sent before it, so a
369
+ // 600 kB write on a slow link holds the pong back for as long as the
370
+ // write takes. That silence is not a dead socket.
371
+ open()
372
+ socket(0).open()
373
+ const write = call<string>('perspective.addLink', { uuid: 'u', blob: 'x'.repeat(600_000) }, { timeoutMs: 120_000 })
374
+ await jest.advanceTimersByTimeAsync(30_000)
375
+ expect(TestSocket.instances).toHaveLength(1)
376
+ expect(socket(0).readyState).toBe(1)
377
+ socket(0).reply({ id: socket(0).sent.find(m => m.type === 'perspective.addLink')!.id, result: 'done' })
378
+ await expect(write).resolves.toBe('done')
379
+ // Once heard from, the socket is held to the usual deadline again.
380
+ await jest.advanceTimersByTimeAsync(20_000)
381
+ expect(socket(0).readyState).toBe(2)
382
+ })
383
+
384
+ it('counts a write in the UTF-8 bytes it is sent as, not in characters', async () => {
385
+ // 300 000 two-byte characters go out as 600 kB.
386
+ open()
387
+ socket(0).open()
388
+ void call('perspective.addLink', { uuid: 'u', blob: 'é'.repeat(300_000) }, { timeoutMs: 120_000 }).catch(() => {})
389
+ await jest.advanceTimersByTimeAsync(30_000)
390
+ expect(socket(0).readyState).toBe(1)
391
+ })
392
+
393
+ it('keeps the time a large write needs when other messages come in while it is still going out', async () => {
394
+ // Hearing from the executor says nothing about how far the upload got:
395
+ // a 600 kB write takes 37.5 s at 16 kB/s, whatever arrives meanwhile.
396
+ open()
397
+ socket(0).open()
398
+ const write = outcomeOf(call('perspective.addLink', { uuid: 'u', blob: 'x'.repeat(600_000) }, { timeoutMs: 120_000 }))
399
+ await jest.advanceTimersByTimeAsync(1_000)
400
+ socket(0).reply({ type: 'agent-updated' })
401
+ await jest.advanceTimersByTimeAsync(14_000)
402
+ socket(0).reply({ type: 'agent-updated' })
403
+ await jest.advanceTimersByTimeAsync(15_000)
404
+ expect(socket(0).readyState).toBe(1)
405
+ expect(write()).toBe('pending')
406
+ // The ping could reach the executor at 37.5 s; its pong gets 5 s more to come back.
407
+ await jest.advanceTimersByTimeAsync(10_000)
408
+ expect(socket(0).readyState).toBe(1)
409
+ // Still unanswered at the next tick: dropped.
410
+ await jest.advanceTimersByTimeAsync(10_000)
411
+ expect(socket(0).readyState).toBe(2)
412
+ expect(write()).toMatchObject({ name: 'RpcError', status: 503 })
413
+ })
414
+
415
+ it('gives a ping that waited behind a large write time for its pong to come back', async () => {
416
+ // The write could have crossed at about 39.94 s, just before the 40 s tick.
417
+ // The ping after it is read then, and its pong comes back 100 ms later.
418
+ open()
419
+ socket(0).open()
420
+ const write = outcomeOf(call('perspective.addLink', { uuid: 'u', blob: 'x'.repeat(638_900) }, { timeoutMs: 120_000 }))
421
+ await jest.advanceTimersByTimeAsync(40_040)
422
+ expect(socket(0).readyState).toBe(1)
423
+ socket(0).reply({ type: 'pong' })
424
+ await jest.advanceTimersByTimeAsync(15_000)
425
+ expect(socket(0).readyState).toBe(1)
426
+ expect(write()).toBe('pending')
427
+ })
428
+
429
+ it('does not give a silent socket more time for what it sent after its unanswered ping', async () => {
430
+ // Those frames queue behind the ping, so they cannot delay its pong.
431
+ open()
432
+ socket(0).open()
433
+ for (let t = 0; t < 20_000; t += 2_000) {
434
+ call('perspective.addLink', { uuid: 'u', blob: 'x'.repeat(20_000) }, { timeoutMs: 120_000 })
435
+ await jest.advanceTimersByTimeAsync(2_000)
436
+ }
437
+ expect(socket(0).readyState).toBe(2)
438
+ })
439
+
440
+ it('judges a new socket by its own pings, not by its predecessor\'s', async () => {
441
+ open()
442
+ socket(0).open()
443
+ await jest.advanceTimersByTimeAsync(20_000)
444
+ expect(socket(0).readyState).toBe(2)
445
+ await jest.advanceTimersByTimeAsync(500)
446
+ socket(1).open()
447
+ // Its first tick pings; nothing has gone unanswered on it yet.
448
+ await jest.advanceTimersByTimeAsync(10_000)
449
+ expect(socket(1).sent.some(m => m.type === 'ping')).toBe(true)
450
+ expect(socket(1).readyState).toBe(1)
451
+ })
452
+
453
+ it('pings a quiet socket before it counts as silent, even when the timer fires late', async () => {
454
+ // A socket with no traffic hears nothing until its first ping is answered.
455
+ // Silence is counted from that ping, not from the last message.
456
+ open()
457
+ socket(0).open()
458
+ await jest.advanceTimersByTimeAsync(9_990)
459
+ // The interval fires 40 ms late.
460
+ const now = performance.now.bind(performance)
461
+ const late = jest.spyOn(performance, 'now').mockImplementation(() => now() + 50)
462
+ try {
463
+ await jest.advanceTimersByTimeAsync(10)
464
+ expect(socket(0).sent.some(m => m.type === 'ping')).toBe(true)
465
+ expect(socket(0).readyState).toBe(1)
466
+ // Unanswered for a whole interval after that ping: dropped.
467
+ await jest.advanceTimersByTimeAsync(10_000)
468
+ expect(socket(0).readyState).toBe(2)
469
+ } finally {
470
+ late.mockRestore()
471
+ }
472
+ })
473
+
474
+ it('ignores events that reach a socket after it was dropped', async () => {
475
+ const seen = jest.fn()
476
+ client.on('agent-updated', seen)
477
+ open()
478
+ socket(0).open()
479
+ await jest.advanceTimersByTimeAsync(20_000)
480
+ expect(socket(0).readyState).toBe(2)
481
+ socket(0).reply({ type: 'agent-updated' })
482
+ expect(seen).not.toHaveBeenCalled()
483
+ })
484
+
485
+ it('keeps a socket that answers its pings or sends anything else', async () => {
486
+ open()
487
+ socket(0).open()
488
+ // Replies by hand: a pong after some pings, an event after the others.
489
+ for (let i = 0; i < 6; i++) {
490
+ await jest.advanceTimersByTimeAsync(10_000)
491
+ if (i % 2 === 0) socket(0).reply({ type: 'pong' })
492
+ else socket(0).reply({ type: 'agent-updated' })
493
+ }
494
+ expect(TestSocket.instances).toHaveLength(1)
495
+ expect(socket(0).readyState).toBe(1)
496
+ })
497
+
498
+ it('leaves no timers after closeAll on an open socket', async () => {
499
+ const promise = call('agent.status')
500
+ socket(0).open()
501
+ socket(0).reply({ id: socket(0).sent[0].id, result: 1 })
502
+ await promise
503
+ client.closeAll()
504
+ expect(jest.getTimerCount()).toBe(0)
505
+ })
506
+ })
507
+
308
508
  describe('ApiClient.onReconnect', () => {
309
509
  beforeEach(() => { TestSocket.autoOpen = false })
310
510
 
@@ -343,6 +543,269 @@ describe('ApiClient.onReconnect', () => {
343
543
  })
344
544
  })
345
545
 
546
+ /** An event target that counts the listeners on it, as `window` or `document`. */
547
+ class CountingTarget extends EventTarget {
548
+ listeners = new Map<string, number>()
549
+ visibilityState = 'hidden'
550
+ addEventListener(type: string, listener: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean) {
551
+ this.listeners.set(type, (this.listeners.get(type) ?? 0) + 1)
552
+ super.addEventListener(type, listener, options)
553
+ }
554
+ removeEventListener(type: string, listener: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean) {
555
+ this.listeners.set(type, (this.listeners.get(type) ?? 0) - 1)
556
+ super.removeEventListener(type, listener, options)
557
+ }
558
+ /** Listeners added and not removed, of every type. */
559
+ get live() { return [...this.listeners.values()].reduce((a, b) => a + b, 0) }
560
+ }
561
+
562
+ describe('ApiClient.reconnectNow', () => {
563
+ beforeEach(() => {
564
+ TestSocket.autoOpen = false
565
+ jest.useFakeTimers()
566
+ })
567
+ afterEach(() => jest.useRealTimers())
568
+
569
+ /** Open socket 0, then drop `drops` sockets in a row, so the client waits out a grown backoff. */
570
+ function backOff(drops: number) {
571
+ open()
572
+ socket(0).open()
573
+ socket(0).drop()
574
+ for (let i = 1; i < drops; i++) {
575
+ jest.advanceTimersByTime(30_000)
576
+ socket(i).drop()
577
+ }
578
+ }
579
+
580
+ it('dials at once instead of waiting out the backoff, and fires onReconnect', () => {
581
+ const reconnected = jest.fn()
582
+ client.onReconnect(reconnected)
583
+ backOff(5) // now waiting 8 s
584
+ const before = TestSocket.instances.length
585
+ client.reconnectNow()
586
+ expect(TestSocket.instances).toHaveLength(before + 1)
587
+ socket(before).open()
588
+ expect(reconnected).toHaveBeenCalledTimes(1)
589
+ // The wait it cut short does not dial again later: one loop, no second timer.
590
+ jest.advanceTimersByTime(60_000)
591
+ expect(TestSocket.instances).toHaveLength(before + 1)
592
+ // The backoff starts over: the next drop is retried after 500 ms.
593
+ socket(before).drop()
594
+ jest.advanceTimersByTime(499)
595
+ expect(TestSocket.instances).toHaveLength(before + 1)
596
+ jest.advanceTimersByTime(1)
597
+ expect(TestSocket.instances).toHaveLength(before + 2)
598
+ })
599
+
600
+ it('keeps backing off from the start when the dial it made fails too', () => {
601
+ backOff(5)
602
+ const before = TestSocket.instances.length
603
+ client.reconnectNow()
604
+ socket(before).drop()
605
+ jest.advanceTimersByTime(500)
606
+ expect(TestSocket.instances).toHaveLength(before + 2)
607
+ })
608
+
609
+ it('cuts short the wait after a socket dropped for going silent', async () => {
610
+ TestSocket.closeHangs = true
611
+ TestSocket.answersPings = false
612
+ open()
613
+ socket(0).open()
614
+ await jest.advanceTimersByTimeAsync(20_000)
615
+ expect(socket(0).readyState).toBe(2) // dropped as silent, waiting 500 ms
616
+ expect(TestSocket.instances).toHaveLength(1)
617
+ client.reconnectNow()
618
+ expect(TestSocket.instances).toHaveLength(2)
619
+ await jest.advanceTimersByTimeAsync(1_000)
620
+ expect(TestSocket.instances).toHaveLength(2)
621
+ })
622
+
623
+ it('does nothing while a socket is open', () => {
624
+ open()
625
+ socket(0).open()
626
+ client.reconnectNow()
627
+ expect(TestSocket.instances).toHaveLength(1)
628
+ expect(socket(0).readyState).toBe(1)
629
+ })
630
+
631
+ it('does nothing while a dial is in flight', () => {
632
+ open()
633
+ expect(socket(0).readyState).toBe(0)
634
+ client.reconnectNow()
635
+ expect(TestSocket.instances).toHaveLength(1)
636
+
637
+ // Nor once the backoff timer has fired and its dial is still connecting.
638
+ socket(0).open()
639
+ socket(0).drop()
640
+ jest.advanceTimersByTime(500)
641
+ expect(TestSocket.instances).toHaveLength(2)
642
+ client.reconnectNow()
643
+ expect(TestSocket.instances).toHaveLength(2)
644
+ })
645
+
646
+ it('does nothing while a call dials during the backoff', () => {
647
+ backOff(3) // waiting 2 s
648
+ call('agent.status').catch(() => {})
649
+ const dialling = TestSocket.instances.length
650
+ client.reconnectNow()
651
+ expect(TestSocket.instances).toHaveLength(dialling)
652
+ })
653
+
654
+ it('ends the wait when a call dials during the backoff, so that socket retries from 500 ms', () => {
655
+ backOff(5) // waiting 8 s
656
+ call('agent.status').catch(() => {})
657
+ const dialled = TestSocket.instances.length - 1
658
+ socket(dialled).open()
659
+ socket(dialled).drop()
660
+ jest.advanceTimersByTime(500)
661
+ expect(TestSocket.instances).toHaveLength(dialled + 2)
662
+ })
663
+
664
+ it('does nothing once the executor refused the token', () => {
665
+ open()
666
+ socket(0).open()
667
+ socket(0).drop(1008, 'token expired')
668
+ client.reconnectNow()
669
+ expect(TestSocket.instances).toHaveLength(1)
670
+ })
671
+
672
+ it('does nothing after closeAll', () => {
673
+ backOff(3)
674
+ const before = TestSocket.instances.length
675
+ client.closeAll()
676
+ client.reconnectNow()
677
+ expect(TestSocket.instances).toHaveLength(before)
678
+ })
679
+
680
+ it('dials through Ad4mClient.reconnectNow', () => {
681
+ const { Ad4mClient } = require('./Ad4mClient')
682
+ const facade = new Ad4mClient(url, undefined, {
683
+ webSocketImpl: TestSocket as unknown as new (url: string) => WebSocket,
684
+ })
685
+ try {
686
+ facade.on('agent-updated', () => {})
687
+ const first = TestSocket.instances.length - 1
688
+ socket(first).open()
689
+ socket(first).drop()
690
+ facade.reconnectNow()
691
+ expect(TestSocket.instances).toHaveLength(first + 2)
692
+ } finally {
693
+ facade.close()
694
+ }
695
+ })
696
+
697
+ describe('in a browser', () => {
698
+ const g = globalThis as Record<string, unknown>
699
+ let win: CountingTarget
700
+ let doc: CountingTarget
701
+ beforeEach(() => {
702
+ win = new CountingTarget()
703
+ doc = new CountingTarget()
704
+ g.window = win
705
+ g.document = doc
706
+ })
707
+ afterEach(() => {
708
+ client.closeAll()
709
+ delete g.window
710
+ delete g.document
711
+ })
712
+
713
+ it('reconnects on `online` and on the page becoming visible, only while waiting to reconnect', () => {
714
+ open()
715
+ win.dispatchEvent(new Event('online')) // dialling
716
+ doc.visibilityState = 'visible'
717
+ doc.dispatchEvent(new Event('visibilitychange'))
718
+ expect(TestSocket.instances).toHaveLength(1)
719
+ socket(0).open()
720
+ win.dispatchEvent(new Event('online')) // connected
721
+ doc.dispatchEvent(new Event('visibilitychange'))
722
+ expect(TestSocket.instances).toHaveLength(1)
723
+
724
+ socket(0).drop()
725
+ jest.advanceTimersByTime(500)
726
+ socket(1).drop() // waiting 1 s now
727
+ win.dispatchEvent(new Event('online'))
728
+ expect(TestSocket.instances).toHaveLength(3)
729
+
730
+ socket(2).drop()
731
+ doc.visibilityState = 'hidden'
732
+ doc.dispatchEvent(new Event('visibilitychange'))
733
+ expect(TestSocket.instances).toHaveLength(3)
734
+ doc.visibilityState = 'visible'
735
+ doc.dispatchEvent(new Event('visibilitychange'))
736
+ expect(TestSocket.instances).toHaveLength(4)
737
+ })
738
+
739
+ it('listens only while waiting to reconnect', () => {
740
+ open()
741
+ socket(0).open()
742
+ expect(win.live + doc.live).toBe(0)
743
+ socket(0).drop()
744
+ expect(win.listeners.get('online')).toBe(1)
745
+ expect(doc.listeners.get('visibilitychange')).toBe(1)
746
+ jest.advanceTimersByTime(500) // the wait is over: dialling
747
+ expect(win.live + doc.live).toBe(0)
748
+ socket(1).drop()
749
+ expect(win.live + doc.live).toBe(2)
750
+ client.reconnectNow()
751
+ expect(win.live + doc.live).toBe(0)
752
+ // Many waits leave one listener each, never more.
753
+ for (let i = 2; i < 8; i++) {
754
+ socket(i).drop()
755
+ expect(win.live + doc.live).toBe(2)
756
+ jest.advanceTimersByTime(30_000)
757
+ }
758
+ })
759
+
760
+ it('removes its listeners on closeAll', () => {
761
+ backOff(3)
762
+ expect(win.live + doc.live).toBe(2)
763
+ client.closeAll()
764
+ expect(win.live + doc.live).toBe(0)
765
+ expect(jest.getTimerCount()).toBe(0)
766
+ })
767
+
768
+ it('removes its listeners when the executor refuses the token', () => {
769
+ backOff(2)
770
+ expect(win.live + doc.live).toBe(2)
771
+ jest.advanceTimersByTime(30_000)
772
+ socket(2).drop(1008, 'token expired')
773
+ expect(win.live + doc.live).toBe(0)
774
+ })
775
+
776
+ it('stops listening when the last subscriber leaves during the wait', () => {
777
+ const unsubscribe = client.on('perspective-added', () => {})
778
+ socket(0).open()
779
+ socket(0).drop()
780
+ expect(win.live + doc.live).toBe(2)
781
+ unsubscribe()
782
+ expect(win.live + doc.live).toBe(0)
783
+ win.dispatchEvent(new Event('online'))
784
+ jest.advanceTimersByTime(30_000)
785
+ expect(TestSocket.instances).toHaveLength(1)
786
+ })
787
+ })
788
+
789
+ it('registers nothing without window, and still reconnects on its backoff', () => {
790
+ const g = globalThis as Record<string, unknown>
791
+ expect(typeof g.window).toBe('undefined')
792
+ // A document without a window (a non-browser host with a DOM shim) is left alone too.
793
+ const doc = new CountingTarget()
794
+ g.document = doc
795
+ try {
796
+ backOff(2) // waiting 1 s
797
+ expect(doc.live).toBe(0)
798
+ const before = TestSocket.instances.length
799
+ jest.advanceTimersByTime(1_000)
800
+ expect(TestSocket.instances).toHaveLength(before + 1)
801
+ client.reconnectNow() // dialling: nothing to do
802
+ expect(TestSocket.instances).toHaveLength(before + 1)
803
+ } finally {
804
+ delete g.document
805
+ }
806
+ })
807
+ })
808
+
346
809
  describe('ApiClient when the executor refuses the token', () => {
347
810
  const REASON = 'Unauthorized access: the token expired or was revoked'
348
811
  let authFailed: jest.Mock
@@ -774,7 +1237,8 @@ describe('PerspectiveProxy.on', () => {
774
1237
  proxy.dispose()
775
1238
  await flush()
776
1239
 
777
- socket(0).reply(linkAdded('p1'))
1240
+ // off() left no handler, so the client closed its socket; the new registration opened another.
1241
+ TestSocket.instances.at(-1)!.reply(linkAdded('p1'))
778
1242
  expect(handler).toHaveBeenCalledTimes(1)
779
1243
  })
780
1244
  })