@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.
- package/__tests__/e2e/e2e.lifecycle.spec.ts +258 -0
- package/__tests__/features/adapter/adapter.connection.spec.ts +27 -6
- package/__tests__/features/adapter/adapter.sse.lifecycle.spec.ts +514 -0
- package/__tests__/features/adapter/adapter.sse.spec.ts +20 -6
- package/__tests__/features/adapter/adapter.websocket.heartbeat.timers.spec.ts +337 -0
- package/__tests__/features/adapter/adapter.websocket.lifecycle.spec.ts +528 -0
- package/__tests__/features/adapter/adapter.websocket.reconnection.spec.ts +669 -0
- package/__tests__/features/delivery/delivery.backpressure.spec.ts +382 -0
- package/__tests__/features/emitter/emitter.sending.spec.ts +493 -0
- package/__tests__/features/emitter/emitter.typescript.spec.ts +153 -0
- package/__tests__/features/listener/listener.dispatch.spec.ts +427 -0
- package/__tests__/features/listener/listener.params.spec.ts +192 -0
- package/__tests__/features/socket/socket.app-manager.spec.ts +24 -2
- package/__tests__/features/socket/socket.interceptors.spec.ts +430 -0
- package/__tests__/utils/controlled-event-source.ts +149 -0
- package/__tests__/utils/controlled-websocket.ts +213 -0
- package/dist/adapter/adapter.bindings.d.ts.map +1 -1
- package/dist/adapter/adapter.d.ts.map +1 -1
- package/dist/adapter-sse/sse-adapter.d.ts.map +1 -1
- package/dist/adapter-websockets/websocket-adapter.d.ts.map +1 -1
- package/dist/emitter/emitter.d.ts.map +1 -1
- package/dist/index.mjs +284 -105
- package/dist/index.mjs.map +1 -1
- package/dist/listener/listener.d.ts +2 -0
- package/dist/listener/listener.d.ts.map +1 -1
- package/dist/socket/socket.d.ts +1 -1
- package/dist/socket/socket.utils.d.ts +11 -3
- package/dist/socket/socket.utils.d.ts.map +1 -1
- package/dist/utils/topic.utils.d.ts +10 -0
- package/dist/utils/topic.utils.d.ts.map +1 -0
- package/package.json +1 -1
- package/src/adapter/adapter.bindings.ts +44 -20
- package/src/adapter/adapter.ts +29 -10
- package/src/adapter-sse/sse-adapter.ts +95 -15
- package/src/adapter-websockets/websocket-adapter.ts +124 -41
- package/src/emitter/emitter.ts +16 -9
- package/src/listener/listener.ts +7 -8
- package/src/socket/socket.utils.ts +20 -6
- package/src/utils/topic.utils.ts +26 -0
|
@@ -0,0 +1,337 @@
|
|
|
1
|
+
import type { WebsocketAdapterOptionsType } from "adapter-websockets";
|
|
2
|
+
import { Socket } from "socket";
|
|
3
|
+
|
|
4
|
+
import {
|
|
5
|
+
ControlledWebSocket,
|
|
6
|
+
flushPromises,
|
|
7
|
+
installControlledWebSocket,
|
|
8
|
+
openWebSocket,
|
|
9
|
+
uninstallControlledWebSocket,
|
|
10
|
+
} from "../../utils/controlled-websocket";
|
|
11
|
+
|
|
12
|
+
const url = "ws://heartbeat";
|
|
13
|
+
const pingTimeout = 3000;
|
|
14
|
+
const pongTimeout = 1000;
|
|
15
|
+
const reconnectTime = 500;
|
|
16
|
+
|
|
17
|
+
describe("Websocket Adapter [ Heartbeat Timers ]", () => {
|
|
18
|
+
const sockets: Socket[] = [];
|
|
19
|
+
|
|
20
|
+
const createConnectedSocket = async (adapterOptions: WebsocketAdapterOptionsType = {}) => {
|
|
21
|
+
const socket = new Socket({
|
|
22
|
+
url,
|
|
23
|
+
reconnectTime,
|
|
24
|
+
adapterOptions: { heartbeat: true, pingTimeout, pongTimeout, ...adapterOptions },
|
|
25
|
+
});
|
|
26
|
+
sockets.push(socket);
|
|
27
|
+
const websocket = await openWebSocket();
|
|
28
|
+
return { socket, websocket };
|
|
29
|
+
};
|
|
30
|
+
|
|
31
|
+
const ping = { topic: "heartbeat", data: "heartbeat" };
|
|
32
|
+
|
|
33
|
+
beforeEach(() => {
|
|
34
|
+
installControlledWebSocket();
|
|
35
|
+
vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
|
|
36
|
+
});
|
|
37
|
+
|
|
38
|
+
afterEach(async () => {
|
|
39
|
+
await Promise.all(sockets.map((socket) => socket.disconnect()));
|
|
40
|
+
sockets.forEach((socket) => socket.appManager.unmount());
|
|
41
|
+
sockets.length = 0;
|
|
42
|
+
vi.useRealTimers();
|
|
43
|
+
uninstallControlledWebSocket();
|
|
44
|
+
});
|
|
45
|
+
|
|
46
|
+
describe("When sending pings", () => {
|
|
47
|
+
it("should not ping before the ping timeout passes", async () => {
|
|
48
|
+
const { websocket } = await createConnectedSocket();
|
|
49
|
+
|
|
50
|
+
await vi.advanceTimersByTimeAsync(pingTimeout - 1);
|
|
51
|
+
|
|
52
|
+
expect(websocket.sent).toStrictEqual([]);
|
|
53
|
+
});
|
|
54
|
+
|
|
55
|
+
it("should ping once the connection was silent for the ping timeout", async () => {
|
|
56
|
+
const { websocket } = await createConnectedSocket();
|
|
57
|
+
|
|
58
|
+
await vi.advanceTimersByTimeAsync(pingTimeout);
|
|
59
|
+
|
|
60
|
+
expect(websocket.sentMessages).toStrictEqual([ping]);
|
|
61
|
+
});
|
|
62
|
+
|
|
63
|
+
it("should use the configured heartbeat message", async () => {
|
|
64
|
+
const { websocket } = await createConnectedSocket({ heartbeatMessage: "are-you-there" });
|
|
65
|
+
|
|
66
|
+
await vi.advanceTimersByTimeAsync(pingTimeout);
|
|
67
|
+
|
|
68
|
+
expect(websocket.sentMessages).toStrictEqual([{ topic: "heartbeat", data: "are-you-there" }]);
|
|
69
|
+
});
|
|
70
|
+
|
|
71
|
+
it("should encode the ping with the custom encoder", async () => {
|
|
72
|
+
const { websocket } = await createConnectedSocket({
|
|
73
|
+
encode: ({ topic, payload }) => `${topic}|${String(payload)}`,
|
|
74
|
+
});
|
|
75
|
+
|
|
76
|
+
await vi.advanceTimersByTimeAsync(pingTimeout);
|
|
77
|
+
|
|
78
|
+
expect(websocket.sent).toStrictEqual(["heartbeat|heartbeat"]);
|
|
79
|
+
});
|
|
80
|
+
|
|
81
|
+
it("should use 5 seconds for the ping and the pong timeout by default", async () => {
|
|
82
|
+
const { socket, websocket } = await createConnectedSocket({ pingTimeout: undefined, pongTimeout: undefined });
|
|
83
|
+
socket.onError(() => null);
|
|
84
|
+
|
|
85
|
+
await vi.advanceTimersByTimeAsync(4999);
|
|
86
|
+
expect(websocket.sent).toHaveLength(0);
|
|
87
|
+
await vi.advanceTimersByTimeAsync(1);
|
|
88
|
+
expect(websocket.sent).toHaveLength(1);
|
|
89
|
+
|
|
90
|
+
await vi.advanceTimersByTimeAsync(4999);
|
|
91
|
+
expect(socket.adapter.connected).toBeTrue();
|
|
92
|
+
await vi.advanceTimersByTimeAsync(1);
|
|
93
|
+
expect(socket.adapter.connected).toBeFalse();
|
|
94
|
+
});
|
|
95
|
+
|
|
96
|
+
it("should keep pinging at the ping interval while the server answers", async () => {
|
|
97
|
+
const { socket, websocket } = await createConnectedSocket();
|
|
98
|
+
|
|
99
|
+
for (let i = 0; i < 5; i += 1) {
|
|
100
|
+
// eslint-disable-next-line no-await-in-loop
|
|
101
|
+
await vi.advanceTimersByTimeAsync(pingTimeout);
|
|
102
|
+
websocket.serverEmit("heartbeat", "pong");
|
|
103
|
+
}
|
|
104
|
+
|
|
105
|
+
expect(websocket.sentMessages).toStrictEqual([ping, ping, ping, ping, ping]);
|
|
106
|
+
expect(socket.adapter.connected).toBeTrue();
|
|
107
|
+
});
|
|
108
|
+
|
|
109
|
+
it("should not ping at all when the heartbeat is disabled", async () => {
|
|
110
|
+
const { websocket } = await createConnectedSocket({ heartbeat: false });
|
|
111
|
+
|
|
112
|
+
await vi.advanceTimersByTimeAsync(pingTimeout * 10);
|
|
113
|
+
|
|
114
|
+
expect(websocket.sent).toStrictEqual([]);
|
|
115
|
+
expect(vi.getTimerCount()).toBe(0);
|
|
116
|
+
});
|
|
117
|
+
|
|
118
|
+
it("should not ping by default", async () => {
|
|
119
|
+
const socket = new Socket({ url });
|
|
120
|
+
sockets.push(socket);
|
|
121
|
+
const websocket = await openWebSocket();
|
|
122
|
+
|
|
123
|
+
await vi.advanceTimersByTimeAsync(60_000);
|
|
124
|
+
|
|
125
|
+
expect(websocket.sent).toStrictEqual([]);
|
|
126
|
+
});
|
|
127
|
+
});
|
|
128
|
+
|
|
129
|
+
describe("When the connection is active", () => {
|
|
130
|
+
it("should postpone the ping after every incoming frame", async () => {
|
|
131
|
+
const { websocket } = await createConnectedSocket();
|
|
132
|
+
|
|
133
|
+
await vi.advanceTimersByTimeAsync(pingTimeout - 1);
|
|
134
|
+
websocket.serverEmit("ticks", 1);
|
|
135
|
+
await vi.advanceTimersByTimeAsync(pingTimeout - 1);
|
|
136
|
+
websocket.serverEmit("ticks", 2);
|
|
137
|
+
await vi.advanceTimersByTimeAsync(pingTimeout - 1);
|
|
138
|
+
|
|
139
|
+
expect(websocket.sent).toStrictEqual([]);
|
|
140
|
+
|
|
141
|
+
await vi.advanceTimersByTimeAsync(1);
|
|
142
|
+
|
|
143
|
+
expect(websocket.sentMessages).toStrictEqual([ping]);
|
|
144
|
+
});
|
|
145
|
+
|
|
146
|
+
it("should treat any frame as a pong, also the ones ignored by the decoder", async () => {
|
|
147
|
+
const { socket, websocket } = await createConnectedSocket({ decode: () => null });
|
|
148
|
+
|
|
149
|
+
await vi.advanceTimersByTimeAsync(pingTimeout);
|
|
150
|
+
websocket.serverSend("pong");
|
|
151
|
+
await vi.advanceTimersByTimeAsync(pongTimeout);
|
|
152
|
+
|
|
153
|
+
expect(socket.adapter.connected).toBeTrue();
|
|
154
|
+
});
|
|
155
|
+
|
|
156
|
+
it("should treat a frame that cannot be decoded as a pong", async () => {
|
|
157
|
+
const { socket, websocket } = await createConnectedSocket({
|
|
158
|
+
decode: () => {
|
|
159
|
+
throw new Error("Unknown frame");
|
|
160
|
+
},
|
|
161
|
+
});
|
|
162
|
+
socket.onError(() => null);
|
|
163
|
+
|
|
164
|
+
await vi.advanceTimersByTimeAsync(pingTimeout);
|
|
165
|
+
websocket.serverSend("pong");
|
|
166
|
+
await vi.advanceTimersByTimeAsync(pongTimeout);
|
|
167
|
+
|
|
168
|
+
expect(socket.adapter.connected).toBeTrue();
|
|
169
|
+
});
|
|
170
|
+
|
|
171
|
+
it("should deliver the pong to the listeners of the heartbeat topic", async () => {
|
|
172
|
+
const { socket, websocket } = await createConnectedSocket();
|
|
173
|
+
const spy = vi.fn();
|
|
174
|
+
socket
|
|
175
|
+
.createListener<string>()({ topic: "heartbeat" })
|
|
176
|
+
.listen(({ data }) => spy(data));
|
|
177
|
+
|
|
178
|
+
await vi.advanceTimersByTimeAsync(pingTimeout);
|
|
179
|
+
websocket.serverEmit("heartbeat", "pong");
|
|
180
|
+
|
|
181
|
+
expect(spy).toHaveBeenCalledWith("pong");
|
|
182
|
+
});
|
|
183
|
+
});
|
|
184
|
+
|
|
185
|
+
describe("When the server stops answering", () => {
|
|
186
|
+
it("should stay connected until the pong timeout passes", async () => {
|
|
187
|
+
const { socket } = await createConnectedSocket();
|
|
188
|
+
|
|
189
|
+
await vi.advanceTimersByTimeAsync(pingTimeout + pongTimeout - 1);
|
|
190
|
+
|
|
191
|
+
expect(socket.adapter.connected).toBeTrue();
|
|
192
|
+
});
|
|
193
|
+
|
|
194
|
+
it("should close the transport and report the lost connection", async () => {
|
|
195
|
+
const { socket, websocket } = await createConnectedSocket();
|
|
196
|
+
const events: string[] = [];
|
|
197
|
+
socket.events.onDisconnected(() => events.push("disconnected"));
|
|
198
|
+
socket.events.onError(({ error }: any) => events.push(`error:${error.message}`));
|
|
199
|
+
|
|
200
|
+
await vi.advanceTimersByTimeAsync(pingTimeout + pongTimeout);
|
|
201
|
+
|
|
202
|
+
expect(websocket.closeCalls).toHaveLength(1);
|
|
203
|
+
expect(socket.adapter.connected).toBeFalse();
|
|
204
|
+
expect(events).toStrictEqual([
|
|
205
|
+
"disconnected",
|
|
206
|
+
"error:Heartbeat timeout - the server did not respond to the ping in time",
|
|
207
|
+
]);
|
|
208
|
+
});
|
|
209
|
+
|
|
210
|
+
it("should not wait for the closing handshake of a dead connection", async () => {
|
|
211
|
+
ControlledWebSocket.autoFinishClose = false;
|
|
212
|
+
const { socket, websocket } = await createConnectedSocket();
|
|
213
|
+
socket.onError(() => null);
|
|
214
|
+
|
|
215
|
+
await vi.advanceTimersByTimeAsync(pingTimeout + pongTimeout);
|
|
216
|
+
|
|
217
|
+
// The transport is still closing, but the socket already knows the connection is gone
|
|
218
|
+
expect(websocket.readyState).toBe(ControlledWebSocket.CLOSING);
|
|
219
|
+
expect(socket.adapter.connected).toBeFalse();
|
|
220
|
+
|
|
221
|
+
await vi.advanceTimersByTimeAsync(reconnectTime);
|
|
222
|
+
await flushPromises();
|
|
223
|
+
|
|
224
|
+
expect(ControlledWebSocket.instances).toHaveLength(2);
|
|
225
|
+
ControlledWebSocket.autoFinishClose = true;
|
|
226
|
+
});
|
|
227
|
+
|
|
228
|
+
it("should reconnect after the reconnect time", async () => {
|
|
229
|
+
const { socket } = await createConnectedSocket();
|
|
230
|
+
socket.onError(() => null);
|
|
231
|
+
const reconnecting = vi.fn();
|
|
232
|
+
socket.events.onReconnecting(reconnecting);
|
|
233
|
+
|
|
234
|
+
await vi.advanceTimersByTimeAsync(pingTimeout + pongTimeout);
|
|
235
|
+
expect(reconnecting).not.toHaveBeenCalled();
|
|
236
|
+
|
|
237
|
+
await vi.advanceTimersByTimeAsync(reconnectTime);
|
|
238
|
+
await flushPromises();
|
|
239
|
+
const next = await openWebSocket(2);
|
|
240
|
+
|
|
241
|
+
expect(reconnecting).toHaveBeenCalledWith({ attempts: 0 });
|
|
242
|
+
expect(socket.adapter.connected).toBeTrue();
|
|
243
|
+
expect(ControlledWebSocket.active).toStrictEqual([next]);
|
|
244
|
+
});
|
|
245
|
+
|
|
246
|
+
it("should emit a single disconnected event when the dead transport finally closes", async () => {
|
|
247
|
+
ControlledWebSocket.autoFinishClose = false;
|
|
248
|
+
const { socket, websocket } = await createConnectedSocket();
|
|
249
|
+
socket.onError(() => null);
|
|
250
|
+
const disconnected = vi.fn();
|
|
251
|
+
socket.events.onDisconnected(disconnected);
|
|
252
|
+
|
|
253
|
+
await vi.advanceTimersByTimeAsync(pingTimeout + pongTimeout);
|
|
254
|
+
websocket.finishClose();
|
|
255
|
+
|
|
256
|
+
expect(disconnected).toHaveBeenCalledTimes(1);
|
|
257
|
+
ControlledWebSocket.autoFinishClose = true;
|
|
258
|
+
});
|
|
259
|
+
|
|
260
|
+
it("should start the heartbeat again on the new connection", async () => {
|
|
261
|
+
const { socket } = await createConnectedSocket();
|
|
262
|
+
socket.onError(() => null);
|
|
263
|
+
|
|
264
|
+
await vi.advanceTimersByTimeAsync(pingTimeout + pongTimeout + reconnectTime);
|
|
265
|
+
await flushPromises();
|
|
266
|
+
const next = await openWebSocket(2);
|
|
267
|
+
await vi.advanceTimersByTimeAsync(pingTimeout);
|
|
268
|
+
|
|
269
|
+
expect(next.sentMessages).toStrictEqual([ping]);
|
|
270
|
+
});
|
|
271
|
+
|
|
272
|
+
it("should use the heartbeat options returned by onConnect for the new connection", async () => {
|
|
273
|
+
const { socket } = await createConnectedSocket();
|
|
274
|
+
socket
|
|
275
|
+
.onError(() => null)
|
|
276
|
+
.onConnect(({ connection }) => ({
|
|
277
|
+
...connection,
|
|
278
|
+
adapterOptions: { ...connection.adapterOptions, heartbeatMessage: "second-connection" },
|
|
279
|
+
}));
|
|
280
|
+
|
|
281
|
+
await vi.advanceTimersByTimeAsync(pingTimeout + pongTimeout + reconnectTime);
|
|
282
|
+
await flushPromises();
|
|
283
|
+
const next = await openWebSocket(2);
|
|
284
|
+
await vi.advanceTimersByTimeAsync(pingTimeout);
|
|
285
|
+
|
|
286
|
+
expect(next.sentMessages).toStrictEqual([{ topic: "heartbeat", data: "second-connection" }]);
|
|
287
|
+
});
|
|
288
|
+
});
|
|
289
|
+
|
|
290
|
+
describe("When the connection ends", () => {
|
|
291
|
+
it("should clear the ping timer on disconnect", async () => {
|
|
292
|
+
const { socket, websocket } = await createConnectedSocket();
|
|
293
|
+
|
|
294
|
+
await socket.disconnect();
|
|
295
|
+
await vi.advanceTimersByTimeAsync(pingTimeout * 3);
|
|
296
|
+
|
|
297
|
+
expect(websocket.sent).toStrictEqual([]);
|
|
298
|
+
expect(vi.getTimerCount()).toBe(0);
|
|
299
|
+
});
|
|
300
|
+
|
|
301
|
+
it("should clear the pong timer on disconnect", async () => {
|
|
302
|
+
const { socket } = await createConnectedSocket();
|
|
303
|
+
const reconnecting = vi.fn();
|
|
304
|
+
socket.events.onReconnecting(reconnecting);
|
|
305
|
+
|
|
306
|
+
await vi.advanceTimersByTimeAsync(pingTimeout);
|
|
307
|
+
await socket.disconnect();
|
|
308
|
+
await vi.advanceTimersByTimeAsync(pongTimeout + reconnectTime * 3);
|
|
309
|
+
|
|
310
|
+
expect(reconnecting).not.toHaveBeenCalled();
|
|
311
|
+
expect(vi.getTimerCount()).toBe(0);
|
|
312
|
+
});
|
|
313
|
+
|
|
314
|
+
it("should stop pinging when the server closes the connection", async () => {
|
|
315
|
+
const { socket, websocket } = await createConnectedSocket();
|
|
316
|
+
socket.onError(() => null);
|
|
317
|
+
|
|
318
|
+
websocket.serverClose({ code: 1000, wasClean: true });
|
|
319
|
+
await vi.advanceTimersByTimeAsync(pingTimeout * 3);
|
|
320
|
+
|
|
321
|
+
expect(websocket.sent).toStrictEqual([]);
|
|
322
|
+
expect(vi.getTimerCount()).toBe(0);
|
|
323
|
+
});
|
|
324
|
+
|
|
325
|
+
it("should not ping through a connection that is being replaced", async () => {
|
|
326
|
+
const { socket, websocket } = await createConnectedSocket();
|
|
327
|
+
|
|
328
|
+
const reconnecting = socket.reconnect();
|
|
329
|
+
const next = await openWebSocket(2);
|
|
330
|
+
await reconnecting;
|
|
331
|
+
await vi.advanceTimersByTimeAsync(pingTimeout);
|
|
332
|
+
|
|
333
|
+
expect(websocket.sent).toStrictEqual([]);
|
|
334
|
+
expect(next.sentMessages).toStrictEqual([ping]);
|
|
335
|
+
});
|
|
336
|
+
});
|
|
337
|
+
});
|