@hyper-fetch/sockets 8.0.1 → 8.1.0
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.callbacks.spec.ts +224 -0
- package/__tests__/e2e/e2e.connection.spec.ts +162 -0
- package/__tests__/e2e/e2e.edge-cases.spec.ts +232 -0
- package/__tests__/e2e/e2e.emitters.spec.ts +160 -0
- package/__tests__/e2e/e2e.heartbeat.spec.ts +162 -0
- package/__tests__/e2e/e2e.listeners.spec.ts +215 -0
- package/__tests__/e2e/e2e.reconnection.spec.ts +240 -0
- package/__tests__/e2e/e2e.sse.spec.ts +191 -0
- package/__tests__/features/adapter/adapter.sse.connection.spec.ts +1 -1
- package/__tests__/features/sdk/sdk.base.spec.ts +125 -0
- package/__tests__/features/sdk/sdk.configuration.spec.ts +341 -0
- package/__tests__/vitest.setup.ts +19 -6
- package/dist/adapter/adapter.bindings.d.ts.map +1 -1
- package/dist/adapter-sse/sse-adapter.d.ts.map +1 -1
- package/dist/adapter-sse/sse-adapter.utils.d.ts +1 -1
- package/dist/adapter-sse/sse-adapter.utils.d.ts.map +1 -1
- package/dist/adapter-websockets/websocket-adapter.utils.d.ts +1 -1
- package/dist/adapter-websockets/websocket-adapter.utils.d.ts.map +1 -1
- package/dist/index.d.ts +1 -0
- package/dist/index.d.ts.map +1 -1
- package/dist/index.mjs +153 -32
- package/dist/index.mjs.map +1 -1
- package/dist/sdk/index.d.ts +2 -0
- package/dist/sdk/index.d.ts.map +1 -0
- package/dist/sdk/sdk.d.ts +70 -0
- package/dist/sdk/sdk.d.ts.map +1 -0
- package/dist/socket/index.d.ts +1 -0
- package/dist/socket/index.d.ts.map +1 -1
- package/dist/socket/socket.create.d.ts +5 -0
- package/dist/socket/socket.create.d.ts.map +1 -0
- package/package.json +1 -1
- package/src/adapter/adapter.bindings.ts +15 -6
- package/src/adapter-sse/sse-adapter.ts +6 -14
- package/src/adapter-sse/sse-adapter.utils.ts +8 -7
- package/src/adapter-websockets/websocket-adapter.utils.ts +5 -4
- package/src/index.ts +1 -0
- package/src/sdk/index.ts +1 -0
- package/src/sdk/sdk.ts +268 -0
- package/src/socket/index.ts +1 -0
- package/src/socket/socket.create.ts +10 -0
- package/vite.config.ts +1 -0
|
@@ -0,0 +1,224 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* @vitest-environment node
|
|
3
|
+
*/
|
|
4
|
+
import { Socket } from "@hyper-fetch/sockets";
|
|
5
|
+
import { createWebsocketE2EServer, sleep, waitForConnection } from "@hyper-fetch/testing";
|
|
6
|
+
|
|
7
|
+
describe("E2E [ WebSocket Callbacks & Interceptors ]", () => {
|
|
8
|
+
it("should fire onConnected callback", async () => {
|
|
9
|
+
const { startServer, stopServer } = createWebsocketE2EServer();
|
|
10
|
+
const url = await startServer();
|
|
11
|
+
|
|
12
|
+
let fired = false;
|
|
13
|
+
const socket = new Socket({ url, adapterOptions: { autoConnect: false } });
|
|
14
|
+
socket.onConnected(() => {
|
|
15
|
+
fired = true;
|
|
16
|
+
});
|
|
17
|
+
|
|
18
|
+
await socket.connect();
|
|
19
|
+
await waitForConnection(socket);
|
|
20
|
+
|
|
21
|
+
expect(fired).toBe(true);
|
|
22
|
+
|
|
23
|
+
await socket.disconnect();
|
|
24
|
+
await stopServer();
|
|
25
|
+
});
|
|
26
|
+
|
|
27
|
+
it("should fire onDisconnected callback", async () => {
|
|
28
|
+
const { startServer, stopServer } = createWebsocketE2EServer();
|
|
29
|
+
const url = await startServer();
|
|
30
|
+
|
|
31
|
+
const socket = new Socket({ url });
|
|
32
|
+
await waitForConnection(socket);
|
|
33
|
+
|
|
34
|
+
let fired = false;
|
|
35
|
+
socket.onDisconnected(() => {
|
|
36
|
+
fired = true;
|
|
37
|
+
});
|
|
38
|
+
|
|
39
|
+
await socket.disconnect();
|
|
40
|
+
await sleep(100);
|
|
41
|
+
|
|
42
|
+
expect(fired).toBe(true);
|
|
43
|
+
|
|
44
|
+
await stopServer();
|
|
45
|
+
});
|
|
46
|
+
|
|
47
|
+
it("should fire onReconnect callback on each attempt", async () => {
|
|
48
|
+
const { startServer, stopServer, terminateAllClients } = createWebsocketE2EServer();
|
|
49
|
+
const url = await startServer();
|
|
50
|
+
|
|
51
|
+
const socket = new Socket({ url, reconnectTime: 150, reconnect: 3 });
|
|
52
|
+
await waitForConnection(socket);
|
|
53
|
+
|
|
54
|
+
let reconnectCount = 0;
|
|
55
|
+
socket.onReconnect(() => {
|
|
56
|
+
reconnectCount += 1;
|
|
57
|
+
});
|
|
58
|
+
|
|
59
|
+
terminateAllClients();
|
|
60
|
+
await sleep(1000);
|
|
61
|
+
|
|
62
|
+
expect(reconnectCount).toBeGreaterThanOrEqual(1);
|
|
63
|
+
|
|
64
|
+
await socket.disconnect();
|
|
65
|
+
await stopServer();
|
|
66
|
+
});
|
|
67
|
+
|
|
68
|
+
it("should fire onReconnectFailed when attempts are exhausted", async () => {
|
|
69
|
+
const wsServer = createWebsocketE2EServer();
|
|
70
|
+
const url = await wsServer.startServer();
|
|
71
|
+
|
|
72
|
+
const socket = new Socket({ url, reconnect: 1, reconnectTime: 200 });
|
|
73
|
+
await waitForConnection(socket);
|
|
74
|
+
|
|
75
|
+
let failedFired = false;
|
|
76
|
+
socket.onReconnectFailed(() => {
|
|
77
|
+
failedFired = true;
|
|
78
|
+
});
|
|
79
|
+
|
|
80
|
+
// Stop server completely so reconnect fails
|
|
81
|
+
await wsServer.stopServer();
|
|
82
|
+
await sleep(3000);
|
|
83
|
+
|
|
84
|
+
expect(failedFired).toBe(true);
|
|
85
|
+
});
|
|
86
|
+
|
|
87
|
+
it("should fire onError callback on connection errors", async () => {
|
|
88
|
+
const { startServer, stopServer, terminateAllClients } = createWebsocketE2EServer();
|
|
89
|
+
const url = await startServer();
|
|
90
|
+
|
|
91
|
+
const socket = new Socket({ url, reconnectTime: 200 });
|
|
92
|
+
await waitForConnection(socket);
|
|
93
|
+
|
|
94
|
+
const errors: Error[] = [];
|
|
95
|
+
socket.onError(({ error }: { error: Error }) => {
|
|
96
|
+
errors.push(error);
|
|
97
|
+
});
|
|
98
|
+
|
|
99
|
+
terminateAllClients();
|
|
100
|
+
await sleep(500);
|
|
101
|
+
|
|
102
|
+
expect(errors.length).toBeGreaterThanOrEqual(1);
|
|
103
|
+
|
|
104
|
+
await socket.disconnect();
|
|
105
|
+
await stopServer();
|
|
106
|
+
});
|
|
107
|
+
|
|
108
|
+
it("should intercept incoming messages with onMessage", async () => {
|
|
109
|
+
const { startServer, stopServer, sendToAll } = createWebsocketE2EServer();
|
|
110
|
+
const url = await startServer();
|
|
111
|
+
|
|
112
|
+
const socket = new Socket({ url, adapterOptions: { autoConnect: false } });
|
|
113
|
+
socket.onMessage(({ event }: any) => {
|
|
114
|
+
return {
|
|
115
|
+
...event,
|
|
116
|
+
data: { ...event.data, intercepted: true },
|
|
117
|
+
extra: event.extra,
|
|
118
|
+
};
|
|
119
|
+
});
|
|
120
|
+
|
|
121
|
+
await socket.connect();
|
|
122
|
+
await waitForConnection(socket);
|
|
123
|
+
|
|
124
|
+
const listener = socket.createListener<{ value: number; intercepted?: boolean }>()({ topic: "intercept-test" });
|
|
125
|
+
|
|
126
|
+
const received: any[] = [];
|
|
127
|
+
listener.listen(({ data }) => received.push(data));
|
|
128
|
+
|
|
129
|
+
await sleep(50);
|
|
130
|
+
sendToAll("intercept-test", { value: 42 });
|
|
131
|
+
await sleep(200);
|
|
132
|
+
|
|
133
|
+
expect(received.length).toBeGreaterThanOrEqual(1);
|
|
134
|
+
|
|
135
|
+
await socket.disconnect();
|
|
136
|
+
await stopServer();
|
|
137
|
+
});
|
|
138
|
+
|
|
139
|
+
it("should intercept outgoing messages with onSend", async () => {
|
|
140
|
+
const { startServer, stopServer, waitForMessage } = createWebsocketE2EServer();
|
|
141
|
+
const url = await startServer();
|
|
142
|
+
|
|
143
|
+
const socket = new Socket({ url, adapterOptions: { autoConnect: false } });
|
|
144
|
+
socket.onSend(({ emitter }) => {
|
|
145
|
+
return emitter.clone({ payload: { ...(emitter.payload as any), modified: true } });
|
|
146
|
+
});
|
|
147
|
+
|
|
148
|
+
await socket.connect();
|
|
149
|
+
await waitForConnection(socket);
|
|
150
|
+
|
|
151
|
+
const emitter = socket.createEmitter<{ value: number }>()({ topic: "send-intercept" });
|
|
152
|
+
|
|
153
|
+
const messagePromise = waitForMessage();
|
|
154
|
+
await emitter.setPayload({ value: 10 }).emit();
|
|
155
|
+
const received = await messagePromise;
|
|
156
|
+
|
|
157
|
+
expect(received.data).toMatchObject({ value: 10, modified: true });
|
|
158
|
+
|
|
159
|
+
await socket.disconnect();
|
|
160
|
+
await stopServer();
|
|
161
|
+
});
|
|
162
|
+
|
|
163
|
+
it("should emit events accessible via socket.events bus", async () => {
|
|
164
|
+
const { startServer, stopServer, sendToAll } = createWebsocketE2EServer();
|
|
165
|
+
const url = await startServer();
|
|
166
|
+
|
|
167
|
+
const socket = new Socket({ url, adapterOptions: { autoConnect: false } });
|
|
168
|
+
|
|
169
|
+
const connectedEvents: any[] = [];
|
|
170
|
+
const disconnectedEvents: any[] = [];
|
|
171
|
+
const listenerEvents: any[] = [];
|
|
172
|
+
|
|
173
|
+
socket.events.onConnected(() => connectedEvents.push(true));
|
|
174
|
+
socket.events.onDisconnected(() => disconnectedEvents.push(true));
|
|
175
|
+
socket.events.onListenerEvent(({ topic, data }: any) => listenerEvents.push({ topic, data }));
|
|
176
|
+
|
|
177
|
+
await socket.connect();
|
|
178
|
+
await waitForConnection(socket);
|
|
179
|
+
expect(connectedEvents).toHaveLength(1);
|
|
180
|
+
|
|
181
|
+
const listener = socket.createListener<{ x: number }>()({ topic: "event-bus" });
|
|
182
|
+
listener.listen(() => {});
|
|
183
|
+
|
|
184
|
+
await sleep(50);
|
|
185
|
+
sendToAll("event-bus", { x: 1 });
|
|
186
|
+
await sleep(200);
|
|
187
|
+
|
|
188
|
+
expect(listenerEvents.length).toBeGreaterThanOrEqual(1);
|
|
189
|
+
expect(listenerEvents[0]).toMatchObject({ topic: "event-bus", data: { x: 1 } });
|
|
190
|
+
|
|
191
|
+
await socket.disconnect();
|
|
192
|
+
await sleep(100);
|
|
193
|
+
|
|
194
|
+
expect(disconnectedEvents).toHaveLength(1);
|
|
195
|
+
|
|
196
|
+
await stopServer();
|
|
197
|
+
});
|
|
198
|
+
|
|
199
|
+
it("should support chaining multiple callbacks", async () => {
|
|
200
|
+
const { startServer, stopServer } = createWebsocketE2EServer();
|
|
201
|
+
const url = await startServer();
|
|
202
|
+
|
|
203
|
+
const calls: string[] = [];
|
|
204
|
+
|
|
205
|
+
const socket = new Socket({ url, adapterOptions: { autoConnect: false } });
|
|
206
|
+
socket
|
|
207
|
+
.onConnected(() => calls.push("connected-1"))
|
|
208
|
+
.onConnected(() => calls.push("connected-2"))
|
|
209
|
+
.onDisconnected(() => calls.push("disconnected-1"))
|
|
210
|
+
.onDisconnected(() => calls.push("disconnected-2"));
|
|
211
|
+
|
|
212
|
+
await socket.connect();
|
|
213
|
+
await waitForConnection(socket);
|
|
214
|
+
|
|
215
|
+
expect(calls).toStrictEqual(["connected-1", "connected-2"]);
|
|
216
|
+
|
|
217
|
+
await socket.disconnect();
|
|
218
|
+
await sleep(100);
|
|
219
|
+
|
|
220
|
+
expect(calls).toStrictEqual(["connected-1", "connected-2", "disconnected-1", "disconnected-2"]);
|
|
221
|
+
|
|
222
|
+
await stopServer();
|
|
223
|
+
});
|
|
224
|
+
});
|
|
@@ -0,0 +1,162 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* @vitest-environment node
|
|
3
|
+
*/
|
|
4
|
+
import { Socket } from "@hyper-fetch/sockets";
|
|
5
|
+
import { createWebsocketE2EServer, sleep, waitForConnection } from "@hyper-fetch/testing";
|
|
6
|
+
|
|
7
|
+
const { startServer, stopServer, waitForClient } = createWebsocketE2EServer();
|
|
8
|
+
|
|
9
|
+
describe("E2E [ WebSocket Connection ]", () => {
|
|
10
|
+
let url: string;
|
|
11
|
+
|
|
12
|
+
beforeAll(async () => {
|
|
13
|
+
url = await startServer();
|
|
14
|
+
});
|
|
15
|
+
|
|
16
|
+
afterAll(async () => {
|
|
17
|
+
await stopServer();
|
|
18
|
+
});
|
|
19
|
+
|
|
20
|
+
it("should connect to a real WebSocket server", async () => {
|
|
21
|
+
const socket = new Socket({ url, adapterOptions: { autoConnect: false } });
|
|
22
|
+
|
|
23
|
+
expect(socket.adapter.connected).toBe(false);
|
|
24
|
+
|
|
25
|
+
await socket.connect();
|
|
26
|
+
await waitForConnection(socket);
|
|
27
|
+
|
|
28
|
+
expect(socket.adapter.connected).toBe(true);
|
|
29
|
+
await socket.disconnect();
|
|
30
|
+
});
|
|
31
|
+
|
|
32
|
+
it("should fire connecting and connected events in order", async () => {
|
|
33
|
+
const events: string[] = [];
|
|
34
|
+
|
|
35
|
+
const socket = new Socket({ url, adapterOptions: { autoConnect: false } });
|
|
36
|
+
|
|
37
|
+
socket.events.onConnecting(({ connecting }) => {
|
|
38
|
+
if (connecting) events.push("connecting");
|
|
39
|
+
});
|
|
40
|
+
socket.events.onConnected(() => {
|
|
41
|
+
events.push("connected");
|
|
42
|
+
});
|
|
43
|
+
|
|
44
|
+
await socket.connect();
|
|
45
|
+
await waitForConnection(socket);
|
|
46
|
+
|
|
47
|
+
expect(events).toStrictEqual(["connecting", "connected"]);
|
|
48
|
+
await socket.disconnect();
|
|
49
|
+
});
|
|
50
|
+
|
|
51
|
+
it("should not connect when autoConnect is false", async () => {
|
|
52
|
+
const socket = new Socket({ url, adapterOptions: { autoConnect: false } });
|
|
53
|
+
await sleep(200);
|
|
54
|
+
|
|
55
|
+
expect(socket.adapter.connected).toBe(false);
|
|
56
|
+
expect(socket.adapter.connecting).toBe(false);
|
|
57
|
+
|
|
58
|
+
await socket.connect();
|
|
59
|
+
await waitForConnection(socket);
|
|
60
|
+
|
|
61
|
+
expect(socket.adapter.connected).toBe(true);
|
|
62
|
+
await socket.disconnect();
|
|
63
|
+
});
|
|
64
|
+
|
|
65
|
+
it("should auto-connect by default", async () => {
|
|
66
|
+
const socket = new Socket({ url });
|
|
67
|
+
|
|
68
|
+
await waitForConnection(socket);
|
|
69
|
+
|
|
70
|
+
expect(socket.adapter.connected).toBe(true);
|
|
71
|
+
await socket.disconnect();
|
|
72
|
+
});
|
|
73
|
+
|
|
74
|
+
it("should pass query params in the URL", async () => {
|
|
75
|
+
const clientPromise = waitForClient();
|
|
76
|
+
const socket = new Socket({
|
|
77
|
+
url,
|
|
78
|
+
queryParams: { token: "abc123", mode: "test" },
|
|
79
|
+
});
|
|
80
|
+
|
|
81
|
+
const serverClient = await clientPromise;
|
|
82
|
+
await waitForConnection(socket);
|
|
83
|
+
|
|
84
|
+
// The ws server client doesn't directly expose URL, but connection succeeded with params
|
|
85
|
+
expect(socket.adapter.connected).toBe(true);
|
|
86
|
+
|
|
87
|
+
// Verify by checking the server received the connection
|
|
88
|
+
expect(serverClient).toBeDefined();
|
|
89
|
+
await socket.disconnect();
|
|
90
|
+
});
|
|
91
|
+
|
|
92
|
+
it("should disconnect manually", async () => {
|
|
93
|
+
const socket = new Socket({ url });
|
|
94
|
+
await waitForConnection(socket);
|
|
95
|
+
|
|
96
|
+
expect(socket.adapter.connected).toBe(true);
|
|
97
|
+
|
|
98
|
+
let disconnected = false;
|
|
99
|
+
socket.events.onDisconnected(() => {
|
|
100
|
+
disconnected = true;
|
|
101
|
+
});
|
|
102
|
+
|
|
103
|
+
await socket.disconnect();
|
|
104
|
+
await sleep(100);
|
|
105
|
+
|
|
106
|
+
expect(socket.adapter.connected).toBe(false);
|
|
107
|
+
expect(disconnected).toBe(true);
|
|
108
|
+
});
|
|
109
|
+
|
|
110
|
+
it("should not auto-reconnect on clean close (code 1000)", async () => {
|
|
111
|
+
const socket = new Socket({ url, reconnectTime: 100 });
|
|
112
|
+
await waitForConnection(socket);
|
|
113
|
+
|
|
114
|
+
let reconnectAttempted = false;
|
|
115
|
+
socket.onReconnect(() => {
|
|
116
|
+
reconnectAttempted = true;
|
|
117
|
+
});
|
|
118
|
+
|
|
119
|
+
await socket.disconnect();
|
|
120
|
+
await sleep(300);
|
|
121
|
+
|
|
122
|
+
expect(reconnectAttempted).toBe(false);
|
|
123
|
+
});
|
|
124
|
+
|
|
125
|
+
it("should support multiple sockets to the same server", async () => {
|
|
126
|
+
const socket1 = new Socket({ url });
|
|
127
|
+
const socket2 = new Socket({ url });
|
|
128
|
+
|
|
129
|
+
await waitForConnection(socket1);
|
|
130
|
+
await waitForConnection(socket2);
|
|
131
|
+
|
|
132
|
+
expect(socket1.adapter.connected).toBe(true);
|
|
133
|
+
expect(socket2.adapter.connected).toBe(true);
|
|
134
|
+
|
|
135
|
+
await socket1.disconnect();
|
|
136
|
+
|
|
137
|
+
expect(socket1.adapter.connected).toBe(false);
|
|
138
|
+
expect(socket2.adapter.connected).toBe(true);
|
|
139
|
+
|
|
140
|
+
await socket2.disconnect();
|
|
141
|
+
});
|
|
142
|
+
|
|
143
|
+
it("should fire disconnected event on server-initiated clean close", async () => {
|
|
144
|
+
const { startServer: startLocal, stopServer: stopLocal, closeAllClients } = createWebsocketE2EServer();
|
|
145
|
+
const localUrl = await startLocal();
|
|
146
|
+
|
|
147
|
+
const socket = new Socket({ url: localUrl, reconnectTime: 100 });
|
|
148
|
+
await waitForConnection(socket);
|
|
149
|
+
|
|
150
|
+
let disconnectedFired = false;
|
|
151
|
+
socket.events.onDisconnected(() => {
|
|
152
|
+
disconnectedFired = true;
|
|
153
|
+
});
|
|
154
|
+
|
|
155
|
+
closeAllClients(1000, "normal close");
|
|
156
|
+
await sleep(200);
|
|
157
|
+
|
|
158
|
+
expect(disconnectedFired).toBe(true);
|
|
159
|
+
|
|
160
|
+
await stopLocal();
|
|
161
|
+
});
|
|
162
|
+
});
|
|
@@ -0,0 +1,232 @@
|
|
|
1
|
+
/* eslint-disable no-await-in-loop */
|
|
2
|
+
/**
|
|
3
|
+
* @vitest-environment node
|
|
4
|
+
*/
|
|
5
|
+
import { Socket } from "@hyper-fetch/sockets";
|
|
6
|
+
import { createWebsocketE2EServer, sleep, waitForConnection } from "@hyper-fetch/testing";
|
|
7
|
+
|
|
8
|
+
describe("E2E [ WebSocket Edge Cases ]", () => {
|
|
9
|
+
it("should handle rapid connect/disconnect cycles without crashing", async () => {
|
|
10
|
+
const { startServer, stopServer } = createWebsocketE2EServer();
|
|
11
|
+
const url = await startServer();
|
|
12
|
+
|
|
13
|
+
const socket = new Socket({ url, adapterOptions: { autoConnect: false }, reconnectTime: 100 });
|
|
14
|
+
|
|
15
|
+
for (let i = 0; i < 5; i += 1) {
|
|
16
|
+
await socket.connect();
|
|
17
|
+
await sleep(50);
|
|
18
|
+
await socket.disconnect();
|
|
19
|
+
await sleep(50);
|
|
20
|
+
}
|
|
21
|
+
|
|
22
|
+
// Should be in a clean disconnected state
|
|
23
|
+
expect(socket.adapter.connected).toBe(false);
|
|
24
|
+
expect(socket.adapter.connecting).toBe(false);
|
|
25
|
+
|
|
26
|
+
// Should still be able to connect
|
|
27
|
+
await socket.connect();
|
|
28
|
+
await waitForConnection(socket, 3000);
|
|
29
|
+
expect(socket.adapter.connected).toBe(true);
|
|
30
|
+
|
|
31
|
+
await socket.disconnect();
|
|
32
|
+
await stopServer();
|
|
33
|
+
});
|
|
34
|
+
|
|
35
|
+
it("should survive malformed JSON from server", async () => {
|
|
36
|
+
const { startServer, stopServer, sendRawToAll } = createWebsocketE2EServer();
|
|
37
|
+
const url = await startServer();
|
|
38
|
+
|
|
39
|
+
const socket = new Socket({ url });
|
|
40
|
+
await waitForConnection(socket);
|
|
41
|
+
|
|
42
|
+
const errors: any[] = [];
|
|
43
|
+
socket.onError(({ error }: any) => errors.push(error));
|
|
44
|
+
|
|
45
|
+
// Send malformed JSON
|
|
46
|
+
sendRawToAll("this is not json{{{");
|
|
47
|
+
await sleep(200);
|
|
48
|
+
|
|
49
|
+
// Connection should still be alive
|
|
50
|
+
expect(socket.adapter.connected).toBe(true);
|
|
51
|
+
|
|
52
|
+
await socket.disconnect();
|
|
53
|
+
await stopServer();
|
|
54
|
+
});
|
|
55
|
+
|
|
56
|
+
it("should handle multiple concurrent sockets independently", async () => {
|
|
57
|
+
const { startServer, stopServer, sendToAll } = createWebsocketE2EServer();
|
|
58
|
+
const url = await startServer();
|
|
59
|
+
|
|
60
|
+
const socket1 = new Socket({ url });
|
|
61
|
+
const socket2 = new Socket({ url });
|
|
62
|
+
const socket3 = new Socket({ url });
|
|
63
|
+
|
|
64
|
+
await waitForConnection(socket1);
|
|
65
|
+
await waitForConnection(socket2);
|
|
66
|
+
await waitForConnection(socket3);
|
|
67
|
+
|
|
68
|
+
const received1: any[] = [];
|
|
69
|
+
const received2: any[] = [];
|
|
70
|
+
const received3: any[] = [];
|
|
71
|
+
|
|
72
|
+
socket1
|
|
73
|
+
.createListener<{ v: number }>()({ topic: "multi" })
|
|
74
|
+
.listen(({ data }) => received1.push(data));
|
|
75
|
+
socket2
|
|
76
|
+
.createListener<{ v: number }>()({ topic: "multi" })
|
|
77
|
+
.listen(({ data }) => received2.push(data));
|
|
78
|
+
socket3
|
|
79
|
+
.createListener<{ v: number }>()({ topic: "multi" })
|
|
80
|
+
.listen(({ data }) => received3.push(data));
|
|
81
|
+
|
|
82
|
+
await sleep(50);
|
|
83
|
+
sendToAll("multi", { v: 1 });
|
|
84
|
+
await sleep(200);
|
|
85
|
+
|
|
86
|
+
expect(received1).toStrictEqual([{ v: 1 }]);
|
|
87
|
+
expect(received2).toStrictEqual([{ v: 1 }]);
|
|
88
|
+
expect(received3).toStrictEqual([{ v: 1 }]);
|
|
89
|
+
|
|
90
|
+
// Disconnect one, others should still work
|
|
91
|
+
await socket2.disconnect();
|
|
92
|
+
|
|
93
|
+
sendToAll("multi", { v: 2 });
|
|
94
|
+
await sleep(200);
|
|
95
|
+
|
|
96
|
+
expect(received1).toStrictEqual([{ v: 1 }, { v: 2 }]);
|
|
97
|
+
expect(received2).toStrictEqual([{ v: 1 }]); // No new message
|
|
98
|
+
expect(received3).toStrictEqual([{ v: 1 }, { v: 2 }]);
|
|
99
|
+
|
|
100
|
+
await socket1.disconnect();
|
|
101
|
+
await socket3.disconnect();
|
|
102
|
+
await stopServer();
|
|
103
|
+
});
|
|
104
|
+
|
|
105
|
+
it("should handle disconnect during reconnection gracefully", async () => {
|
|
106
|
+
const { startServer, stopServer } = createWebsocketE2EServer();
|
|
107
|
+
const url = await startServer();
|
|
108
|
+
|
|
109
|
+
const socket = new Socket({ url, reconnectTime: 500 });
|
|
110
|
+
await waitForConnection(socket);
|
|
111
|
+
|
|
112
|
+
// Stop the server so reconnect cannot succeed
|
|
113
|
+
await stopServer();
|
|
114
|
+
await sleep(100);
|
|
115
|
+
|
|
116
|
+
// Disconnect while reconnection is pending
|
|
117
|
+
await socket.disconnect();
|
|
118
|
+
await sleep(800);
|
|
119
|
+
|
|
120
|
+
expect(socket.adapter.connected).toBe(false);
|
|
121
|
+
});
|
|
122
|
+
|
|
123
|
+
it("should handle server sending empty message", async () => {
|
|
124
|
+
const { startServer, stopServer, sendRawToAll } = createWebsocketE2EServer();
|
|
125
|
+
const url = await startServer();
|
|
126
|
+
|
|
127
|
+
const socket = new Socket({ url });
|
|
128
|
+
await waitForConnection(socket);
|
|
129
|
+
|
|
130
|
+
sendRawToAll("");
|
|
131
|
+
await sleep(200);
|
|
132
|
+
|
|
133
|
+
// Should not crash
|
|
134
|
+
expect(socket.adapter.connected).toBe(true);
|
|
135
|
+
|
|
136
|
+
await socket.disconnect();
|
|
137
|
+
await stopServer();
|
|
138
|
+
});
|
|
139
|
+
|
|
140
|
+
it("should handle many listeners without issues", async () => {
|
|
141
|
+
const { startServer, stopServer, sendToAll } = createWebsocketE2EServer();
|
|
142
|
+
const url = await startServer();
|
|
143
|
+
|
|
144
|
+
const socket = new Socket({ url });
|
|
145
|
+
await waitForConnection(socket);
|
|
146
|
+
|
|
147
|
+
const listenerCount = 100;
|
|
148
|
+
const receivedCounts = new Array(listenerCount).fill(0);
|
|
149
|
+
|
|
150
|
+
for (let i = 0; i < listenerCount; i += 1) {
|
|
151
|
+
const idx = i;
|
|
152
|
+
socket
|
|
153
|
+
.createListener<{ v: number }>()({ topic: "many-listeners" })
|
|
154
|
+
.listen(() => {
|
|
155
|
+
receivedCounts[idx] += 1;
|
|
156
|
+
});
|
|
157
|
+
}
|
|
158
|
+
|
|
159
|
+
await sleep(50);
|
|
160
|
+
sendToAll("many-listeners", { v: 1 });
|
|
161
|
+
await sleep(300);
|
|
162
|
+
|
|
163
|
+
// All listeners should have received the message
|
|
164
|
+
receivedCounts.forEach((count) => {
|
|
165
|
+
expect(count).toBe(1);
|
|
166
|
+
});
|
|
167
|
+
|
|
168
|
+
await socket.disconnect();
|
|
169
|
+
await stopServer();
|
|
170
|
+
});
|
|
171
|
+
|
|
172
|
+
it("should handle connecting to an unreachable server", async () => {
|
|
173
|
+
const socket = new Socket({
|
|
174
|
+
url: "ws://127.0.0.1:19999",
|
|
175
|
+
reconnect: 1,
|
|
176
|
+
reconnectTime: 100,
|
|
177
|
+
adapterOptions: { autoConnect: false },
|
|
178
|
+
});
|
|
179
|
+
|
|
180
|
+
let errorFired = false;
|
|
181
|
+
|
|
182
|
+
socket.onError(() => {
|
|
183
|
+
errorFired = true;
|
|
184
|
+
});
|
|
185
|
+
|
|
186
|
+
await socket.connect();
|
|
187
|
+
await sleep(1000);
|
|
188
|
+
|
|
189
|
+
expect(errorFired).toBe(true);
|
|
190
|
+
});
|
|
191
|
+
|
|
192
|
+
it("should handle bidirectional communication", async () => {
|
|
193
|
+
const { startServer, stopServer, onMessage } = createWebsocketE2EServer();
|
|
194
|
+
const url = await startServer();
|
|
195
|
+
|
|
196
|
+
const socket = new Socket({ url });
|
|
197
|
+
await waitForConnection(socket);
|
|
198
|
+
|
|
199
|
+
// Set up echo behavior on server
|
|
200
|
+
const serverReceived: any[] = [];
|
|
201
|
+
onMessage((msg, ws) => {
|
|
202
|
+
serverReceived.push(msg);
|
|
203
|
+
if (msg.topic === "echo-request") {
|
|
204
|
+
ws.send(JSON.stringify({ topic: "echo-response", data: msg.data }));
|
|
205
|
+
}
|
|
206
|
+
});
|
|
207
|
+
|
|
208
|
+
// Set up client listener for response
|
|
209
|
+
const clientReceived: any[] = [];
|
|
210
|
+
socket
|
|
211
|
+
.createListener<{ message: string }>()({ topic: "echo-response" })
|
|
212
|
+
.listen(({ data }) => {
|
|
213
|
+
clientReceived.push(data);
|
|
214
|
+
});
|
|
215
|
+
|
|
216
|
+
await sleep(50);
|
|
217
|
+
|
|
218
|
+
// Client sends, server echoes back
|
|
219
|
+
const emitter = socket.createEmitter<{ message: string }>()({ topic: "echo-request" });
|
|
220
|
+
await emitter.setPayload({ message: "ping" }).emit();
|
|
221
|
+
|
|
222
|
+
await sleep(300);
|
|
223
|
+
|
|
224
|
+
expect(serverReceived).toHaveLength(1);
|
|
225
|
+
expect(serverReceived[0].data).toStrictEqual({ message: "ping" });
|
|
226
|
+
expect(clientReceived).toHaveLength(1);
|
|
227
|
+
expect(clientReceived[0]).toStrictEqual({ message: "ping" });
|
|
228
|
+
|
|
229
|
+
await socket.disconnect();
|
|
230
|
+
await stopServer();
|
|
231
|
+
});
|
|
232
|
+
});
|