@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.
- package/lib/index.cjs +807 -275
- package/lib/index.js +804 -276
- package/lib/src/Ad4mClient.d.ts +6 -0
- package/lib/src/Ad4mClient.js +8 -0
- package/lib/src/apiClient.d.ts +32 -0
- package/lib/src/apiClient.js +132 -13
- package/lib/src/generated/api/AgentMessage.d.ts +10 -0
- package/lib/src/generated/api/AgentMessage.js +2 -0
- package/lib/src/generated/api/AgentReply.d.ts +9 -0
- package/lib/src/generated/api/AgentReply.js +2 -0
- package/lib/src/generated/api/RpcMethods.d.ts +6 -0
- package/lib/src/generated/api/RpcMethods.js +1 -0
- package/lib/src/generated/api/RunAgentRequest.d.ts +26 -0
- package/lib/src/generated/api/RunAgentRequest.js +1 -0
- package/lib/src/generated/api/index.d.ts +3 -0
- package/lib/src/index.d.ts +1 -0
- package/lib/src/index.js +1 -0
- package/lib/src/model/Ad4mModel.d.ts +7 -0
- package/lib/src/model/Ad4mModel.js +16 -13
- package/lib/src/model/ModelQueryBuilder.d.ts +2 -0
- package/lib/src/model/ModelQueryBuilder.js +36 -57
- package/lib/src/model/types.d.ts +6 -0
- package/lib/src/neighbourhood/SfuManager.d.ts +15 -0
- package/lib/src/neighbourhood/SfuManager.js +39 -2
- package/lib/src/perspectives/LiveQuery.d.ts +40 -4
- package/lib/src/perspectives/LiveQuery.js +94 -10
- package/lib/src/perspectives/Mentioning.d.ts +37 -0
- package/lib/src/perspectives/Mentioning.js +58 -0
- package/lib/src/perspectives/PerspectiveClient.d.ts +26 -2
- package/lib/src/perspectives/PerspectiveClient.js +19 -4
- package/lib/src/perspectives/PerspectiveProxy.d.ts +34 -3
- package/lib/src/perspectives/PerspectiveProxy.js +52 -16
- package/lib/src/perspectives/TextContent.d.ts +4 -0
- package/lib/src/perspectives/TextContent.js +4 -0
- package/lib/src/perspectives/WakerSubscriptionManager.d.ts +104 -12
- package/lib/src/perspectives/WakerSubscriptionManager.js +252 -66
- package/package.json +2 -2
- package/src/Ad4mClient.ts +9 -0
- package/src/apiClient.test.ts +467 -3
- package/src/apiClient.ts +133 -13
- package/src/generated/api/AgentMessage.ts +10 -0
- package/src/generated/api/AgentReply.ts +10 -0
- package/src/generated/api/RpcMethods.ts +4 -0
- package/src/generated/api/RunAgentRequest.ts +26 -0
- package/src/generated/api/index.ts +3 -0
- package/src/index.ts +1 -0
- package/src/model/Ad4mModel.test.ts +128 -364
- package/src/model/Ad4mModel.ts +16 -17
- package/src/model/ModelQueryBuilder.ts +39 -59
- package/src/model/types.ts +6 -0
- package/src/model/write-round-trips.test.ts +215 -0
- package/src/neighbourhood/SfuManager.test.ts +151 -2
- package/src/neighbourhood/SfuManager.ts +38 -1
- package/src/perspectives/LiveQuery.test.ts +173 -1
- package/src/perspectives/LiveQuery.ts +110 -10
- package/src/perspectives/Mentioning.test.ts +78 -0
- package/src/perspectives/Mentioning.ts +42 -0
- package/src/perspectives/PerspectiveClient.ts +36 -4
- package/src/perspectives/PerspectiveProxy.test.ts +24 -2
- package/src/perspectives/PerspectiveProxy.ts +61 -16
- package/src/perspectives/TextContent.ts +4 -0
- package/src/perspectives/WakerSubscriptionManager.test.ts +608 -152
- package/src/perspectives/WakerSubscriptionManager.ts +313 -67
package/src/apiClient.test.ts
CHANGED
|
@@ -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) {
|
|
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.
|
|
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
|
-
|
|
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
|
})
|