@hyper-fetch/sockets 9.6.0 → 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 (40) hide show
  1. package/__tests__/e2e/e2e.lifecycle.spec.ts +258 -0
  2. package/__tests__/features/adapter/adapter.connection.spec.ts +63 -6
  3. package/__tests__/features/adapter/adapter.sse.connection.spec.ts +45 -0
  4. package/__tests__/features/adapter/adapter.sse.lifecycle.spec.ts +514 -0
  5. package/__tests__/features/adapter/adapter.sse.spec.ts +20 -6
  6. package/__tests__/features/adapter/adapter.websocket.heartbeat.timers.spec.ts +337 -0
  7. package/__tests__/features/adapter/adapter.websocket.lifecycle.spec.ts +528 -0
  8. package/__tests__/features/adapter/adapter.websocket.reconnection.spec.ts +669 -0
  9. package/__tests__/features/delivery/delivery.backpressure.spec.ts +382 -0
  10. package/__tests__/features/emitter/emitter.sending.spec.ts +493 -0
  11. package/__tests__/features/emitter/emitter.typescript.spec.ts +153 -0
  12. package/__tests__/features/listener/listener.dispatch.spec.ts +427 -0
  13. package/__tests__/features/listener/listener.params.spec.ts +192 -0
  14. package/__tests__/features/socket/socket.app-manager.spec.ts +24 -2
  15. package/__tests__/features/socket/socket.interceptors.spec.ts +430 -0
  16. package/__tests__/utils/controlled-event-source.ts +149 -0
  17. package/__tests__/utils/controlled-websocket.ts +213 -0
  18. package/dist/adapter/adapter.bindings.d.ts.map +1 -1
  19. package/dist/adapter/adapter.d.ts.map +1 -1
  20. package/dist/adapter-sse/sse-adapter.d.ts.map +1 -1
  21. package/dist/adapter-websockets/websocket-adapter.d.ts.map +1 -1
  22. package/dist/emitter/emitter.d.ts.map +1 -1
  23. package/dist/index.mjs +289 -105
  24. package/dist/index.mjs.map +1 -1
  25. package/dist/listener/listener.d.ts +2 -0
  26. package/dist/listener/listener.d.ts.map +1 -1
  27. package/dist/socket/socket.d.ts +1 -1
  28. package/dist/socket/socket.utils.d.ts +11 -3
  29. package/dist/socket/socket.utils.d.ts.map +1 -1
  30. package/dist/utils/topic.utils.d.ts +10 -0
  31. package/dist/utils/topic.utils.d.ts.map +1 -0
  32. package/package.json +1 -1
  33. package/src/adapter/adapter.bindings.ts +44 -20
  34. package/src/adapter/adapter.ts +29 -10
  35. package/src/adapter-sse/sse-adapter.ts +101 -13
  36. package/src/adapter-websockets/websocket-adapter.ts +126 -41
  37. package/src/emitter/emitter.ts +16 -9
  38. package/src/listener/listener.ts +7 -8
  39. package/src/socket/socket.utils.ts +20 -6
  40. package/src/utils/topic.utils.ts +26 -0
@@ -0,0 +1,427 @@
1
+ import { getAdapterBindings } from "adapter";
2
+ import { Socket } from "socket";
3
+
4
+ import type { ControlledWebSocket } from "../../utils/controlled-websocket";
5
+ import {
6
+ installControlledWebSocket,
7
+ openWebSocket,
8
+ uninstallControlledWebSocket,
9
+ } from "../../utils/controlled-websocket";
10
+
11
+ type Tick = { value: number };
12
+
13
+ describe("Listener [ Dispatch ]", () => {
14
+ let socket: Socket;
15
+ let websocket: ControlledWebSocket;
16
+
17
+ beforeEach(async () => {
18
+ installControlledWebSocket();
19
+ socket = new Socket({ url: "ws://dispatch", reconnectTime: 100 });
20
+ websocket = await openWebSocket();
21
+ });
22
+
23
+ afterEach(async () => {
24
+ await socket.disconnect();
25
+ uninstallControlledWebSocket();
26
+ });
27
+
28
+ describe("When many callbacks listen to one topic", () => {
29
+ it("should call every callback once per message", () => {
30
+ const listener = socket.createListener<Tick>()({ topic: "ticks" });
31
+ const spies = [vi.fn(), vi.fn(), vi.fn()];
32
+ spies.forEach((spy) => listener.listen(({ data }) => spy(data)));
33
+
34
+ websocket.serverEmit("ticks", { value: 1 });
35
+
36
+ spies.forEach((spy) => {
37
+ expect(spy).toHaveBeenCalledTimes(1);
38
+ expect(spy).toHaveBeenCalledWith({ value: 1 });
39
+ });
40
+ });
41
+
42
+ it("should call the callbacks in the order they subscribed", () => {
43
+ const listener = socket.createListener<Tick>()({ topic: "ticks" });
44
+ const order: string[] = [];
45
+ listener.listen(() => order.push("first"));
46
+ listener.listen(() => order.push("second"));
47
+ listener.listen(() => order.push("third"));
48
+
49
+ websocket.serverEmit("ticks", { value: 1 });
50
+
51
+ expect(order).toStrictEqual(["first", "second", "third"]);
52
+ });
53
+
54
+ it("should stop only the unsubscribed callback", () => {
55
+ const listener = socket.createListener<Tick>()({ topic: "ticks" });
56
+ const first = vi.fn();
57
+ const second = vi.fn();
58
+ const third = vi.fn();
59
+ listener.listen(first);
60
+ const stopSecond = listener.listen(second);
61
+ listener.listen(third);
62
+
63
+ stopSecond();
64
+ websocket.serverEmit("ticks", { value: 1 });
65
+
66
+ expect(first).toHaveBeenCalledTimes(1);
67
+ expect(second).not.toHaveBeenCalled();
68
+ expect(third).toHaveBeenCalledTimes(1);
69
+ });
70
+
71
+ it("should share the callbacks registered through separate listener instances of the same topic", () => {
72
+ const first = vi.fn();
73
+ const second = vi.fn();
74
+ socket.createListener<Tick>()({ topic: "ticks" }).listen(first);
75
+ socket.createListener<Tick>()({ topic: "ticks" }).listen(second);
76
+
77
+ websocket.serverEmit("ticks", { value: 1 });
78
+
79
+ expect(first).toHaveBeenCalledTimes(1);
80
+ expect(second).toHaveBeenCalledTimes(1);
81
+ expect(socket.adapter.listeners.get("ticks")?.size).toBe(2);
82
+ });
83
+
84
+ it("should keep the messages of every topic apart", () => {
85
+ const ticks = vi.fn();
86
+ const tocks = vi.fn();
87
+ socket
88
+ .createListener<Tick>()({ topic: "ticks" })
89
+ .listen(({ data }) => ticks(data));
90
+ socket
91
+ .createListener<Tick>()({ topic: "tocks" })
92
+ .listen(({ data }) => tocks(data));
93
+
94
+ websocket.serverEmit("ticks", { value: 1 });
95
+ websocket.serverEmit("tocks", { value: 2 });
96
+ websocket.serverEmit("ticks", { value: 3 });
97
+
98
+ expect(ticks.mock.calls).toStrictEqual([[{ value: 1 }], [{ value: 3 }]]);
99
+ expect(tocks.mock.calls).toStrictEqual([[{ value: 2 }]]);
100
+ });
101
+
102
+ it("should not treat a topic as a prefix or a pattern", () => {
103
+ const spy = vi.fn();
104
+ socket.createListener<Tick>()({ topic: "ticks" }).listen(spy);
105
+ socket.createListener<Tick>()({ topic: "*" }).listen(spy);
106
+
107
+ websocket.serverEmit("ticks/1", { value: 1 });
108
+ websocket.serverEmit("tick", { value: 1 });
109
+ websocket.serverEmit("TICKS", { value: 1 });
110
+
111
+ expect(spy).not.toHaveBeenCalled();
112
+ });
113
+
114
+ it("should keep 10000 messages in order", () => {
115
+ const received: number[] = [];
116
+ socket
117
+ .createListener<Tick>()({ topic: "ticks" })
118
+ .listen(({ data }) => received.push(data.value));
119
+
120
+ for (let i = 0; i < 10_000; i += 1) {
121
+ websocket.serverEmit("ticks", { value: i });
122
+ }
123
+
124
+ expect(received).toHaveLength(10_000);
125
+ expect(received.every((value, index) => value === index)).toBeTrue();
126
+ });
127
+ });
128
+
129
+ describe("When a callback changes the subscriptions during a dispatch", () => {
130
+ it("should let a callback unsubscribe itself and listen only once", () => {
131
+ const listener = socket.createListener<Tick>()({ topic: "ticks" });
132
+ const spy = vi.fn();
133
+ const stop = listener.listen(({ data }) => {
134
+ spy(data);
135
+ stop();
136
+ });
137
+
138
+ websocket.serverEmit("ticks", { value: 1 });
139
+ websocket.serverEmit("ticks", { value: 2 });
140
+
141
+ expect(spy).toHaveBeenCalledTimes(1);
142
+ expect(spy).toHaveBeenCalledWith({ value: 1 });
143
+ });
144
+
145
+ it("should still call the callbacks registered after the one that unsubscribed itself", () => {
146
+ const listener = socket.createListener<Tick>()({ topic: "ticks" });
147
+ const after = vi.fn();
148
+ const stop = listener.listen(() => stop());
149
+ listener.listen(after);
150
+
151
+ websocket.serverEmit("ticks", { value: 1 });
152
+
153
+ expect(after).toHaveBeenCalledTimes(1);
154
+ });
155
+
156
+ it("should not call a callback that was unsubscribed earlier in the same dispatch", () => {
157
+ const listener = socket.createListener<Tick>()({ topic: "ticks" });
158
+ const removed = vi.fn();
159
+ let stopRemoved: () => void = () => null;
160
+ listener.listen(() => stopRemoved());
161
+ stopRemoved = listener.listen(removed);
162
+
163
+ websocket.serverEmit("ticks", { value: 1 });
164
+
165
+ expect(removed).not.toHaveBeenCalled();
166
+ });
167
+
168
+ it("should deliver the next message, not the current one, to a callback added during a dispatch", () => {
169
+ const listener = socket.createListener<Tick>()({ topic: "ticks" });
170
+ const late = vi.fn();
171
+ let added = false;
172
+ listener.listen(() => {
173
+ if (!added) {
174
+ added = true;
175
+ listener.listen(({ data }) => late(data));
176
+ }
177
+ });
178
+
179
+ websocket.serverEmit("ticks", { value: 1 });
180
+ expect(late).not.toHaveBeenCalled();
181
+
182
+ websocket.serverEmit("ticks", { value: 2 });
183
+ expect(late.mock.calls).toStrictEqual([[{ value: 2 }]]);
184
+ });
185
+
186
+ it("should not loop when every callback subscribes another one", () => {
187
+ const listener = socket.createListener<Tick>()({ topic: "ticks" });
188
+ const subscribe = () => {
189
+ listener.listen(() => subscribe());
190
+ };
191
+ subscribe();
192
+
193
+ websocket.serverEmit("ticks", { value: 1 });
194
+
195
+ expect(socket.adapter.listeners.get("ticks")?.size).toBe(2);
196
+ });
197
+ });
198
+
199
+ describe("When a callback throws", () => {
200
+ it("should still call the other callbacks of the topic", () => {
201
+ const listener = socket.createListener<Tick>()({ topic: "ticks" });
202
+ const before = vi.fn();
203
+ const after = vi.fn();
204
+ listener.listen(before);
205
+ listener.listen(() => {
206
+ throw new Error("Broken callback");
207
+ });
208
+ listener.listen(after);
209
+
210
+ expect(() => socket.adapter.triggerListeners({ topic: "ticks", data: { value: 1 }, extra: {} as any })).toThrow(
211
+ "Broken callback",
212
+ );
213
+
214
+ expect(before).toHaveBeenCalledTimes(1);
215
+ expect(after).toHaveBeenCalledTimes(1);
216
+ });
217
+
218
+ it("should still publish the message on the socket events", () => {
219
+ const listener = socket.createListener<Tick>()({ topic: "ticks" });
220
+ const global = vi.fn();
221
+ const byTopic = vi.fn();
222
+ listener.listen(() => {
223
+ throw new Error("Broken callback");
224
+ });
225
+ socket.events.onListenerEvent(global);
226
+ socket.events.onListenerEventByTopic(listener, byTopic);
227
+
228
+ const { onEvent } = getAdapterBindings(socket);
229
+
230
+ expect(() => onEvent({ topic: "ticks", data: { value: 1 }, extra: {} as any })).toThrow("Broken callback");
231
+
232
+ expect(global).toHaveBeenCalledTimes(1);
233
+ expect(byTopic).toHaveBeenCalledTimes(1);
234
+ });
235
+
236
+ it("should keep the connection and deliver the next messages", () => {
237
+ const listener = socket.createListener<Tick>()({ topic: "ticks" });
238
+ const spy = vi.fn();
239
+ listener.listen(({ data }) => {
240
+ if (data.value === 1) {
241
+ throw new Error("Broken callback");
242
+ }
243
+ spy(data);
244
+ });
245
+
246
+ const { onEvent } = getAdapterBindings(socket);
247
+ expect(() => onEvent({ topic: "ticks", data: { value: 1 }, extra: {} as any })).toThrow("Broken callback");
248
+ websocket.serverEmit("ticks", { value: 2 });
249
+
250
+ expect(spy).toHaveBeenCalledWith({ value: 2 });
251
+ expect(socket.adapter.connected).toBeTrue();
252
+ });
253
+ });
254
+
255
+ describe("When unsubscribing", () => {
256
+ it("should emit the remove event once, also when unsubscribe is called twice", () => {
257
+ const listener = socket.createListener<Tick>()({ topic: "ticks" });
258
+ const removed = vi.fn();
259
+ const removedByTopic = vi.fn();
260
+ socket.events.onListenerRemove(removed);
261
+ socket.events.onListenerRemoveByTopic(listener, removedByTopic);
262
+ const stop = listener.listen(() => null);
263
+
264
+ stop();
265
+ stop();
266
+
267
+ expect(removed).toHaveBeenCalledTimes(1);
268
+ expect(removed).toHaveBeenCalledWith({ topic: "ticks" });
269
+ expect(removedByTopic).toHaveBeenCalledTimes(1);
270
+ });
271
+
272
+ it("should report whether a callback was removed", () => {
273
+ const listener = socket.createListener<Tick>()({ topic: "ticks" });
274
+ const callback = () => null;
275
+ listener.listen(callback);
276
+
277
+ expect(socket.adapter.removeListener({ topic: "ticks", callback })).toBeTrue();
278
+ expect(socket.adapter.removeListener({ topic: "ticks", callback })).toBeFalse();
279
+ expect(socket.adapter.removeListener({ topic: "unknown", callback })).toBeFalse();
280
+ });
281
+
282
+ it("should not remove the callbacks of other topics", () => {
283
+ const callback = vi.fn();
284
+ const stopTicks = socket.createListener<Tick>()({ topic: "ticks" }).listen(callback);
285
+ socket.createListener<Tick>()({ topic: "tocks" }).listen(callback);
286
+
287
+ stopTicks();
288
+ websocket.serverEmit("ticks", { value: 1 });
289
+ websocket.serverEmit("tocks", { value: 2 });
290
+
291
+ expect(callback).toHaveBeenCalledTimes(1);
292
+ expect(callback.mock.calls[0][0].data).toStrictEqual({ value: 2 });
293
+ });
294
+
295
+ it("should leave no callbacks after every subscription was stopped", () => {
296
+ const listener = socket.createListener<Tick>()({ topic: "ticks" });
297
+ const stops = Array.from({ length: 50 }, () => listener.listen(() => null));
298
+
299
+ stops.forEach((stop) => stop());
300
+
301
+ expect(socket.adapter.listeners.get("ticks")?.size).toBe(0);
302
+ });
303
+
304
+ it("should allow subscribing again after unsubscribing", () => {
305
+ const listener = socket.createListener<Tick>()({ topic: "ticks" });
306
+ const spy = vi.fn();
307
+ listener.listen(spy)();
308
+ listener.listen(spy);
309
+
310
+ websocket.serverEmit("ticks", { value: 1 });
311
+
312
+ expect(spy).toHaveBeenCalledTimes(1);
313
+ });
314
+ });
315
+
316
+ describe("When the connection changes", () => {
317
+ it("should allow subscribing before the socket is connected", async () => {
318
+ const lazy = new Socket({ url: "ws://lazy", adapterOptions: { autoConnect: false } });
319
+ const spy = vi.fn();
320
+ lazy
321
+ .createListener<Tick>()({ topic: "ticks" })
322
+ .listen(({ data }) => spy(data));
323
+
324
+ const connecting = lazy.connect();
325
+ const lazyWebsocket = await openWebSocket(2);
326
+ await connecting;
327
+ lazyWebsocket.serverEmit("ticks", { value: 1 });
328
+
329
+ expect(spy).toHaveBeenCalledWith({ value: 1 });
330
+ await lazy.disconnect();
331
+ });
332
+
333
+ it("should keep every subscription exactly once after a reconnect", async () => {
334
+ const listener = socket.createListener<Tick>()({ topic: "ticks" });
335
+ const first = vi.fn();
336
+ const second = vi.fn();
337
+ listener.listen(first);
338
+ listener.listen(second);
339
+
340
+ const reconnecting = socket.reconnect();
341
+ const next = await openWebSocket(2);
342
+ await reconnecting;
343
+ next.serverEmit("ticks", { value: 1 });
344
+
345
+ expect(first).toHaveBeenCalledTimes(1);
346
+ expect(second).toHaveBeenCalledTimes(1);
347
+ expect(socket.adapter.listeners.get("ticks")?.size).toBe(2);
348
+ });
349
+
350
+ it("should keep the subscriptions after disconnecting and connecting again", async () => {
351
+ const spy = vi.fn();
352
+ socket.createListener<Tick>()({ topic: "ticks" }).listen(spy);
353
+
354
+ await socket.disconnect();
355
+ const connecting = socket.connect();
356
+ const next = await openWebSocket(2);
357
+ await connecting;
358
+ next.serverEmit("ticks", { value: 1 });
359
+
360
+ expect(spy).toHaveBeenCalledTimes(1);
361
+ });
362
+
363
+ it("should allow unsubscribing while the socket is disconnected", async () => {
364
+ const spy = vi.fn();
365
+ const stop = socket.createListener<Tick>()({ topic: "ticks" }).listen(spy);
366
+
367
+ await socket.disconnect();
368
+ stop();
369
+ const connecting = socket.connect();
370
+ const next = await openWebSocket(2);
371
+ await connecting;
372
+ next.serverEmit("ticks", { value: 1 });
373
+
374
+ expect(spy).not.toHaveBeenCalled();
375
+ });
376
+ });
377
+
378
+ describe("When the server sends malformed frames", () => {
379
+ it.each([
380
+ { name: "text that is not JSON", frame: "not json at all" },
381
+ { name: "an empty frame", frame: "" },
382
+ { name: "a JSON null", frame: "null" },
383
+ { name: "a JSON number", frame: "42" },
384
+ { name: "a JSON array", frame: "[1,2,3]" },
385
+ { name: "an object without a topic", frame: JSON.stringify({ data: { value: 1 } }) },
386
+ { name: "a binary frame", frame: new Uint8Array([1, 2, 3]).buffer },
387
+ { name: "a blob", frame: new Blob(["binary"]) },
388
+ ])("should ignore $name and keep the connection", ({ frame }) => {
389
+ const spy = vi.fn();
390
+ const errors = vi.fn();
391
+ socket.onError(errors);
392
+ socket
393
+ .createListener<Tick>()({ topic: "ticks" })
394
+ .listen(({ data }) => spy(data));
395
+
396
+ expect(() => websocket.serverSend(frame)).not.toThrow();
397
+ websocket.serverEmit("ticks", { value: 1 });
398
+
399
+ expect(spy.mock.calls).toStrictEqual([[{ value: 1 }]]);
400
+ expect(errors).not.toHaveBeenCalled();
401
+ expect(socket.adapter.connected).toBeTrue();
402
+ });
403
+
404
+ it("should deliver a message without data as undefined", () => {
405
+ const spy = vi.fn();
406
+ socket
407
+ .createListener<undefined>()({ topic: "ping" })
408
+ .listen(({ data }) => spy(data));
409
+
410
+ websocket.serverSend(JSON.stringify({ topic: "ping" }));
411
+
412
+ expect(spy).toHaveBeenCalledWith(undefined);
413
+ });
414
+
415
+ it("should pass the raw MessageEvent as extra", () => {
416
+ const extras: MessageEvent[] = [];
417
+ socket
418
+ .createListener<Tick>()({ topic: "ticks" })
419
+ .listen(({ extra }) => extras.push(extra));
420
+
421
+ websocket.serverEmit("ticks", { value: 1 });
422
+
423
+ expect(extras[0]).toBeInstanceOf(MessageEvent);
424
+ expect(extras[0].data).toBe(JSON.stringify({ topic: "ticks", data: { value: 1 } }));
425
+ });
426
+ });
427
+ });
@@ -0,0 +1,192 @@
1
+ import { Socket } from "socket";
2
+ import { expectTypeOf } from "vitest";
3
+
4
+ const socket = new Socket({ url: "ws://params", adapterOptions: { autoConnect: false } });
5
+
6
+ describe("Listener [ Params ]", () => {
7
+ describe("When setting params on a listener", () => {
8
+ it("should fill a single param", () => {
9
+ const listener = socket.createListener<string>()({ topic: "chat/:roomId" }).setParams({ roomId: 1 });
10
+
11
+ expect(listener.topic).toBe("chat/1");
12
+ expect(listener.params).toStrictEqual({ roomId: 1 });
13
+ });
14
+
15
+ it("should fill many params", () => {
16
+ const listener = socket
17
+ .createListener<string>()({ topic: "orgs/:orgId/rooms/:roomId/users/:userId" })
18
+ .setParams({ orgId: "acme", roomId: 2, userId: "ann" });
19
+
20
+ expect(listener.topic).toBe("orgs/acme/rooms/2/users/ann");
21
+ });
22
+
23
+ it("should not change the listener used as a template", () => {
24
+ const template = socket.createListener<string>()({ topic: "chat/:roomId" });
25
+
26
+ template.setParams({ roomId: 1 });
27
+
28
+ expect(template.topic).toBe("chat/:roomId");
29
+ expect(template.params).toBeUndefined();
30
+ });
31
+
32
+ it("should replace the params when they are set again", () => {
33
+ const first = socket.createListener<string>()({ topic: "chat/:roomId" }).setParams({ roomId: 1 });
34
+ const second = first.setParams({ roomId: 2 });
35
+
36
+ expect(first.topic).toBe("chat/1");
37
+ expect(second.topic).toBe("chat/2");
38
+ expect(second.params).toStrictEqual({ roomId: 2 });
39
+ });
40
+
41
+ it("should keep the params through setOptions, setDelivery and clone", () => {
42
+ const listener = socket.createListener<string>()({ topic: "chat/:roomId" }).setParams({ roomId: 1 });
43
+
44
+ expect(listener.setOptions(undefined).topic).toBe("chat/1");
45
+ expect(listener.setDelivery({ strategy: "latest", interval: 10 }).topic).toBe("chat/1");
46
+ expect(listener.clone().topic).toBe("chat/1");
47
+ expect(listener.clone().params).toStrictEqual({ roomId: 1 });
48
+ });
49
+
50
+ it("should allow new params after other methods cloned the listener", () => {
51
+ const listener = socket
52
+ .createListener<string>()({ topic: "chat/:roomId" })
53
+ .setParams({ roomId: 1 })
54
+ .setDelivery({ strategy: "batch", interval: 10 })
55
+ .setParams({ roomId: 2 });
56
+
57
+ expect(listener.topic).toBe("chat/2");
58
+ expect(listener.delivery).toStrictEqual({ strategy: "batch", interval: 10 });
59
+ });
60
+
61
+ it("should not let a short param name replace the beginning of a longer one", () => {
62
+ const listener = socket.createListener<string>()({ topic: "items/:id/:idx" }).setParams({ id: 1, idx: 2 });
63
+
64
+ expect(listener.topic).toBe("items/1/2");
65
+ });
66
+
67
+ it("should insert values with replacement patterns literally", () => {
68
+ const listener = socket.createListener<string>()({ topic: "files/:name" }).setParams({ name: "a$&b$1" });
69
+
70
+ expect(listener.topic).toBe("files/a$&b$1");
71
+ });
72
+
73
+ it("should not parse a value containing a colon as another param", () => {
74
+ const listener = socket.createListener<string>()({ topic: ":first/:second" }).setParams({
75
+ first: ":second",
76
+ second: "value",
77
+ });
78
+
79
+ expect(listener.topic).toBe(":second/value");
80
+ });
81
+
82
+ it.each([
83
+ { value: 0, topic: "items/0" },
84
+ { value: "", topic: "items/" },
85
+ { value: false, topic: "items/false" },
86
+ ])("should fill the falsy value $value", ({ value, topic }) => {
87
+ const listener = socket
88
+ .createListener<string>()({ topic: "items/:id" })
89
+ .setParams({ id: value as any });
90
+
91
+ expect(listener.topic).toBe(topic);
92
+ });
93
+
94
+ it("should leave params without a value untouched", () => {
95
+ const listener = socket
96
+ .createListener<string>()({ topic: "a/:first/:second" })
97
+ .setParams({ first: 1 } as any);
98
+
99
+ expect(listener.topic).toBe("a/1/:second");
100
+ });
101
+
102
+ it("should listen on separate topics for separate params", () => {
103
+ const template = socket.createListener<string>()({ topic: "chat/:roomId" });
104
+ const first = vi.fn();
105
+ const second = vi.fn();
106
+ const stopFirst = template.setParams({ roomId: 1 }).listen(({ data }) => first(data));
107
+ const stopSecond = template.setParams({ roomId: 2 }).listen(({ data }) => second(data));
108
+
109
+ socket.adapter.triggerListeners({ topic: "chat/1", data: "one", extra: {} as any });
110
+ socket.adapter.triggerListeners({ topic: "chat/2", data: "two", extra: {} as any });
111
+
112
+ expect(first.mock.calls).toStrictEqual([["one"]]);
113
+ expect(second.mock.calls).toStrictEqual([["two"]]);
114
+ stopFirst();
115
+ stopSecond();
116
+ });
117
+ });
118
+
119
+ describe("When setting params on an emitter", () => {
120
+ it("should replace the params when they are set again", () => {
121
+ const emitter = socket.createEmitter<string>()({ topic: "chat/:roomId" }).setParams({ roomId: 1 });
122
+
123
+ expect(emitter.topic).toBe("chat/1");
124
+ expect(emitter.setParams({ roomId: 2 }).topic).toBe("chat/2");
125
+ });
126
+
127
+ it("should not let a short param name replace the beginning of a longer one", () => {
128
+ const emitter = socket.createEmitter<string>()({ topic: "items/:id/:idx" }).setParams({ id: 1, idx: 2 });
129
+
130
+ expect(emitter.topic).toBe("items/1/2");
131
+ });
132
+
133
+ it("should insert values with replacement patterns literally", () => {
134
+ const emitter = socket.createEmitter<string>()({ topic: "files/:name" }).setParams({ name: "a$&b" });
135
+
136
+ expect(emitter.topic).toBe("files/a$&b");
137
+ });
138
+
139
+ it("should keep the params through setPayload and setOptions", () => {
140
+ const emitter = socket
141
+ .createEmitter<string>()({ topic: "chat/:roomId" })
142
+ .setParams({ roomId: 1 })
143
+ .setPayload("hi")
144
+ .setOptions(undefined);
145
+
146
+ expect(emitter.topic).toBe("chat/1");
147
+ expect(emitter.payload).toBe("hi");
148
+ expect(emitter.params).toStrictEqual({ roomId: 1 });
149
+ });
150
+ });
151
+
152
+ describe("When checking the types", () => {
153
+ it("should type the params from the topic", () => {
154
+ const listener = socket.createListener<string>()({ topic: "orgs/:orgId/rooms/:roomId" });
155
+ const emitter = socket.createEmitter<string>()({ topic: "orgs/:orgId/rooms/:roomId" });
156
+
157
+ expectTypeOf(listener.setParams).parameter(0).toHaveProperty("orgId");
158
+ expectTypeOf(listener.setParams).parameter(0).toHaveProperty("roomId");
159
+ expectTypeOf(emitter.setParams).parameter(0).toHaveProperty("orgId");
160
+ expectTypeOf(emitter.setParams).parameter(0).toHaveProperty("roomId");
161
+ // @ts-expect-error - unknown param
162
+ listener.setParams({ orgId: 1, roomId: 1, other: 1 });
163
+ // @ts-expect-error - missing param
164
+ emitter.setParams({ orgId: 1 });
165
+ });
166
+
167
+ it("should keep the topic literal and the data types through the methods", () => {
168
+ const listener = socket.createListener<{ text: string }>()({ topic: "chat/:roomId" }).setParams({ roomId: 1 });
169
+ const emitter = socket.createEmitter<{ text: string }>()({ topic: "chat/:roomId" }).setParams({ roomId: 1 });
170
+
171
+ expectTypeOf(listener.topic).toEqualTypeOf<"chat/:roomId">();
172
+ expectTypeOf(emitter.topic).toEqualTypeOf<"chat/:roomId">();
173
+ listener.listen(({ data, extra }) => {
174
+ expectTypeOf(data).toEqualTypeOf<{ text: string }>();
175
+ expectTypeOf(extra).toEqualTypeOf<MessageEvent<any>>();
176
+ })();
177
+ expectTypeOf(emitter.setPayload).parameter(0).toExtend<{ text: string }>();
178
+ });
179
+
180
+ it("should require the payload and the params only when they are missing", () => {
181
+ const emitter = socket.createEmitter<{ text: string }>()({ topic: "chat/:roomId" });
182
+ const ready = emitter.setParams({ roomId: 1 }).setPayload({ text: "hi" });
183
+
184
+ expectTypeOf(ready.emit).toBeCallableWith();
185
+ expectTypeOf(emitter.emit).toBeCallableWith({ payload: { text: "hi" }, params: { roomId: 1 } });
186
+ // @ts-expect-error - payload has a wrong shape
187
+ expectTypeOf(emitter.emit).toBeCallableWith({ payload: { text: 1 }, params: { roomId: 1 } });
188
+ // @ts-expect-error - payload and params are required
189
+ expectTypeOf(emitter.emit).toBeCallableWith();
190
+ });
191
+ });
192
+ });
@@ -11,7 +11,7 @@ const setNavigatorOnline = (value: boolean) => {
11
11
  };
12
12
 
13
13
  describe("Socket [ App Manager ]", () => {
14
- const { url, startServer, stopServer } = createWebsocketMockingServer();
14
+ const { url, getServer, startServer, stopServer } = createWebsocketMockingServer();
15
15
  const sockets: Socket<WebsocketAdapterType>[] = [];
16
16
 
17
17
  const create = (...args: Parameters<typeof createSocket<WebsocketAdapterType>>) => {
@@ -59,11 +59,18 @@ describe("Socket [ App Manager ]", () => {
59
59
  it("should reconnect when the browser comes back online", async () => {
60
60
  const socket = create();
61
61
  await waitForConnection(socket);
62
+ const onDisconnected = vi.fn();
63
+ socket.events.onDisconnected(onDisconnected);
62
64
 
65
+ // The network goes down and takes the connection with it
63
66
  window.dispatchEvent(new Event("offline"));
64
- await socket.disconnect();
67
+ getServer().close({ code: 1006, reason: "Network lost", wasClean: false });
68
+ await waitFor(() => {
69
+ expect(onDisconnected).toHaveBeenCalledTimes(1);
70
+ });
65
71
  expect(socket.adapter.connected).toBeFalse();
66
72
 
73
+ startServer();
67
74
  const onConnected = vi.fn();
68
75
  socket.events.onConnected(onConnected);
69
76
  window.dispatchEvent(new Event("online"));
@@ -74,6 +81,21 @@ describe("Socket [ App Manager ]", () => {
74
81
  });
75
82
  });
76
83
 
84
+ it("should stay disconnected when the browser comes back online after a manual disconnect", async () => {
85
+ const socket = create();
86
+ await waitForConnection(socket);
87
+ await socket.disconnect();
88
+ const onConnecting = vi.fn();
89
+ socket.events.onConnecting(onConnecting);
90
+
91
+ window.dispatchEvent(new Event("offline"));
92
+ window.dispatchEvent(new Event("online"));
93
+
94
+ expect(onConnecting).not.toHaveBeenCalled();
95
+ expect(socket.adapter.connecting).toBeFalse();
96
+ expect(socket.adapter.connected).toBeFalse();
97
+ });
98
+
77
99
  it("should not connect while the browser is offline", async () => {
78
100
  const socket = create({ adapterOptions: { autoConnect: false } });
79
101