@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,258 @@
|
|
|
1
|
+
import { createSseE2EServer, createWebsocketE2EServer, sleep } from "@hyper-fetch/testing";
|
|
2
|
+
import { ServerSentEventsAdapter } from "adapter-sse";
|
|
3
|
+
import net from "net";
|
|
4
|
+
import { Socket } from "socket";
|
|
5
|
+
|
|
6
|
+
/** A TCP server that accepts connections and never answers - the handshake of every client hangs */
|
|
7
|
+
const createSilentServer = async () => {
|
|
8
|
+
const connections: net.Socket[] = [];
|
|
9
|
+
const server = net.createServer((connection) => {
|
|
10
|
+
connections.push(connection);
|
|
11
|
+
connection.on("error", () => null);
|
|
12
|
+
});
|
|
13
|
+
await new Promise<void>((resolve) => {
|
|
14
|
+
server.listen(0, "127.0.0.1", () => resolve());
|
|
15
|
+
});
|
|
16
|
+
const { port } = server.address() as net.AddressInfo;
|
|
17
|
+
|
|
18
|
+
return {
|
|
19
|
+
port,
|
|
20
|
+
connections,
|
|
21
|
+
stop: async () => {
|
|
22
|
+
connections.forEach((connection) => connection.destroy());
|
|
23
|
+
await new Promise((resolve) => {
|
|
24
|
+
server.close(resolve);
|
|
25
|
+
});
|
|
26
|
+
},
|
|
27
|
+
};
|
|
28
|
+
};
|
|
29
|
+
|
|
30
|
+
describe("E2E [ Lifecycle ]", () => {
|
|
31
|
+
describe("When using a real WebSocket server", () => {
|
|
32
|
+
it("should be connected when connect resolves right after creating the socket", async () => {
|
|
33
|
+
const { startServer, stopServer } = createWebsocketE2EServer();
|
|
34
|
+
const url = await startServer();
|
|
35
|
+
const socket = new Socket({ url });
|
|
36
|
+
|
|
37
|
+
await socket.connect();
|
|
38
|
+
|
|
39
|
+
expect(socket.adapter.connected).toBe(true);
|
|
40
|
+
await socket.disconnect();
|
|
41
|
+
await stopServer();
|
|
42
|
+
});
|
|
43
|
+
|
|
44
|
+
it("should send a message emitted right after awaiting connect", async () => {
|
|
45
|
+
const { startServer, stopServer, waitForMessage, waitForClient } = createWebsocketE2EServer();
|
|
46
|
+
const url = await startServer();
|
|
47
|
+
const client = waitForClient();
|
|
48
|
+
const socket = new Socket({ url });
|
|
49
|
+
await client;
|
|
50
|
+
const message = waitForMessage();
|
|
51
|
+
|
|
52
|
+
await socket.connect();
|
|
53
|
+
socket
|
|
54
|
+
.createEmitter<{ value: number }>()({ topic: "ready" })
|
|
55
|
+
.emit({ payload: { value: 1 } });
|
|
56
|
+
|
|
57
|
+
await expect(message).resolves.toStrictEqual({ topic: "ready", data: { value: 1 } });
|
|
58
|
+
await socket.disconnect();
|
|
59
|
+
await stopServer();
|
|
60
|
+
});
|
|
61
|
+
|
|
62
|
+
it("should stay disconnected after disconnecting a connection that is still opening", async () => {
|
|
63
|
+
const silent = await createSilentServer();
|
|
64
|
+
const socket = new Socket({ url: `ws://127.0.0.1:${silent.port}`, reconnectTime: 100 });
|
|
65
|
+
const reconnecting = vi.fn();
|
|
66
|
+
const connecting = vi.fn();
|
|
67
|
+
const errors = vi.fn();
|
|
68
|
+
await vi.waitFor(() => expect(silent.connections.length).toBeGreaterThanOrEqual(1));
|
|
69
|
+
|
|
70
|
+
await socket.disconnect();
|
|
71
|
+
// Everything the socket does from now on would be acting against the manual disconnect
|
|
72
|
+
socket.events.onReconnecting(reconnecting);
|
|
73
|
+
socket.events.onConnecting(connecting);
|
|
74
|
+
socket.events.onError(errors);
|
|
75
|
+
await sleep(400);
|
|
76
|
+
|
|
77
|
+
expect(reconnecting).not.toHaveBeenCalled();
|
|
78
|
+
expect(connecting).not.toHaveBeenCalled();
|
|
79
|
+
expect(errors).not.toHaveBeenCalled();
|
|
80
|
+
expect(socket.adapter.connected).toBe(false);
|
|
81
|
+
expect(socket.adapter.connecting).toBe(false);
|
|
82
|
+
await silent.stop();
|
|
83
|
+
});
|
|
84
|
+
|
|
85
|
+
it("should give up after the configured attempts when the handshake never finishes", async () => {
|
|
86
|
+
const silent = await createSilentServer();
|
|
87
|
+
const socket = new Socket({ url: `ws://127.0.0.1:${silent.port}`, reconnect: 2, reconnectTime: 40 });
|
|
88
|
+
const attempts: number[] = [];
|
|
89
|
+
const failed = vi.fn();
|
|
90
|
+
socket.onError(() => null);
|
|
91
|
+
socket.events.onReconnecting(({ attempts: attempt }) => attempts.push(attempt));
|
|
92
|
+
socket.events.onReconnectingFailed(failed);
|
|
93
|
+
|
|
94
|
+
await vi.waitFor(() => expect(failed).toHaveBeenCalledTimes(1), { timeout: 5000 });
|
|
95
|
+
await sleep(200);
|
|
96
|
+
|
|
97
|
+
expect(attempts).toStrictEqual([0, 1, 2]);
|
|
98
|
+
expect(failed).toHaveBeenCalledWith({ attempts: 2 });
|
|
99
|
+
expect(socket.adapter.connecting).toBe(false);
|
|
100
|
+
await socket.disconnect();
|
|
101
|
+
await silent.stop();
|
|
102
|
+
});
|
|
103
|
+
|
|
104
|
+
it("should not report an error for a manual disconnect", async () => {
|
|
105
|
+
const { startServer, stopServer } = createWebsocketE2EServer();
|
|
106
|
+
const url = await startServer();
|
|
107
|
+
const socket = new Socket({ url });
|
|
108
|
+
const errors = vi.fn();
|
|
109
|
+
const disconnected = vi.fn();
|
|
110
|
+
await socket.connect();
|
|
111
|
+
socket.onError(errors);
|
|
112
|
+
socket.events.onDisconnected(disconnected);
|
|
113
|
+
|
|
114
|
+
await socket.disconnect();
|
|
115
|
+
|
|
116
|
+
expect(errors).not.toHaveBeenCalled();
|
|
117
|
+
expect(disconnected).toHaveBeenCalledTimes(1);
|
|
118
|
+
await stopServer();
|
|
119
|
+
});
|
|
120
|
+
|
|
121
|
+
it("should deliver the data returned by an onMessage interceptor", async () => {
|
|
122
|
+
const { startServer, stopServer, sendToAll } = createWebsocketE2EServer();
|
|
123
|
+
const url = await startServer();
|
|
124
|
+
const socket = new Socket({ url }).onMessage<{ value: number }>(({ event }) => ({
|
|
125
|
+
...event,
|
|
126
|
+
value: event.value + 1,
|
|
127
|
+
}));
|
|
128
|
+
const received = vi.fn();
|
|
129
|
+
socket
|
|
130
|
+
.createListener<{ value: number }>()({ topic: "numbers" })
|
|
131
|
+
.listen(({ data }) => received(data));
|
|
132
|
+
await socket.connect();
|
|
133
|
+
|
|
134
|
+
sendToAll("numbers", { value: 41 });
|
|
135
|
+
|
|
136
|
+
await vi.waitFor(() => expect(received).toHaveBeenCalledWith({ value: 42 }));
|
|
137
|
+
await socket.disconnect();
|
|
138
|
+
await stopServer();
|
|
139
|
+
});
|
|
140
|
+
|
|
141
|
+
it("should keep the connection when the server sends binary and malformed frames", async () => {
|
|
142
|
+
const { startServer, stopServer, sendToAll, sendRawToAll, getConnectedClients } = createWebsocketE2EServer();
|
|
143
|
+
const url = await startServer();
|
|
144
|
+
const socket = new Socket({ url });
|
|
145
|
+
const received = vi.fn();
|
|
146
|
+
const errors = vi.fn();
|
|
147
|
+
socket.onError(errors);
|
|
148
|
+
socket
|
|
149
|
+
.createListener<number>()({ topic: "numbers" })
|
|
150
|
+
.listen(({ data }) => received(data));
|
|
151
|
+
await socket.connect();
|
|
152
|
+
await vi.waitFor(() => expect(getConnectedClients()).toHaveLength(1));
|
|
153
|
+
|
|
154
|
+
getConnectedClients()[0].send(Buffer.from([0, 1, 2, 255]));
|
|
155
|
+
sendRawToAll("{ broken json");
|
|
156
|
+
sendRawToAll("");
|
|
157
|
+
sendToAll("numbers", 1);
|
|
158
|
+
|
|
159
|
+
await vi.waitFor(() => expect(received).toHaveBeenCalledWith(1));
|
|
160
|
+
expect(received).toHaveBeenCalledTimes(1);
|
|
161
|
+
expect(errors).not.toHaveBeenCalled();
|
|
162
|
+
expect(socket.adapter.connected).toBe(true);
|
|
163
|
+
await socket.disconnect();
|
|
164
|
+
await stopServer();
|
|
165
|
+
});
|
|
166
|
+
});
|
|
167
|
+
|
|
168
|
+
describe("When using a real Server-Sent Events server", () => {
|
|
169
|
+
it("should be connected when connect resolves right after creating the socket", async () => {
|
|
170
|
+
const { startServer, stopServer } = createSseE2EServer();
|
|
171
|
+
const url = await startServer();
|
|
172
|
+
const socket = new Socket({ url, adapter: ServerSentEventsAdapter });
|
|
173
|
+
|
|
174
|
+
await socket.connect();
|
|
175
|
+
|
|
176
|
+
expect(socket.adapter.connected).toBe(true);
|
|
177
|
+
await socket.disconnect();
|
|
178
|
+
await stopServer();
|
|
179
|
+
});
|
|
180
|
+
|
|
181
|
+
it("should report the disconnection when the server drops the stream", async () => {
|
|
182
|
+
const { startServer, stopServer, closeAllClients } = createSseE2EServer();
|
|
183
|
+
const url = await startServer();
|
|
184
|
+
const socket = new Socket({ url, adapter: ServerSentEventsAdapter, reconnectTime: 10_000 });
|
|
185
|
+
const disconnected = vi.fn();
|
|
186
|
+
socket.onError(() => null);
|
|
187
|
+
socket.events.onDisconnected(disconnected);
|
|
188
|
+
await socket.connect();
|
|
189
|
+
|
|
190
|
+
closeAllClients();
|
|
191
|
+
|
|
192
|
+
await vi.waitFor(() => expect(disconnected).toHaveBeenCalledTimes(1), { timeout: 5000 });
|
|
193
|
+
expect(socket.adapter.connected).toBe(false);
|
|
194
|
+
await socket.disconnect();
|
|
195
|
+
await stopServer();
|
|
196
|
+
});
|
|
197
|
+
|
|
198
|
+
it("should receive messages again after the dropped stream is back", async () => {
|
|
199
|
+
const { startServer, stopServer, closeAllClients, sendEvent, getConnectedCount } = createSseE2EServer();
|
|
200
|
+
const url = await startServer();
|
|
201
|
+
const socket = new Socket({ url, adapter: ServerSentEventsAdapter, reconnectTime: 100 });
|
|
202
|
+
const received = vi.fn();
|
|
203
|
+
const connected = vi.fn();
|
|
204
|
+
socket.onError(() => null);
|
|
205
|
+
socket
|
|
206
|
+
.createListener<number>()({ topic: "numbers" })
|
|
207
|
+
.listen(({ data }) => received(data));
|
|
208
|
+
await socket.connect();
|
|
209
|
+
socket.events.onConnected(connected);
|
|
210
|
+
|
|
211
|
+
closeAllClients();
|
|
212
|
+
await vi.waitFor(() => expect(connected).toHaveBeenCalledTimes(1), { timeout: 8000 });
|
|
213
|
+
await vi.waitFor(() => expect(getConnectedCount()).toBe(1), { timeout: 5000 });
|
|
214
|
+
sendEvent("numbers", 7);
|
|
215
|
+
|
|
216
|
+
await vi.waitFor(() => expect(received).toHaveBeenCalledWith(7), { timeout: 5000 });
|
|
217
|
+
expect(received).toHaveBeenCalledTimes(1);
|
|
218
|
+
await socket.disconnect();
|
|
219
|
+
await stopServer();
|
|
220
|
+
}, 20_000);
|
|
221
|
+
|
|
222
|
+
it("should stay disconnected after disconnecting a stream that is still opening", async () => {
|
|
223
|
+
const silent = await createSilentServer();
|
|
224
|
+
const socket = new Socket({
|
|
225
|
+
url: `http://127.0.0.1:${silent.port}`,
|
|
226
|
+
adapter: ServerSentEventsAdapter,
|
|
227
|
+
reconnectTime: 100,
|
|
228
|
+
});
|
|
229
|
+
const reconnecting = vi.fn();
|
|
230
|
+
const connecting = vi.fn();
|
|
231
|
+
await vi.waitFor(() => expect(silent.connections.length).toBeGreaterThanOrEqual(1));
|
|
232
|
+
|
|
233
|
+
await socket.disconnect();
|
|
234
|
+
// Everything the socket does from now on would be acting against the manual disconnect
|
|
235
|
+
socket.events.onReconnecting(reconnecting);
|
|
236
|
+
socket.events.onConnecting(connecting);
|
|
237
|
+
await sleep(400);
|
|
238
|
+
|
|
239
|
+
expect(reconnecting).not.toHaveBeenCalled();
|
|
240
|
+
expect(connecting).not.toHaveBeenCalled();
|
|
241
|
+
expect(socket.adapter.connecting).toBe(false);
|
|
242
|
+
await silent.stop();
|
|
243
|
+
});
|
|
244
|
+
|
|
245
|
+
it("should throw from emit instead of leaving an unhandled rejection", async () => {
|
|
246
|
+
const { startServer, stopServer } = createSseE2EServer();
|
|
247
|
+
const url = await startServer();
|
|
248
|
+
const socket = new Socket({ url, adapter: ServerSentEventsAdapter });
|
|
249
|
+
await socket.connect();
|
|
250
|
+
|
|
251
|
+
expect(() => socket.createEmitter<number>()({ topic: "numbers" }).emit({ payload: 1 })).toThrow(
|
|
252
|
+
"Cannot emit events in SSE adapter",
|
|
253
|
+
);
|
|
254
|
+
await socket.disconnect();
|
|
255
|
+
await stopServer();
|
|
256
|
+
});
|
|
257
|
+
});
|
|
258
|
+
});
|
|
@@ -22,7 +22,7 @@ class OpenWebSocket extends EventTarget {
|
|
|
22
22
|
}
|
|
23
23
|
|
|
24
24
|
describe("Socket Adapter [ Connection ]", () => {
|
|
25
|
-
const { url, startServer, stopServer } = createWebsocketMockingServer();
|
|
25
|
+
const { url, getServer, startServer, stopServer } = createWebsocketMockingServer();
|
|
26
26
|
let socket: ReturnType<typeof createSocket>;
|
|
27
27
|
// The mocked WebSocket installed by the mocking server, restored after tests that replace it
|
|
28
28
|
let MockedWebSocket: typeof WebSocket;
|
|
@@ -64,19 +64,40 @@ describe("Socket Adapter [ Connection ]", () => {
|
|
|
64
64
|
|
|
65
65
|
it("should reconnect when going online", async () => {
|
|
66
66
|
const spy = vi.fn();
|
|
67
|
+
const disconnectedSpy = vi.fn();
|
|
67
68
|
await waitForConnection(socket);
|
|
69
|
+
socket.events.onDisconnected(disconnectedSpy);
|
|
70
|
+
|
|
71
|
+
// The network goes down and takes the connection with it
|
|
68
72
|
socket.appManager.setOnline(false);
|
|
69
|
-
|
|
70
|
-
|
|
71
|
-
|
|
72
|
-
socket.appManager.setOnline(true);
|
|
73
|
+
getServer().close({ code: 1006, reason: "Network lost", wasClean: false });
|
|
74
|
+
await waitFor(() => {
|
|
75
|
+
expect(disconnectedSpy).toHaveBeenCalledTimes(1);
|
|
73
76
|
});
|
|
74
|
-
|
|
77
|
+
|
|
78
|
+
startServer();
|
|
79
|
+
socket.events.onConnected(spy);
|
|
80
|
+
socket.appManager.setOnline(true);
|
|
81
|
+
|
|
75
82
|
await waitFor(() => {
|
|
76
83
|
expect(spy).toHaveBeenCalledTimes(1);
|
|
77
84
|
});
|
|
78
85
|
});
|
|
79
86
|
|
|
87
|
+
it("should stay disconnected when going online after a manual disconnect", async () => {
|
|
88
|
+
const connectingSpy = vi.fn();
|
|
89
|
+
await waitForConnection(socket);
|
|
90
|
+
await socket.disconnect();
|
|
91
|
+
socket.events.onConnecting(connectingSpy);
|
|
92
|
+
|
|
93
|
+
socket.appManager.setOnline(false);
|
|
94
|
+
socket.appManager.setOnline(true);
|
|
95
|
+
|
|
96
|
+
expect(connectingSpy).not.toHaveBeenCalled();
|
|
97
|
+
expect(socket.adapter.connecting).toBe(false);
|
|
98
|
+
expect(socket.adapter.connected).toBe(false);
|
|
99
|
+
});
|
|
100
|
+
|
|
80
101
|
it("should reconnect when connection attempt takes too long", async () => {
|
|
81
102
|
// The socket from beforeEach has to finish connecting before the clock is replaced
|
|
82
103
|
await waitForConnection(socket);
|