@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,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
+ });
@@ -8,19 +8,37 @@ const socketOptions: Parameters<typeof createSocket>[0] = {
8
8
  reconnectTime: 10,
9
9
  };
10
10
 
11
+ /** A transport that reports an open connection from the start and never emits events */
12
+ class OpenWebSocket extends EventTarget {
13
+ static OPEN = 1;
14
+
15
+ static CLOSED = 3;
16
+
17
+ readyState = OpenWebSocket.OPEN;
18
+
19
+ close = vi.fn();
20
+
21
+ send = vi.fn();
22
+ }
23
+
11
24
  describe("Socket Adapter [ Connection ]", () => {
12
- const { url, startServer, stopServer } = createWebsocketMockingServer();
25
+ const { url, getServer, startServer, stopServer } = createWebsocketMockingServer();
13
26
  let socket: ReturnType<typeof createSocket>;
27
+ // The mocked WebSocket installed by the mocking server, restored after tests that replace it
28
+ let MockedWebSocket: typeof WebSocket;
14
29
 
15
30
  beforeEach(async () => {
16
31
  vi.resetAllMocks();
17
32
  startServer();
33
+ MockedWebSocket = window.WebSocket;
18
34
  socket = createSocket(socketOptions);
19
35
  });
20
36
 
21
37
  afterEach(() => {
22
38
  vi.clearAllTimers();
23
39
  vi.useRealTimers();
40
+ window.WebSocket = MockedWebSocket;
41
+ globalThis.WebSocket = MockedWebSocket;
24
42
  });
25
43
 
26
44
  afterAll(() => {
@@ -46,19 +64,40 @@ describe("Socket Adapter [ Connection ]", () => {
46
64
 
47
65
  it("should reconnect when going online", async () => {
48
66
  const spy = vi.fn();
67
+ const disconnectedSpy = vi.fn();
49
68
  await waitForConnection(socket);
69
+ socket.events.onDisconnected(disconnectedSpy);
70
+
71
+ // The network goes down and takes the connection with it
50
72
  socket.appManager.setOnline(false);
51
- socket.onDisconnected(() => {
52
- socket.adapter.connected = false;
53
- socket.events.onConnected(spy);
54
- socket.appManager.setOnline(true);
73
+ getServer().close({ code: 1006, reason: "Network lost", wasClean: false });
74
+ await waitFor(() => {
75
+ expect(disconnectedSpy).toHaveBeenCalledTimes(1);
55
76
  });
56
- await socket.disconnect();
77
+
78
+ startServer();
79
+ socket.events.onConnected(spy);
80
+ socket.appManager.setOnline(true);
81
+
57
82
  await waitFor(() => {
58
83
  expect(spy).toHaveBeenCalledTimes(1);
59
84
  });
60
85
  });
61
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
+
62
101
  it("should reconnect when connection attempt takes too long", async () => {
63
102
  // The socket from beforeEach has to finish connecting before the clock is replaced
64
103
  await waitForConnection(socket);
@@ -75,4 +114,22 @@ describe("Socket Adapter [ Connection ]", () => {
75
114
  await vi.advanceTimersByTimeAsync(1);
76
115
  expect(spy).toHaveBeenCalledTimes(1);
77
116
  });
117
+
118
+ it("should not reconnect when the WebSocket is already open", async () => {
119
+ // The socket from beforeEach has to finish connecting before the clock is replaced
120
+ await waitForConnection(socket);
121
+ vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
122
+ window.WebSocket = OpenWebSocket as unknown as typeof WebSocket;
123
+ globalThis.WebSocket = window.WebSocket;
124
+
125
+ const onReconnecting = vi.fn();
126
+ const newSocket = createSocket({ ...socketOptions, url: "ws://open", adapterOptions: { autoConnect: false } });
127
+ newSocket.events.onReconnecting(onReconnecting);
128
+
129
+ await expect(newSocket.adapter.connect()).resolves.toBeTrue();
130
+ await vi.advanceTimersByTimeAsync(30);
131
+
132
+ expect(onReconnecting).not.toHaveBeenCalled();
133
+ expect(newSocket.adapter.connected).toBeTrue();
134
+ });
78
135
  });
@@ -8,6 +8,7 @@ const socketOptions: Parameters<typeof createSocket>[0] = {
8
8
  adapter: ServerSentEventsAdapter,
9
9
  };
10
10
  const { startServer } = createSseMockingServer();
11
+ const OriginalEventSource = window.EventSource;
11
12
 
12
13
  /** Opens the mocked connection, `startServer` waits for a timer so the clock has to move for it to finish */
13
14
  const openConnection = async (start: () => Promise<void>) => {
@@ -27,6 +28,7 @@ describe("Socket SSE [ Connection ]", () => {
27
28
  // replacing the EventSource registered for the shared url while the next test is running.
28
29
  vi.clearAllTimers();
29
30
  vi.useRealTimers();
31
+ window.EventSource = OriginalEventSource;
30
32
  });
31
33
 
32
34
  it("should auto connect", async () => {
@@ -90,4 +92,47 @@ describe("Socket SSE [ Connection ]", () => {
90
92
 
91
93
  expect(onReconnecting).toHaveBeenCalledTimes(1);
92
94
  });
95
+
96
+ it("should not reconnect after disconnecting during a pending connection attempt", async () => {
97
+ const onReconnecting = vi.fn();
98
+ const onConnecting = vi.fn();
99
+ const url = "ws://localhost:2347";
100
+ const socket = createSocket({ ...socketOptions, url, adapterOptions: { autoConnect: false } });
101
+ socket.events.onReconnecting(onReconnecting);
102
+ socket.events.onConnecting(onConnecting);
103
+
104
+ socket.adapter.connect();
105
+ await vi.advanceTimersByTimeAsync(0);
106
+ await socket.adapter.disconnect();
107
+
108
+ expect(onConnecting).toHaveBeenCalledTimes(2);
109
+ expect(socket.adapter.connecting).toBeFalse();
110
+
111
+ // Several reconnect intervals pass without the cancelled attempt coming back
112
+ await vi.advanceTimersByTimeAsync(30);
113
+
114
+ expect(onReconnecting).not.toHaveBeenCalled();
115
+ expect(onConnecting).toHaveBeenCalledTimes(2);
116
+ expect(socket.adapter.connecting).toBeFalse();
117
+ });
118
+
119
+ it("should not reconnect when the EventSource is already open", async () => {
120
+ class OpenEventSource extends OriginalEventSource {
121
+ constructor(url: string | URL, eventSourceInitDict?: EventSourceInit) {
122
+ super(url, eventSourceInitDict);
123
+ Object.defineProperty(this, "readyState", { get: () => EventSource.OPEN, set: () => {} });
124
+ }
125
+ }
126
+ window.EventSource = OpenEventSource;
127
+ const onReconnecting = vi.fn();
128
+ const url = "ws://localhost:2348";
129
+ const socket = createSocket({ ...socketOptions, url, adapterOptions: { autoConnect: false } });
130
+ socket.events.onReconnecting(onReconnecting);
131
+
132
+ await expect(socket.adapter.connect()).resolves.toBeTrue();
133
+ await vi.advanceTimersByTimeAsync(30);
134
+
135
+ expect(onReconnecting).not.toHaveBeenCalled();
136
+ expect(socket.adapter.connected).toBeTrue();
137
+ });
93
138
  });