@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,514 @@
|
|
|
1
|
+
import type { ServerSentEventsAdapterType } from "adapter-sse";
|
|
2
|
+
import { ServerSentEventsAdapter } from "adapter-sse";
|
|
3
|
+
import { Socket } from "socket";
|
|
4
|
+
|
|
5
|
+
import {
|
|
6
|
+
ControlledEventSource,
|
|
7
|
+
installControlledEventSource,
|
|
8
|
+
openEventSource,
|
|
9
|
+
uninstallControlledEventSource,
|
|
10
|
+
waitForEventSource,
|
|
11
|
+
} from "../../utils/controlled-event-source";
|
|
12
|
+
import { flushPromises } from "../../utils/controlled-websocket";
|
|
13
|
+
|
|
14
|
+
const url = "http://sse-lifecycle/events";
|
|
15
|
+
const reconnectTime = 1000;
|
|
16
|
+
|
|
17
|
+
type SseSocket = Socket<ServerSentEventsAdapterType>;
|
|
18
|
+
|
|
19
|
+
describe("SSE Adapter [ Lifecycle ]", () => {
|
|
20
|
+
const sockets: SseSocket[] = [];
|
|
21
|
+
|
|
22
|
+
const createSocket = (options?: Partial<ConstructorParameters<typeof Socket<ServerSentEventsAdapterType>>[0]>) => {
|
|
23
|
+
const socket = new Socket<ServerSentEventsAdapterType>({
|
|
24
|
+
url,
|
|
25
|
+
reconnectTime,
|
|
26
|
+
adapter: ServerSentEventsAdapter,
|
|
27
|
+
...options,
|
|
28
|
+
});
|
|
29
|
+
sockets.push(socket);
|
|
30
|
+
return socket;
|
|
31
|
+
};
|
|
32
|
+
|
|
33
|
+
const createConnectedSocket = async (
|
|
34
|
+
options?: Partial<ConstructorParameters<typeof Socket<ServerSentEventsAdapterType>>[0]>,
|
|
35
|
+
) => {
|
|
36
|
+
const socket = createSocket(options);
|
|
37
|
+
const source = await openEventSource();
|
|
38
|
+
return { socket, source };
|
|
39
|
+
};
|
|
40
|
+
|
|
41
|
+
const trackEvents = (socket: SseSocket) => {
|
|
42
|
+
const events: string[] = [];
|
|
43
|
+
socket.events.onConnecting(({ connecting }) => events.push(`connecting:${connecting}`));
|
|
44
|
+
socket.events.onConnected(() => events.push("connected"));
|
|
45
|
+
socket.events.onDisconnected(() => events.push("disconnected"));
|
|
46
|
+
socket.events.onReconnecting(({ attempts }) => events.push(`reconnecting:${attempts}`));
|
|
47
|
+
socket.events.onReconnectingFailed(({ attempts }) => events.push(`failed:${attempts}`));
|
|
48
|
+
socket.events.onError(() => events.push("error"));
|
|
49
|
+
return events;
|
|
50
|
+
};
|
|
51
|
+
|
|
52
|
+
const waitForReconnectAttempt = async () => {
|
|
53
|
+
await vi.advanceTimersByTimeAsync(reconnectTime);
|
|
54
|
+
await flushPromises();
|
|
55
|
+
return ControlledEventSource.last;
|
|
56
|
+
};
|
|
57
|
+
|
|
58
|
+
/** Waits for the next attempt and lets it fail for good */
|
|
59
|
+
const failReconnectAttempt = async () => {
|
|
60
|
+
const attempt = await waitForReconnectAttempt();
|
|
61
|
+
attempt.serverFail();
|
|
62
|
+
return attempt;
|
|
63
|
+
};
|
|
64
|
+
|
|
65
|
+
/** Waits for the next attempt and lets the server accept it */
|
|
66
|
+
const openReconnectAttempt = async () => {
|
|
67
|
+
const attempt = await waitForReconnectAttempt();
|
|
68
|
+
attempt.serverOpen();
|
|
69
|
+
return attempt;
|
|
70
|
+
};
|
|
71
|
+
|
|
72
|
+
beforeEach(() => {
|
|
73
|
+
installControlledEventSource();
|
|
74
|
+
vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
|
|
75
|
+
});
|
|
76
|
+
|
|
77
|
+
afterEach(async () => {
|
|
78
|
+
await Promise.all(sockets.map((socket) => socket.disconnect()));
|
|
79
|
+
sockets.forEach((socket) => socket.appManager.unmount());
|
|
80
|
+
sockets.length = 0;
|
|
81
|
+
vi.useRealTimers();
|
|
82
|
+
uninstallControlledEventSource();
|
|
83
|
+
});
|
|
84
|
+
|
|
85
|
+
describe("When connecting", () => {
|
|
86
|
+
it("should open the stream with the url, query params and init options", async () => {
|
|
87
|
+
createSocket({
|
|
88
|
+
queryParams: { token: "abc" },
|
|
89
|
+
adapterOptions: { eventSourceInit: { withCredentials: true } },
|
|
90
|
+
});
|
|
91
|
+
|
|
92
|
+
const source = await waitForEventSource();
|
|
93
|
+
|
|
94
|
+
expect(source.url).toBe(`${url}?token=abc`);
|
|
95
|
+
expect(source.withCredentials).toBeTrue();
|
|
96
|
+
});
|
|
97
|
+
|
|
98
|
+
it("should not send credentials by default", async () => {
|
|
99
|
+
createSocket();
|
|
100
|
+
|
|
101
|
+
const source = await waitForEventSource();
|
|
102
|
+
|
|
103
|
+
expect(source.withCredentials).toBeFalse();
|
|
104
|
+
});
|
|
105
|
+
|
|
106
|
+
it("should emit connecting, then connected in order", async () => {
|
|
107
|
+
const socket = createSocket({ adapterOptions: { autoConnect: false } });
|
|
108
|
+
const events = trackEvents(socket);
|
|
109
|
+
|
|
110
|
+
const connecting = socket.connect();
|
|
111
|
+
await openEventSource();
|
|
112
|
+
await connecting;
|
|
113
|
+
|
|
114
|
+
expect(events).toStrictEqual(["connecting:true", "connecting:false", "connected"]);
|
|
115
|
+
expect(vi.getTimerCount()).toBe(0);
|
|
116
|
+
});
|
|
117
|
+
|
|
118
|
+
it("should wait for the automatic connection when connect is called right after creating the socket", async () => {
|
|
119
|
+
const socket = createSocket();
|
|
120
|
+
const resolved = vi.fn();
|
|
121
|
+
|
|
122
|
+
const connecting = socket.connect().then(resolved);
|
|
123
|
+
const source = await waitForEventSource();
|
|
124
|
+
await flushPromises();
|
|
125
|
+
expect(resolved).not.toHaveBeenCalled();
|
|
126
|
+
|
|
127
|
+
source.serverOpen();
|
|
128
|
+
await connecting;
|
|
129
|
+
|
|
130
|
+
expect(socket.adapter.connected).toBeTrue();
|
|
131
|
+
expect(ControlledEventSource.instances).toHaveLength(1);
|
|
132
|
+
});
|
|
133
|
+
|
|
134
|
+
it("should open a single stream for concurrent connect calls", async () => {
|
|
135
|
+
const socket = createSocket({ adapterOptions: { autoConnect: false } });
|
|
136
|
+
|
|
137
|
+
const first = socket.adapter.connect();
|
|
138
|
+
const second = socket.adapter.connect();
|
|
139
|
+
await openEventSource();
|
|
140
|
+
|
|
141
|
+
await expect(Promise.all([first, second])).resolves.toStrictEqual([true, true]);
|
|
142
|
+
expect(ControlledEventSource.instances).toHaveLength(1);
|
|
143
|
+
});
|
|
144
|
+
|
|
145
|
+
it("should report an error when the stream cannot be created", async () => {
|
|
146
|
+
const socket = createSocket({ adapterOptions: { autoConnect: false } });
|
|
147
|
+
const events = trackEvents(socket);
|
|
148
|
+
ControlledEventSource.constructorError = new SyntaxError("The URL is invalid");
|
|
149
|
+
|
|
150
|
+
await expect(socket.adapter.connect()).resolves.toBe(false);
|
|
151
|
+
|
|
152
|
+
expect(events).toStrictEqual(["connecting:true", "connecting:false", "error"]);
|
|
153
|
+
});
|
|
154
|
+
|
|
155
|
+
it("should start over when the stream does not open before the reconnect time", async () => {
|
|
156
|
+
const socket = createSocket();
|
|
157
|
+
const events = trackEvents(socket);
|
|
158
|
+
const hanging = await waitForEventSource();
|
|
159
|
+
|
|
160
|
+
const next = await waitForReconnectAttempt();
|
|
161
|
+
|
|
162
|
+
expect(hanging.readyState).toBe(ControlledEventSource.CLOSED);
|
|
163
|
+
expect(next).not.toBe(hanging);
|
|
164
|
+
expect(events).toStrictEqual(["reconnecting:0", "connecting:false", "disconnected", "connecting:true"]);
|
|
165
|
+
expect(ControlledEventSource.active).toStrictEqual([next]);
|
|
166
|
+
});
|
|
167
|
+
|
|
168
|
+
it("should stop after the configured number of attempts when the stream never opens", async () => {
|
|
169
|
+
const socket = createSocket({ reconnect: 2 });
|
|
170
|
+
const events = trackEvents(socket);
|
|
171
|
+
await waitForEventSource();
|
|
172
|
+
|
|
173
|
+
await waitForReconnectAttempt();
|
|
174
|
+
await waitForReconnectAttempt();
|
|
175
|
+
await vi.advanceTimersByTimeAsync(reconnectTime);
|
|
176
|
+
await flushPromises();
|
|
177
|
+
await vi.advanceTimersByTimeAsync(reconnectTime * 10);
|
|
178
|
+
|
|
179
|
+
expect(events.filter((event) => event.startsWith("reconnecting") || event.startsWith("failed"))).toStrictEqual([
|
|
180
|
+
"reconnecting:0",
|
|
181
|
+
"reconnecting:1",
|
|
182
|
+
"reconnecting:2",
|
|
183
|
+
"failed:2",
|
|
184
|
+
]);
|
|
185
|
+
expect(ControlledEventSource.instances).toHaveLength(3);
|
|
186
|
+
expect(ControlledEventSource.active).toHaveLength(0);
|
|
187
|
+
expect(vi.getTimerCount()).toBe(0);
|
|
188
|
+
});
|
|
189
|
+
});
|
|
190
|
+
|
|
191
|
+
describe("When receiving messages", () => {
|
|
192
|
+
it("should deliver messages by topic", async () => {
|
|
193
|
+
const { socket, source } = await createConnectedSocket();
|
|
194
|
+
const ticks = vi.fn();
|
|
195
|
+
const tocks = vi.fn();
|
|
196
|
+
socket
|
|
197
|
+
.createListener<number>()({ topic: "ticks" })
|
|
198
|
+
.listen(({ data }) => ticks(data));
|
|
199
|
+
socket
|
|
200
|
+
.createListener<number>()({ topic: "tocks" })
|
|
201
|
+
.listen(({ data }) => tocks(data));
|
|
202
|
+
|
|
203
|
+
source.serverEmit("ticks", 1);
|
|
204
|
+
source.serverEmit("tocks", 2);
|
|
205
|
+
|
|
206
|
+
expect(ticks.mock.calls).toStrictEqual([[1]]);
|
|
207
|
+
expect(tocks.mock.calls).toStrictEqual([[2]]);
|
|
208
|
+
});
|
|
209
|
+
|
|
210
|
+
it("should deliver every message once", async () => {
|
|
211
|
+
const { socket, source } = await createConnectedSocket();
|
|
212
|
+
const spy = vi.fn();
|
|
213
|
+
socket.createListener<number>()({ topic: "ticks" }).listen(spy);
|
|
214
|
+
|
|
215
|
+
source.serverEmit("ticks", 1);
|
|
216
|
+
source.serverEmit("ticks", 2);
|
|
217
|
+
|
|
218
|
+
expect(spy).toHaveBeenCalledTimes(2);
|
|
219
|
+
});
|
|
220
|
+
|
|
221
|
+
it("should expose the last event id through extra", async () => {
|
|
222
|
+
const { socket, source } = await createConnectedSocket();
|
|
223
|
+
const ids: string[] = [];
|
|
224
|
+
socket
|
|
225
|
+
.createListener<number>()({ topic: "ticks" })
|
|
226
|
+
.listen(({ extra }) => ids.push(extra.lastEventId));
|
|
227
|
+
|
|
228
|
+
source.serverEmit("ticks", 1, { lastEventId: "41" });
|
|
229
|
+
source.serverEmit("ticks", 2, { lastEventId: "42" });
|
|
230
|
+
|
|
231
|
+
expect(ids).toStrictEqual(["41", "42"]);
|
|
232
|
+
});
|
|
233
|
+
|
|
234
|
+
it("should map custom message formats with decode", async () => {
|
|
235
|
+
const { socket, source } = await createConnectedSocket({
|
|
236
|
+
adapterOptions: {
|
|
237
|
+
decode: (event) => {
|
|
238
|
+
const [type, payload] = String(event.data).split("|");
|
|
239
|
+
return type === "skip" ? null : { topic: type, data: payload };
|
|
240
|
+
},
|
|
241
|
+
},
|
|
242
|
+
});
|
|
243
|
+
const spy = vi.fn();
|
|
244
|
+
socket
|
|
245
|
+
.createListener<string>()({ topic: "greeting" })
|
|
246
|
+
.listen(({ data }) => spy(data));
|
|
247
|
+
|
|
248
|
+
source.serverSend("skip|ignored");
|
|
249
|
+
source.serverSend("greeting|hello");
|
|
250
|
+
|
|
251
|
+
expect(spy.mock.calls).toStrictEqual([["hello"]]);
|
|
252
|
+
});
|
|
253
|
+
|
|
254
|
+
it.each([
|
|
255
|
+
{ name: "text that is not JSON", data: "plain text" },
|
|
256
|
+
{ name: "an empty message", data: "" },
|
|
257
|
+
{ name: "a JSON array", data: "[1,2]" },
|
|
258
|
+
{ name: "an object without a topic", data: JSON.stringify({ data: 1 }) },
|
|
259
|
+
])("should ignore $name and keep the stream", async ({ data }) => {
|
|
260
|
+
const { socket, source } = await createConnectedSocket();
|
|
261
|
+
const spy = vi.fn();
|
|
262
|
+
const errors = vi.fn();
|
|
263
|
+
socket.onError(errors);
|
|
264
|
+
socket
|
|
265
|
+
.createListener<number>()({ topic: "ticks" })
|
|
266
|
+
.listen(({ data: received }) => spy(received));
|
|
267
|
+
|
|
268
|
+
source.serverSend(data);
|
|
269
|
+
source.serverEmit("ticks", 1);
|
|
270
|
+
|
|
271
|
+
expect(spy.mock.calls).toStrictEqual([[1]]);
|
|
272
|
+
expect(errors).not.toHaveBeenCalled();
|
|
273
|
+
expect(socket.adapter.connected).toBeTrue();
|
|
274
|
+
});
|
|
275
|
+
|
|
276
|
+
it("should apply the onMessage interceptors", async () => {
|
|
277
|
+
const { socket, source } = await createConnectedSocket();
|
|
278
|
+
socket.onMessage<number>(({ event }) => event * 10);
|
|
279
|
+
const spy = vi.fn();
|
|
280
|
+
socket
|
|
281
|
+
.createListener<number>()({ topic: "ticks" })
|
|
282
|
+
.listen(({ data }) => spy(data));
|
|
283
|
+
|
|
284
|
+
source.serverEmit("ticks", 4);
|
|
285
|
+
|
|
286
|
+
expect(spy).toHaveBeenCalledWith(40);
|
|
287
|
+
});
|
|
288
|
+
});
|
|
289
|
+
|
|
290
|
+
describe("When the stream breaks", () => {
|
|
291
|
+
it("should mark the socket as disconnected while the browser retries", async () => {
|
|
292
|
+
const { socket, source } = await createConnectedSocket();
|
|
293
|
+
const events = trackEvents(socket);
|
|
294
|
+
|
|
295
|
+
source.serverDrop();
|
|
296
|
+
|
|
297
|
+
expect(events).toStrictEqual(["error", "connecting:false", "disconnected", "connecting:true"]);
|
|
298
|
+
expect(socket.adapter.connected).toBeFalse();
|
|
299
|
+
expect(socket.adapter.connecting).toBeTrue();
|
|
300
|
+
});
|
|
301
|
+
|
|
302
|
+
it("should become connected again when the browser retry succeeds", async () => {
|
|
303
|
+
const { socket, source } = await createConnectedSocket();
|
|
304
|
+
source.serverDrop();
|
|
305
|
+
const events = trackEvents(socket);
|
|
306
|
+
|
|
307
|
+
source.serverOpen();
|
|
308
|
+
|
|
309
|
+
expect(events).toStrictEqual(["connecting:false", "connected"]);
|
|
310
|
+
expect(socket.adapter.connected).toBeTrue();
|
|
311
|
+
expect(ControlledEventSource.instances).toHaveLength(1);
|
|
312
|
+
expect(vi.getTimerCount()).toBe(0);
|
|
313
|
+
});
|
|
314
|
+
|
|
315
|
+
it("should keep delivering to the same listeners after the browser retry", async () => {
|
|
316
|
+
const { socket, source } = await createConnectedSocket();
|
|
317
|
+
const spy = vi.fn();
|
|
318
|
+
socket
|
|
319
|
+
.createListener<number>()({ topic: "ticks" })
|
|
320
|
+
.listen(({ data }) => spy(data));
|
|
321
|
+
|
|
322
|
+
source.serverEmit("ticks", 1);
|
|
323
|
+
source.serverDrop();
|
|
324
|
+
source.serverOpen();
|
|
325
|
+
source.serverEmit("ticks", 2);
|
|
326
|
+
|
|
327
|
+
expect(spy.mock.calls).toStrictEqual([[1], [2]]);
|
|
328
|
+
});
|
|
329
|
+
|
|
330
|
+
it("should replace the stream when the browser retry takes longer than the reconnect time", async () => {
|
|
331
|
+
const { socket, source } = await createConnectedSocket();
|
|
332
|
+
source.serverDrop();
|
|
333
|
+
const events = trackEvents(socket);
|
|
334
|
+
|
|
335
|
+
const next = await waitForReconnectAttempt();
|
|
336
|
+
next.serverOpen();
|
|
337
|
+
|
|
338
|
+
expect(source.readyState).toBe(ControlledEventSource.CLOSED);
|
|
339
|
+
expect(events).toStrictEqual([
|
|
340
|
+
"reconnecting:0",
|
|
341
|
+
"connecting:false",
|
|
342
|
+
"disconnected",
|
|
343
|
+
"connecting:true",
|
|
344
|
+
"connecting:false",
|
|
345
|
+
"connected",
|
|
346
|
+
]);
|
|
347
|
+
expect(ControlledEventSource.active).toStrictEqual([next]);
|
|
348
|
+
});
|
|
349
|
+
|
|
350
|
+
it("should mark the socket as disconnected and reconnect when the stream fails for good", async () => {
|
|
351
|
+
const { socket, source } = await createConnectedSocket();
|
|
352
|
+
const events = trackEvents(socket);
|
|
353
|
+
|
|
354
|
+
source.serverFail();
|
|
355
|
+
|
|
356
|
+
expect(events).toStrictEqual(["error", "connecting:false", "disconnected"]);
|
|
357
|
+
expect(socket.adapter.connected).toBeFalse();
|
|
358
|
+
expect(socket.adapter.connecting).toBeFalse();
|
|
359
|
+
|
|
360
|
+
const next = await waitForReconnectAttempt();
|
|
361
|
+
next.serverOpen();
|
|
362
|
+
|
|
363
|
+
expect(socket.adapter.connected).toBeTrue();
|
|
364
|
+
expect(ControlledEventSource.active).toStrictEqual([next]);
|
|
365
|
+
});
|
|
366
|
+
|
|
367
|
+
it("should emit disconnected once for a stream that failed for good", async () => {
|
|
368
|
+
const { socket, source } = await createConnectedSocket({ reconnect: 0 });
|
|
369
|
+
const disconnected = vi.fn();
|
|
370
|
+
socket.events.onDisconnected(disconnected);
|
|
371
|
+
|
|
372
|
+
source.serverFail();
|
|
373
|
+
await vi.advanceTimersByTimeAsync(reconnectTime * 3);
|
|
374
|
+
|
|
375
|
+
expect(disconnected).toHaveBeenCalledTimes(1);
|
|
376
|
+
expect(vi.getTimerCount()).toBe(0);
|
|
377
|
+
});
|
|
378
|
+
|
|
379
|
+
it("should count the attempts and reset them after the stream is back", async () => {
|
|
380
|
+
const { socket, source } = await createConnectedSocket();
|
|
381
|
+
const events = trackEvents(socket);
|
|
382
|
+
|
|
383
|
+
source.serverFail();
|
|
384
|
+
await failReconnectAttempt();
|
|
385
|
+
await openReconnectAttempt();
|
|
386
|
+
|
|
387
|
+
expect(events.filter((event) => event.startsWith("reconnecting"))).toStrictEqual([
|
|
388
|
+
"reconnecting:0",
|
|
389
|
+
"reconnecting:1",
|
|
390
|
+
]);
|
|
391
|
+
expect(socket.adapter.reconnectionAttempts).toBe(0);
|
|
392
|
+
});
|
|
393
|
+
});
|
|
394
|
+
|
|
395
|
+
describe("When disconnecting", () => {
|
|
396
|
+
it("should close the stream and emit a single disconnected event", async () => {
|
|
397
|
+
const { socket, source } = await createConnectedSocket();
|
|
398
|
+
const events = trackEvents(socket);
|
|
399
|
+
|
|
400
|
+
await socket.disconnect();
|
|
401
|
+
await socket.disconnect();
|
|
402
|
+
|
|
403
|
+
expect(source.readyState).toBe(ControlledEventSource.CLOSED);
|
|
404
|
+
expect(events).toStrictEqual(["connecting:false", "disconnected"]);
|
|
405
|
+
});
|
|
406
|
+
|
|
407
|
+
it("should not reconnect after disconnecting a stream that is still opening", async () => {
|
|
408
|
+
const socket = createSocket();
|
|
409
|
+
const source = await waitForEventSource();
|
|
410
|
+
await socket.disconnect();
|
|
411
|
+
const events = trackEvents(socket);
|
|
412
|
+
|
|
413
|
+
await vi.advanceTimersByTimeAsync(reconnectTime * 5);
|
|
414
|
+
|
|
415
|
+
expect(source.readyState).toBe(ControlledEventSource.CLOSED);
|
|
416
|
+
expect(events).toStrictEqual([]);
|
|
417
|
+
expect(ControlledEventSource.instances).toHaveLength(1);
|
|
418
|
+
expect(vi.getTimerCount()).toBe(0);
|
|
419
|
+
});
|
|
420
|
+
|
|
421
|
+
it("should cancel the reconnection scheduled after a failure", async () => {
|
|
422
|
+
const { socket, source } = await createConnectedSocket();
|
|
423
|
+
source.serverFail();
|
|
424
|
+
|
|
425
|
+
await socket.disconnect();
|
|
426
|
+
await vi.advanceTimersByTimeAsync(reconnectTime * 5);
|
|
427
|
+
|
|
428
|
+
expect(ControlledEventSource.instances).toHaveLength(1);
|
|
429
|
+
expect(vi.getTimerCount()).toBe(0);
|
|
430
|
+
});
|
|
431
|
+
|
|
432
|
+
it("should stop the browser retry of a dropped stream", async () => {
|
|
433
|
+
const { socket, source } = await createConnectedSocket();
|
|
434
|
+
source.serverDrop();
|
|
435
|
+
|
|
436
|
+
await socket.disconnect();
|
|
437
|
+
|
|
438
|
+
expect(source.readyState).toBe(ControlledEventSource.CLOSED);
|
|
439
|
+
expect(socket.adapter.connecting).toBeFalse();
|
|
440
|
+
expect(vi.getTimerCount()).toBe(0);
|
|
441
|
+
});
|
|
442
|
+
|
|
443
|
+
it("should ignore messages and errors of a closed stream", async () => {
|
|
444
|
+
const { socket, source } = await createConnectedSocket();
|
|
445
|
+
const spy = vi.fn();
|
|
446
|
+
socket.createListener<number>()({ topic: "ticks" }).listen(spy);
|
|
447
|
+
await socket.disconnect();
|
|
448
|
+
const events = trackEvents(socket);
|
|
449
|
+
|
|
450
|
+
source.serverEmit("ticks", 1);
|
|
451
|
+
source.dispatchEvent(new Event("error"));
|
|
452
|
+
source.dispatchEvent(new Event("open"));
|
|
453
|
+
|
|
454
|
+
expect(spy).not.toHaveBeenCalled();
|
|
455
|
+
expect(events).toStrictEqual([]);
|
|
456
|
+
expect(socket.adapter.connected).toBeFalse();
|
|
457
|
+
});
|
|
458
|
+
|
|
459
|
+
it("should stay disconnected when the network comes back after a manual disconnect", async () => {
|
|
460
|
+
const { socket } = await createConnectedSocket();
|
|
461
|
+
await socket.disconnect();
|
|
462
|
+
|
|
463
|
+
socket.appManager.setOnline(false);
|
|
464
|
+
socket.appManager.setOnline(true);
|
|
465
|
+
await flushPromises();
|
|
466
|
+
|
|
467
|
+
expect(ControlledEventSource.instances).toHaveLength(1);
|
|
468
|
+
expect(socket.adapter.connecting).toBeFalse();
|
|
469
|
+
});
|
|
470
|
+
|
|
471
|
+
it("should connect again on demand", async () => {
|
|
472
|
+
const { socket } = await createConnectedSocket();
|
|
473
|
+
await socket.disconnect();
|
|
474
|
+
|
|
475
|
+
const connecting = socket.connect();
|
|
476
|
+
const next = await openEventSource(2);
|
|
477
|
+
await connecting;
|
|
478
|
+
|
|
479
|
+
expect(socket.adapter.connected).toBeTrue();
|
|
480
|
+
expect(ControlledEventSource.active).toStrictEqual([next]);
|
|
481
|
+
});
|
|
482
|
+
});
|
|
483
|
+
|
|
484
|
+
describe("When reconnecting manually", () => {
|
|
485
|
+
it("should replace the stream and resolve when the new one is open", async () => {
|
|
486
|
+
const { socket, source } = await createConnectedSocket();
|
|
487
|
+
const resolved = vi.fn();
|
|
488
|
+
|
|
489
|
+
const reconnecting = socket.reconnect().then(resolved);
|
|
490
|
+
const next = await waitForEventSource(2);
|
|
491
|
+
await flushPromises();
|
|
492
|
+
expect(resolved).not.toHaveBeenCalled();
|
|
493
|
+
|
|
494
|
+
next.serverOpen();
|
|
495
|
+
await reconnecting;
|
|
496
|
+
|
|
497
|
+
expect(source.readyState).toBe(ControlledEventSource.CLOSED);
|
|
498
|
+
expect(socket.adapter.connected).toBeTrue();
|
|
499
|
+
});
|
|
500
|
+
|
|
501
|
+
it("should use the connection details returned by onConnect for every attempt", async () => {
|
|
502
|
+
let token = "first";
|
|
503
|
+
const { socket } = await createConnectedSocket();
|
|
504
|
+
socket.onConnect(({ connection }) => ({ ...connection, queryParams: { token } }));
|
|
505
|
+
|
|
506
|
+
token = "second";
|
|
507
|
+
const reconnecting = socket.reconnect();
|
|
508
|
+
const next = await openEventSource(2);
|
|
509
|
+
await reconnecting;
|
|
510
|
+
|
|
511
|
+
expect(next.url).toBe(`${url}?token=second`);
|
|
512
|
+
});
|
|
513
|
+
});
|
|
514
|
+
});
|
|
@@ -13,7 +13,7 @@ const socketOptions: Parameters<typeof createSocket>[0] = {
|
|
|
13
13
|
};
|
|
14
14
|
|
|
15
15
|
describe("Socket Adapter [ SSE ]", () => {
|
|
16
|
-
const { startServer, emitError } = createSseMockingServer();
|
|
16
|
+
const { startServer, emitError, getSource } = createSseMockingServer();
|
|
17
17
|
let socket = createSocket<ServerSentEventsAdapterType>(socketOptions);
|
|
18
18
|
let originalEventSource: typeof EventSource;
|
|
19
19
|
|
|
@@ -42,7 +42,7 @@ describe("Socket Adapter [ SSE ]", () => {
|
|
|
42
42
|
it("should throw error when emitting", async () => {
|
|
43
43
|
await startServer();
|
|
44
44
|
|
|
45
|
-
|
|
45
|
+
expect(() => socket.adapter.emit({} as any)).toThrow("Cannot emit events in SSE adapter");
|
|
46
46
|
});
|
|
47
47
|
|
|
48
48
|
it("should reconnect when going online", async () => {
|
|
@@ -56,11 +56,11 @@ describe("Socket Adapter [ SSE ]", () => {
|
|
|
56
56
|
expect(spy).toHaveBeenCalledTimes(1);
|
|
57
57
|
});
|
|
58
58
|
|
|
59
|
-
//
|
|
59
|
+
// The network goes down and the stream fails for good
|
|
60
60
|
socket.appManager.setOnline(false);
|
|
61
|
-
|
|
61
|
+
getSource().readyState = 2;
|
|
62
|
+
emitError({ code: 1006, reason: "Network lost", wasClean: false });
|
|
62
63
|
|
|
63
|
-
// Wait for disconnect to complete
|
|
64
64
|
await waitFor(() => {
|
|
65
65
|
expect(socket.adapter.connected).toBe(false);
|
|
66
66
|
});
|
|
@@ -76,6 +76,20 @@ describe("Socket Adapter [ SSE ]", () => {
|
|
|
76
76
|
});
|
|
77
77
|
});
|
|
78
78
|
|
|
79
|
+
it("should stay disconnected when going online after a manual disconnect", async () => {
|
|
80
|
+
const connectingSpy = vi.fn();
|
|
81
|
+
await startServer();
|
|
82
|
+
await socket.disconnect();
|
|
83
|
+
socket.events.onConnecting(connectingSpy);
|
|
84
|
+
|
|
85
|
+
socket.appManager.setOnline(false);
|
|
86
|
+
socket.appManager.setOnline(true);
|
|
87
|
+
|
|
88
|
+
expect(connectingSpy).not.toHaveBeenCalled();
|
|
89
|
+
expect(socket.adapter.connecting).toBe(false);
|
|
90
|
+
expect(socket.adapter.connected).toBe(false);
|
|
91
|
+
});
|
|
92
|
+
|
|
79
93
|
it("should not reconnect when connection is open", async () => {
|
|
80
94
|
const spy = vi.fn();
|
|
81
95
|
|
|
@@ -278,7 +292,7 @@ describe("Socket Adapter [ SSE ]", () => {
|
|
|
278
292
|
// Give time for any potential error events
|
|
279
293
|
await sleep(10);
|
|
280
294
|
|
|
281
|
-
expect(errorSpy).toHaveBeenCalled();
|
|
295
|
+
expect(errorSpy).not.toHaveBeenCalled();
|
|
282
296
|
expect(socket.adapter.connected).toBe(false);
|
|
283
297
|
});
|
|
284
298
|
|