@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,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
- socket.onDisconnected(() => {
70
- socket.adapter.connected = false;
71
- socket.events.onConnected(spy);
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
- await socket.disconnect();
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);