@hyper-fetch/sockets 9.6.1 → 9.6.2

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 (39) hide show
  1. package/__tests__/e2e/e2e.lifecycle.spec.ts +258 -0
  2. package/__tests__/features/adapter/adapter.connection.spec.ts +27 -6
  3. package/__tests__/features/adapter/adapter.sse.lifecycle.spec.ts +514 -0
  4. package/__tests__/features/adapter/adapter.sse.spec.ts +20 -6
  5. package/__tests__/features/adapter/adapter.websocket.heartbeat.timers.spec.ts +337 -0
  6. package/__tests__/features/adapter/adapter.websocket.lifecycle.spec.ts +528 -0
  7. package/__tests__/features/adapter/adapter.websocket.reconnection.spec.ts +669 -0
  8. package/__tests__/features/delivery/delivery.backpressure.spec.ts +382 -0
  9. package/__tests__/features/emitter/emitter.sending.spec.ts +493 -0
  10. package/__tests__/features/emitter/emitter.typescript.spec.ts +153 -0
  11. package/__tests__/features/listener/listener.dispatch.spec.ts +427 -0
  12. package/__tests__/features/listener/listener.params.spec.ts +192 -0
  13. package/__tests__/features/socket/socket.app-manager.spec.ts +24 -2
  14. package/__tests__/features/socket/socket.interceptors.spec.ts +430 -0
  15. package/__tests__/utils/controlled-event-source.ts +149 -0
  16. package/__tests__/utils/controlled-websocket.ts +213 -0
  17. package/dist/adapter/adapter.bindings.d.ts.map +1 -1
  18. package/dist/adapter/adapter.d.ts.map +1 -1
  19. package/dist/adapter-sse/sse-adapter.d.ts.map +1 -1
  20. package/dist/adapter-websockets/websocket-adapter.d.ts.map +1 -1
  21. package/dist/emitter/emitter.d.ts.map +1 -1
  22. package/dist/index.mjs +284 -105
  23. package/dist/index.mjs.map +1 -1
  24. package/dist/listener/listener.d.ts +2 -0
  25. package/dist/listener/listener.d.ts.map +1 -1
  26. package/dist/socket/socket.d.ts +1 -1
  27. package/dist/socket/socket.utils.d.ts +11 -3
  28. package/dist/socket/socket.utils.d.ts.map +1 -1
  29. package/dist/utils/topic.utils.d.ts +10 -0
  30. package/dist/utils/topic.utils.d.ts.map +1 -0
  31. package/package.json +1 -1
  32. package/src/adapter/adapter.bindings.ts +44 -20
  33. package/src/adapter/adapter.ts +29 -10
  34. package/src/adapter-sse/sse-adapter.ts +95 -15
  35. package/src/adapter-websockets/websocket-adapter.ts +124 -41
  36. package/src/emitter/emitter.ts +16 -9
  37. package/src/listener/listener.ts +7 -8
  38. package/src/socket/socket.utils.ts +20 -6
  39. package/src/utils/topic.utils.ts +26 -0
@@ -0,0 +1,669 @@
1
+ import { Socket } from "socket";
2
+
3
+ import {
4
+ ControlledWebSocket,
5
+ flushPromises,
6
+ installControlledWebSocket,
7
+ openWebSocket,
8
+ uninstallControlledWebSocket,
9
+ waitForWebSocket,
10
+ } from "../../utils/controlled-websocket";
11
+
12
+ const url = "ws://reconnection";
13
+ const reconnectTime = 1000;
14
+
15
+ describe("Websocket Adapter [ Reconnection ]", () => {
16
+ const sockets: Socket[] = [];
17
+
18
+ const createSocket = (options?: Partial<ConstructorParameters<typeof Socket>[0]>) => {
19
+ const socket = new Socket({ url, reconnectTime, ...options });
20
+ sockets.push(socket);
21
+ return socket;
22
+ };
23
+
24
+ /** Creates a socket and opens its first connection */
25
+ const createConnectedSocket = async (options?: Partial<ConstructorParameters<typeof Socket>[0]>) => {
26
+ const socket = createSocket(options);
27
+ const websocket = await openWebSocket();
28
+ return { socket, websocket };
29
+ };
30
+
31
+ const trackReconnection = (socket: Socket) => {
32
+ const events: string[] = [];
33
+ socket.events.onReconnecting(({ attempts }) => events.push(`reconnecting:${attempts}`));
34
+ socket.events.onReconnectingFailed(({ attempts }) => events.push(`failed:${attempts}`));
35
+ socket.events.onConnected(() => events.push("connected"));
36
+ socket.events.onDisconnected(() => events.push("disconnected"));
37
+ return events;
38
+ };
39
+
40
+ /** Moves the clock by the reconnection delay and lets the next attempt create its transport */
41
+ const waitForReconnectAttempt = async () => {
42
+ await vi.advanceTimersByTimeAsync(reconnectTime);
43
+ await flushPromises();
44
+ return ControlledWebSocket.last;
45
+ };
46
+
47
+ /** Waits for the next attempt and lets the server refuse it */
48
+ const refuseReconnectAttempt = async () => {
49
+ const attempt = await waitForReconnectAttempt();
50
+ attempt.serverRefuse();
51
+ return attempt;
52
+ };
53
+
54
+ /** Waits for the next attempt and lets the server accept it */
55
+ const openReconnectAttempt = async () => {
56
+ const attempt = await waitForReconnectAttempt();
57
+ attempt.serverOpen();
58
+ return attempt;
59
+ };
60
+
61
+ beforeEach(() => {
62
+ installControlledWebSocket();
63
+ vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
64
+ });
65
+
66
+ afterEach(async () => {
67
+ await Promise.all(sockets.map((socket) => socket.disconnect()));
68
+ sockets.forEach((socket) => socket.appManager.unmount());
69
+ sockets.length = 0;
70
+ vi.useRealTimers();
71
+ uninstallControlledWebSocket();
72
+ });
73
+
74
+ describe("When the connection is lost", () => {
75
+ it("should wait for the reconnect time before trying again", async () => {
76
+ const { socket, websocket } = await createConnectedSocket();
77
+ socket.onError(() => null);
78
+ const events = trackReconnection(socket);
79
+
80
+ websocket.serverClose({ code: 1006 });
81
+ await vi.advanceTimersByTimeAsync(reconnectTime - 1);
82
+
83
+ expect(events).toStrictEqual(["disconnected"]);
84
+ expect(ControlledWebSocket.instances).toHaveLength(1);
85
+
86
+ await vi.advanceTimersByTimeAsync(1);
87
+ await flushPromises();
88
+
89
+ expect(events).toStrictEqual(["disconnected", "reconnecting:0"]);
90
+ expect(ControlledWebSocket.instances).toHaveLength(2);
91
+ });
92
+
93
+ it("should reconnect and become connected again", async () => {
94
+ const { socket, websocket } = await createConnectedSocket();
95
+ socket.onError(() => null);
96
+ const events = trackReconnection(socket);
97
+
98
+ websocket.serverClose({ code: 1006 });
99
+ const next = await waitForReconnectAttempt();
100
+ next.serverOpen();
101
+
102
+ expect(events).toStrictEqual(["disconnected", "reconnecting:0", "connected"]);
103
+ expect(socket.adapter.connected).toBeTrue();
104
+ expect(ControlledWebSocket.active).toStrictEqual([next]);
105
+ });
106
+
107
+ it("should use the reconnect time from the socket options", async () => {
108
+ const { socket, websocket } = await createConnectedSocket({ reconnectTime: 250 });
109
+ socket.onError(() => null);
110
+
111
+ websocket.serverClose({ code: 1006 });
112
+ await vi.advanceTimersByTimeAsync(249);
113
+ expect(ControlledWebSocket.instances).toHaveLength(1);
114
+
115
+ await vi.advanceTimersByTimeAsync(1);
116
+ await flushPromises();
117
+ expect(ControlledWebSocket.instances).toHaveLength(2);
118
+ });
119
+
120
+ it("should call the onReconnect callbacks on every attempt", async () => {
121
+ const onReconnect = vi.fn();
122
+ const { socket, websocket } = await createConnectedSocket();
123
+ socket.onError(() => null).onReconnect(onReconnect);
124
+
125
+ websocket.serverClose({ code: 1006 });
126
+ await refuseReconnectAttempt();
127
+ await refuseReconnectAttempt();
128
+ await waitForReconnectAttempt();
129
+
130
+ expect(onReconnect).toHaveBeenCalledTimes(3);
131
+ });
132
+
133
+ it("should number the attempts until the connection is back", async () => {
134
+ const attempts: number[] = [];
135
+ const { socket, websocket } = await createConnectedSocket();
136
+ socket
137
+ .onError(() => null)
138
+ .onConnect(({ connection, attempt }) => {
139
+ attempts.push(attempt);
140
+ return connection;
141
+ });
142
+ const events = trackReconnection(socket);
143
+
144
+ websocket.serverClose({ code: 1006 });
145
+ await refuseReconnectAttempt();
146
+ await refuseReconnectAttempt();
147
+ await openReconnectAttempt();
148
+
149
+ expect(attempts).toStrictEqual([1, 2, 3]);
150
+ expect(events).toStrictEqual([
151
+ "disconnected",
152
+ "reconnecting:0",
153
+ "disconnected",
154
+ "reconnecting:1",
155
+ "disconnected",
156
+ "reconnecting:2",
157
+ "connected",
158
+ ]);
159
+ expect(socket.adapter.reconnectionAttempts).toBe(0);
160
+ });
161
+
162
+ it("should start counting from zero after a successful reconnection", async () => {
163
+ const { socket, websocket } = await createConnectedSocket();
164
+ socket.onError(() => null);
165
+
166
+ websocket.serverClose({ code: 1006 });
167
+ await refuseReconnectAttempt();
168
+ const recovered = await waitForReconnectAttempt();
169
+ recovered.serverOpen();
170
+ const events = trackReconnection(socket);
171
+
172
+ recovered.serverClose({ code: 1006 });
173
+ await waitForReconnectAttempt();
174
+
175
+ expect(events).toStrictEqual(["disconnected", "reconnecting:0"]);
176
+ });
177
+
178
+ it("should hold only one live transport while reconnecting", async () => {
179
+ const { socket, websocket } = await createConnectedSocket();
180
+ socket.onError(() => null);
181
+
182
+ websocket.serverClose({ code: 1006 });
183
+ for (let i = 0; i < 5; i += 1) {
184
+ // eslint-disable-next-line no-await-in-loop
185
+ const next = await waitForReconnectAttempt();
186
+ expect(ControlledWebSocket.active).toStrictEqual([next]);
187
+ next.serverRefuse();
188
+ }
189
+
190
+ expect(ControlledWebSocket.active).toHaveLength(0);
191
+ expect(vi.getTimerCount()).toBe(1);
192
+ });
193
+
194
+ it("should survive a flapping connection with one transport and paired events", async () => {
195
+ const { socket, websocket } = await createConnectedSocket();
196
+ socket.onError(() => null);
197
+ const events = trackReconnection(socket);
198
+ let current = websocket;
199
+
200
+ for (let i = 0; i < 10; i += 1) {
201
+ current.serverClose({ code: 1006 });
202
+ // eslint-disable-next-line no-await-in-loop
203
+ current = await waitForReconnectAttempt();
204
+ current.serverOpen();
205
+ }
206
+
207
+ expect(ControlledWebSocket.instances).toHaveLength(11);
208
+ expect(ControlledWebSocket.active).toStrictEqual([current]);
209
+ expect(events.filter((event) => event === "disconnected")).toHaveLength(10);
210
+ expect(events.filter((event) => event === "connected")).toHaveLength(10);
211
+ expect(events.filter((event) => event === "reconnecting:0")).toHaveLength(10);
212
+ expect(socket.adapter.connected).toBeTrue();
213
+ expect(vi.getTimerCount()).toBe(0);
214
+ });
215
+
216
+ it("should keep delivering messages to the same listeners after reconnecting", async () => {
217
+ const { socket, websocket } = await createConnectedSocket();
218
+ socket.onError(() => null);
219
+ const spy = vi.fn();
220
+ socket
221
+ .createListener<number>()({ topic: "ticks" })
222
+ .listen(({ data }) => spy(data));
223
+
224
+ websocket.serverEmit("ticks", 1);
225
+ websocket.serverClose({ code: 1006 });
226
+ const next = await waitForReconnectAttempt();
227
+ next.serverOpen();
228
+ next.serverEmit("ticks", 2);
229
+
230
+ expect(spy.mock.calls).toStrictEqual([[1], [2]]);
231
+ expect(socket.adapter.listeners.get("ticks")?.size).toBe(1);
232
+ });
233
+
234
+ it("should ignore frames of the replaced transport", async () => {
235
+ const { socket, websocket } = await createConnectedSocket();
236
+ socket.onError(() => null);
237
+ const spy = vi.fn();
238
+ socket
239
+ .createListener<number>()({ topic: "ticks" })
240
+ .listen(({ data }) => spy(data));
241
+
242
+ const reconnecting = socket.reconnect();
243
+ const next = await openWebSocket(2);
244
+ await reconnecting;
245
+ websocket.serverEmit("ticks", 1);
246
+ next.serverEmit("ticks", 2);
247
+
248
+ expect(spy.mock.calls).toStrictEqual([[2]]);
249
+ });
250
+ });
251
+
252
+ describe("When the reconnection attempts are limited", () => {
253
+ it("should stop after the configured number of attempts", async () => {
254
+ const onReconnectFailed = vi.fn();
255
+ const { socket, websocket } = await createConnectedSocket({ reconnect: 2 });
256
+ socket.onError(() => null).onReconnectFailed(onReconnectFailed);
257
+ const events = trackReconnection(socket);
258
+
259
+ websocket.serverClose({ code: 1006 });
260
+ await refuseReconnectAttempt();
261
+ await refuseReconnectAttempt();
262
+ await vi.advanceTimersByTimeAsync(reconnectTime);
263
+ await flushPromises();
264
+
265
+ expect(events).toStrictEqual([
266
+ "disconnected",
267
+ "reconnecting:0",
268
+ "disconnected",
269
+ "reconnecting:1",
270
+ "disconnected",
271
+ "reconnecting:2",
272
+ "failed:2",
273
+ ]);
274
+ expect(onReconnectFailed).toHaveBeenCalledTimes(1);
275
+ expect(ControlledWebSocket.instances).toHaveLength(3);
276
+ });
277
+
278
+ it("should leave no timers and no transport after giving up", async () => {
279
+ const { socket, websocket } = await createConnectedSocket({ reconnect: 1 });
280
+ socket.onError(() => null);
281
+
282
+ websocket.serverClose({ code: 1006 });
283
+ await refuseReconnectAttempt();
284
+ await vi.advanceTimersByTimeAsync(reconnectTime);
285
+ await flushPromises();
286
+ await vi.advanceTimersByTimeAsync(reconnectTime * 10);
287
+
288
+ expect(vi.getTimerCount()).toBe(0);
289
+ expect(ControlledWebSocket.active).toHaveLength(0);
290
+ expect(ControlledWebSocket.instances).toHaveLength(2);
291
+ expect(socket.adapter.connecting).toBeFalse();
292
+ });
293
+
294
+ it("should not reconnect at all when reconnect is set to 0", async () => {
295
+ const { socket, websocket } = await createConnectedSocket({ reconnect: 0 });
296
+ socket.onError(() => null);
297
+ const events = trackReconnection(socket);
298
+
299
+ websocket.serverClose({ code: 1006 });
300
+ await vi.advanceTimersByTimeAsync(reconnectTime * 5);
301
+ await flushPromises();
302
+
303
+ expect(events).toStrictEqual(["disconnected", "reconnecting:0", "failed:0"]);
304
+ expect(ControlledWebSocket.instances).toHaveLength(1);
305
+ });
306
+
307
+ it("should count attempts whose handshake never finishes", async () => {
308
+ const socket = createSocket({ reconnect: 2 });
309
+ socket.onError(() => null);
310
+ const events = trackReconnection(socket);
311
+ await waitForWebSocket();
312
+
313
+ // The server accepts the TCP connection but never answers the handshake
314
+ await waitForReconnectAttempt();
315
+ await waitForReconnectAttempt();
316
+ await vi.advanceTimersByTimeAsync(reconnectTime);
317
+ await flushPromises();
318
+ await vi.advanceTimersByTimeAsync(reconnectTime * 10);
319
+
320
+ expect(events.filter((event) => event.startsWith("reconnecting"))).toStrictEqual([
321
+ "reconnecting:0",
322
+ "reconnecting:1",
323
+ "reconnecting:2",
324
+ ]);
325
+ expect(events.at(-1)).toBe("failed:2");
326
+ expect(ControlledWebSocket.instances).toHaveLength(3);
327
+ expect(ControlledWebSocket.active).toHaveLength(0);
328
+ expect(vi.getTimerCount()).toBe(0);
329
+ });
330
+
331
+ it("should close the hanging transport before starting the next attempt", async () => {
332
+ const socket = createSocket();
333
+ socket.onError(() => null);
334
+ const hanging = await waitForWebSocket();
335
+
336
+ const next = await waitForReconnectAttempt();
337
+
338
+ expect(hanging.readyState).toBe(ControlledWebSocket.CLOSED);
339
+ expect(next).not.toBe(hanging);
340
+ expect(ControlledWebSocket.active).toStrictEqual([next]);
341
+ });
342
+
343
+ it("should pass the attempt number of a hanging handshake to onConnect", async () => {
344
+ const attempts: number[] = [];
345
+ const socket = createSocket().onConnect(({ connection, attempt }) => {
346
+ attempts.push(attempt);
347
+ return connection;
348
+ });
349
+ socket.onError(() => null);
350
+ await waitForWebSocket();
351
+
352
+ await waitForReconnectAttempt();
353
+ await waitForReconnectAttempt();
354
+ await waitForReconnectAttempt();
355
+
356
+ expect(attempts).toStrictEqual([0, 1, 2, 3]);
357
+ });
358
+
359
+ it("should allow a manual connect after giving up", async () => {
360
+ const { socket, websocket } = await createConnectedSocket({ reconnect: 0 });
361
+ socket.onError(() => null);
362
+ websocket.serverClose({ code: 1006 });
363
+ await vi.advanceTimersByTimeAsync(reconnectTime);
364
+ await flushPromises();
365
+
366
+ const connecting = socket.connect();
367
+ await openWebSocket(2);
368
+ await connecting;
369
+
370
+ expect(socket.adapter.connected).toBeTrue();
371
+ expect(socket.adapter.reconnectionAttempts).toBe(0);
372
+ });
373
+
374
+ it("should retry endlessly by default", async () => {
375
+ const { socket, websocket } = await createConnectedSocket();
376
+ socket.onError(() => null);
377
+ const failed = vi.fn();
378
+ socket.events.onReconnectingFailed(failed);
379
+
380
+ websocket.serverClose({ code: 1006 });
381
+ for (let i = 0; i < 25; i += 1) {
382
+ // eslint-disable-next-line no-await-in-loop
383
+ await refuseReconnectAttempt();
384
+ }
385
+
386
+ expect(failed).not.toHaveBeenCalled();
387
+ expect(ControlledWebSocket.instances).toHaveLength(26);
388
+ expect(socket.adapter.reconnectionAttempts).toBe(25);
389
+ });
390
+ });
391
+
392
+ describe("When disconnecting manually", () => {
393
+ it("should cancel the scheduled reconnection", async () => {
394
+ const { socket, websocket } = await createConnectedSocket();
395
+ socket.onError(() => null);
396
+ websocket.serverClose({ code: 1006 });
397
+ const events = trackReconnection(socket);
398
+
399
+ await socket.disconnect();
400
+ await vi.advanceTimersByTimeAsync(reconnectTime * 5);
401
+
402
+ expect(events).toStrictEqual([]);
403
+ expect(ControlledWebSocket.instances).toHaveLength(1);
404
+ expect(vi.getTimerCount()).toBe(0);
405
+ });
406
+
407
+ it("should stop a reconnection attempt that is still opening", async () => {
408
+ const { socket, websocket } = await createConnectedSocket();
409
+ socket.onError(() => null);
410
+ websocket.serverClose({ code: 1006 });
411
+ const attempt = await waitForReconnectAttempt();
412
+
413
+ await socket.disconnect();
414
+ await vi.advanceTimersByTimeAsync(reconnectTime * 5);
415
+
416
+ expect(attempt.readyState).toBe(ControlledWebSocket.CLOSED);
417
+ expect(ControlledWebSocket.instances).toHaveLength(2);
418
+ expect(socket.adapter.connecting).toBeFalse();
419
+ expect(socket.adapter.reconnectionAttempts).toBe(0);
420
+ expect(vi.getTimerCount()).toBe(0);
421
+ });
422
+
423
+ it("should not reconnect when the transport reports the close late", async () => {
424
+ ControlledWebSocket.autoFinishClose = false;
425
+ const { socket, websocket } = await createConnectedSocket();
426
+ const events = trackReconnection(socket);
427
+
428
+ const disconnecting = socket.disconnect();
429
+ websocket.finishClose();
430
+ await disconnecting;
431
+ await vi.advanceTimersByTimeAsync(reconnectTime * 5);
432
+
433
+ expect(events).toStrictEqual(["disconnected"]);
434
+ expect(ControlledWebSocket.instances).toHaveLength(1);
435
+ });
436
+
437
+ it("should win over a reconnection that is closing the previous transport", async () => {
438
+ ControlledWebSocket.autoFinishClose = false;
439
+ const { socket, websocket } = await createConnectedSocket();
440
+ const events = trackReconnection(socket);
441
+
442
+ const reconnecting = socket.reconnect();
443
+ const disconnecting = socket.disconnect();
444
+ websocket.finishClose();
445
+ await Promise.all([reconnecting, disconnecting]);
446
+ await vi.advanceTimersByTimeAsync(reconnectTime * 5);
447
+
448
+ expect(events).toStrictEqual(["reconnecting:0", "disconnected"]);
449
+ expect(ControlledWebSocket.instances).toHaveLength(1);
450
+ expect(socket.adapter.connecting).toBeFalse();
451
+ expect(socket.adapter.connected).toBeFalse();
452
+ });
453
+
454
+ it("should mark the socket as closed on purpose until it connects again", async () => {
455
+ const { socket } = await createConnectedSocket();
456
+
457
+ await socket.disconnect();
458
+ expect(socket.adapter.forceClosed).toBeTrue();
459
+
460
+ const connecting = socket.connect();
461
+ await openWebSocket(2);
462
+ await connecting;
463
+ expect(socket.adapter.forceClosed).toBeFalse();
464
+ });
465
+ });
466
+
467
+ describe("When reconnecting manually", () => {
468
+ it("should replace the open connection with a new one", async () => {
469
+ const { socket, websocket } = await createConnectedSocket();
470
+ const events = trackReconnection(socket);
471
+
472
+ const reconnecting = socket.reconnect();
473
+ const next = await openWebSocket(2);
474
+ await reconnecting;
475
+
476
+ expect(websocket.readyState).toBe(ControlledWebSocket.CLOSED);
477
+ expect(events).toStrictEqual(["reconnecting:0", "disconnected", "connected"]);
478
+ expect(ControlledWebSocket.active).toStrictEqual([next]);
479
+ });
480
+
481
+ it("should resolve reconnect only after the new connection is open", async () => {
482
+ const { socket } = await createConnectedSocket();
483
+ const resolved = vi.fn();
484
+
485
+ const reconnecting = socket.reconnect().then(resolved);
486
+ const next = await waitForWebSocket(2);
487
+ await flushPromises();
488
+ expect(resolved).not.toHaveBeenCalled();
489
+
490
+ next.serverOpen();
491
+ await reconnecting;
492
+
493
+ expect(resolved).toHaveBeenCalledTimes(1);
494
+ expect(socket.adapter.connected).toBeTrue();
495
+ });
496
+
497
+ it("should connect a socket that was disconnected manually", async () => {
498
+ const { socket } = await createConnectedSocket();
499
+ await socket.disconnect();
500
+
501
+ const reconnecting = socket.reconnect();
502
+ await openWebSocket(2);
503
+ await reconnecting;
504
+
505
+ expect(socket.adapter.connected).toBeTrue();
506
+ expect(socket.adapter.forceClosed).toBeFalse();
507
+ });
508
+
509
+ it("should apply the url and query params set before reconnecting", async () => {
510
+ const { socket } = await createConnectedSocket({ queryParams: { token: "old" } });
511
+
512
+ socket.setUrl("ws://other-region").setQueryParams({ token: "new" });
513
+ const reconnecting = socket.reconnect();
514
+ const next = await openWebSocket(2);
515
+ await reconnecting;
516
+
517
+ expect(next.url).toBe("ws://other-region?token=new");
518
+ });
519
+
520
+ it("should replace a connection that is still opening without leaving it behind", async () => {
521
+ const socket = createSocket();
522
+ const first = await waitForWebSocket();
523
+
524
+ const reconnecting = socket.reconnect();
525
+ const second = await openWebSocket(2);
526
+ await reconnecting;
527
+
528
+ expect(first.readyState).toBe(ControlledWebSocket.CLOSED);
529
+ expect(ControlledWebSocket.active).toStrictEqual([second]);
530
+ expect(socket.adapter.connected).toBeTrue();
531
+ });
532
+
533
+ it("should refresh the connection details on every attempt", async () => {
534
+ const tokens = ["token-1", "token-2", "token-3"];
535
+ const { socket, websocket } = await createConnectedSocket();
536
+ socket
537
+ .onError(() => null)
538
+ .onConnect(async ({ connection, attempt }) => ({
539
+ ...connection,
540
+ adapterOptions: { ...connection.adapterOptions, protocols: ["auth", tokens[attempt - 1]] },
541
+ }));
542
+
543
+ websocket.serverClose({ code: 1006 });
544
+ const first = await waitForReconnectAttempt();
545
+ first.serverRefuse();
546
+ const second = await waitForReconnectAttempt();
547
+ second.serverRefuse();
548
+ const third = await waitForReconnectAttempt();
549
+
550
+ expect(first.protocols).toStrictEqual(["auth", "token-1"]);
551
+ expect(second.protocols).toStrictEqual(["auth", "token-2"]);
552
+ expect(third.protocols).toStrictEqual(["auth", "token-3"]);
553
+ });
554
+
555
+ it("should stay disconnected when the onConnect interceptor fails during a reconnection", async () => {
556
+ let shouldFail = false;
557
+ const errors: string[] = [];
558
+ const { socket, websocket } = await createConnectedSocket();
559
+ socket
560
+ .onError<Error>(({ error }) => errors.push(error.message))
561
+ .onConnect(({ connection }) => {
562
+ if (shouldFail) {
563
+ throw new Error("Cannot refresh the token");
564
+ }
565
+ return connection;
566
+ });
567
+
568
+ shouldFail = true;
569
+ websocket.serverClose({ code: 1006 });
570
+ await waitForReconnectAttempt();
571
+ await vi.advanceTimersByTimeAsync(reconnectTime * 5);
572
+
573
+ expect(errors).toContain("Cannot refresh the token");
574
+ expect(ControlledWebSocket.instances).toHaveLength(1);
575
+ expect(socket.adapter.connecting).toBeFalse();
576
+ expect(socket.adapter.connected).toBeFalse();
577
+ expect(vi.getTimerCount()).toBe(0);
578
+ });
579
+ });
580
+
581
+ describe("When the network state changes", () => {
582
+ it("should skip reconnection attempts while offline", async () => {
583
+ const { socket, websocket } = await createConnectedSocket();
584
+ socket.onError(() => null);
585
+
586
+ socket.appManager.setOnline(false);
587
+ websocket.serverClose({ code: 1006 });
588
+ await vi.advanceTimersByTimeAsync(reconnectTime * 5);
589
+ await flushPromises();
590
+
591
+ expect(ControlledWebSocket.instances).toHaveLength(1);
592
+ expect(socket.adapter.connecting).toBeFalse();
593
+ });
594
+
595
+ it("should connect as soon as the network is back", async () => {
596
+ const { socket, websocket } = await createConnectedSocket();
597
+ socket.onError(() => null);
598
+ socket.appManager.setOnline(false);
599
+ websocket.serverClose({ code: 1006 });
600
+ await vi.advanceTimersByTimeAsync(reconnectTime);
601
+ await flushPromises();
602
+
603
+ socket.appManager.setOnline(true);
604
+ const next = await openWebSocket(2);
605
+
606
+ expect(socket.adapter.connected).toBeTrue();
607
+ expect(ControlledWebSocket.active).toStrictEqual([next]);
608
+ });
609
+
610
+ it("should keep the open connection when the online event fires", async () => {
611
+ const { socket } = await createConnectedSocket();
612
+
613
+ socket.appManager.setOnline(false);
614
+ socket.appManager.setOnline(true);
615
+ await flushPromises();
616
+
617
+ expect(ControlledWebSocket.instances).toHaveLength(1);
618
+ expect(socket.adapter.connected).toBeTrue();
619
+ });
620
+
621
+ it("should not open a second transport when the online event fires while connecting", async () => {
622
+ const socket = createSocket();
623
+ await waitForWebSocket();
624
+
625
+ socket.appManager.setOnline(true);
626
+ socket.appManager.setOnline(true);
627
+ await flushPromises();
628
+
629
+ expect(ControlledWebSocket.instances).toHaveLength(1);
630
+ });
631
+
632
+ it("should not connect on the online event without autoConnect", async () => {
633
+ const socket = createSocket({ adapterOptions: { autoConnect: false } });
634
+
635
+ socket.appManager.setOnline(false);
636
+ socket.appManager.setOnline(true);
637
+ await flushPromises();
638
+
639
+ expect(ControlledWebSocket.instances).toHaveLength(0);
640
+ expect(socket.adapter.connecting).toBeFalse();
641
+ });
642
+
643
+ it("should stay disconnected on the online event after a manual disconnect", async () => {
644
+ const { socket } = await createConnectedSocket();
645
+ await socket.disconnect();
646
+
647
+ socket.appManager.setOnline(false);
648
+ socket.appManager.setOnline(true);
649
+ await flushPromises();
650
+
651
+ expect(ControlledWebSocket.instances).toHaveLength(1);
652
+ expect(socket.adapter.connecting).toBeFalse();
653
+ });
654
+
655
+ it("should connect on the online event after the reconnection attempts ran out", async () => {
656
+ const { socket, websocket } = await createConnectedSocket({ reconnect: 0 });
657
+ socket.onError(() => null);
658
+ websocket.serverClose({ code: 1006 });
659
+ await vi.advanceTimersByTimeAsync(reconnectTime);
660
+ await flushPromises();
661
+
662
+ socket.appManager.setOnline(false);
663
+ socket.appManager.setOnline(true);
664
+ await openWebSocket(2);
665
+
666
+ expect(socket.adapter.connected).toBeTrue();
667
+ });
668
+ });
669
+ });