@hyper-fetch/sockets 8.0.0 → 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,160 @@
|
|
|
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 wsServer = createWebsocketE2EServer();
|
|
8
|
+
|
|
9
|
+
describe("E2E [ WebSocket Emitters ]", () => {
|
|
10
|
+
let url: string;
|
|
11
|
+
|
|
12
|
+
beforeAll(async () => {
|
|
13
|
+
url = await wsServer.startServer();
|
|
14
|
+
});
|
|
15
|
+
|
|
16
|
+
afterAll(async () => {
|
|
17
|
+
await wsServer.stopServer();
|
|
18
|
+
});
|
|
19
|
+
|
|
20
|
+
it("should send a message to the server", async () => {
|
|
21
|
+
const socket = new Socket({ url });
|
|
22
|
+
await waitForConnection(socket);
|
|
23
|
+
|
|
24
|
+
const emitter = socket.createEmitter<{ greeting: string }>()({ topic: "hello" });
|
|
25
|
+
|
|
26
|
+
const messagePromise = wsServer.waitForMessage();
|
|
27
|
+
await emitter.setPayload({ greeting: "world" }).emit();
|
|
28
|
+
const received = await messagePromise;
|
|
29
|
+
|
|
30
|
+
expect(received).toStrictEqual({ topic: "hello", data: { greeting: "world" } });
|
|
31
|
+
|
|
32
|
+
await socket.disconnect();
|
|
33
|
+
});
|
|
34
|
+
|
|
35
|
+
it("should send payload correctly", async () => {
|
|
36
|
+
const socket = new Socket({ url });
|
|
37
|
+
await waitForConnection(socket);
|
|
38
|
+
|
|
39
|
+
const emitter = socket.createEmitter<{ items: number[] }>()({ topic: "data" });
|
|
40
|
+
|
|
41
|
+
const messagePromise = wsServer.waitForMessage();
|
|
42
|
+
await emitter.setPayload({ items: [1, 2, 3] }).emit();
|
|
43
|
+
const received = await messagePromise;
|
|
44
|
+
|
|
45
|
+
expect(received.topic).toBe("data");
|
|
46
|
+
expect(received.data).toStrictEqual({ items: [1, 2, 3] });
|
|
47
|
+
|
|
48
|
+
await socket.disconnect();
|
|
49
|
+
});
|
|
50
|
+
|
|
51
|
+
it("should resolve topic params before sending", async () => {
|
|
52
|
+
const socket = new Socket({ url });
|
|
53
|
+
await waitForConnection(socket);
|
|
54
|
+
|
|
55
|
+
const emitter = socket.createEmitter<{ action: string }>()({ topic: "room/:roomId/action" });
|
|
56
|
+
|
|
57
|
+
const messagePromise = wsServer.waitForMessage();
|
|
58
|
+
await emitter.setParams({ roomId: "main" }).setPayload({ action: "join" }).emit();
|
|
59
|
+
const received = await messagePromise;
|
|
60
|
+
|
|
61
|
+
expect(received.topic).toBe("room/main/action");
|
|
62
|
+
expect(received.data).toStrictEqual({ action: "join" });
|
|
63
|
+
|
|
64
|
+
await socket.disconnect();
|
|
65
|
+
});
|
|
66
|
+
|
|
67
|
+
it("should block emit when disconnected", async () => {
|
|
68
|
+
const socket = new Socket({ url, adapterOptions: { autoConnect: false } });
|
|
69
|
+
|
|
70
|
+
const emitter = socket.createEmitter<{ v: number }>()({ topic: "blocked" });
|
|
71
|
+
|
|
72
|
+
socket.events.onError(() => {
|
|
73
|
+
// expected — emit while disconnected
|
|
74
|
+
});
|
|
75
|
+
|
|
76
|
+
// Should not throw but should not send
|
|
77
|
+
await emitter.setPayload({ v: 1 }).emit();
|
|
78
|
+
await sleep(100);
|
|
79
|
+
|
|
80
|
+
// The emit was blocked silently (onEmit returns null)
|
|
81
|
+
expect(socket.adapter.connected).toBe(false);
|
|
82
|
+
});
|
|
83
|
+
|
|
84
|
+
it("should apply payload mapper before sending", async () => {
|
|
85
|
+
const socket = new Socket({ url });
|
|
86
|
+
await waitForConnection(socket);
|
|
87
|
+
|
|
88
|
+
const emitter = socket
|
|
89
|
+
.createEmitter<{ raw: string }>()({ topic: "mapped" })
|
|
90
|
+
.setPayloadMapper((payload: any) => ({
|
|
91
|
+
raw: payload.raw.toUpperCase(),
|
|
92
|
+
transformed: true,
|
|
93
|
+
}));
|
|
94
|
+
|
|
95
|
+
const messagePromise = wsServer.waitForMessage();
|
|
96
|
+
await emitter.setPayload({ raw: "hello" }).emit();
|
|
97
|
+
const received = await messagePromise;
|
|
98
|
+
|
|
99
|
+
expect(received.topic).toBe("mapped");
|
|
100
|
+
expect(received.data).toStrictEqual({ raw: "HELLO", transformed: true });
|
|
101
|
+
|
|
102
|
+
await socket.disconnect();
|
|
103
|
+
});
|
|
104
|
+
|
|
105
|
+
it("should emit after reconnection", async () => {
|
|
106
|
+
const localServer = createWebsocketE2EServer();
|
|
107
|
+
const localUrl = await localServer.startServer();
|
|
108
|
+
|
|
109
|
+
const socket = new Socket({ url: localUrl, reconnectTime: 200 });
|
|
110
|
+
await waitForConnection(socket);
|
|
111
|
+
|
|
112
|
+
const emitter = socket.createEmitter<{ v: number }>()({ topic: "after-reconnect" });
|
|
113
|
+
|
|
114
|
+
// Send before disruption
|
|
115
|
+
let messagePromise = localServer.waitForMessage();
|
|
116
|
+
await emitter.setPayload({ v: 1 }).emit();
|
|
117
|
+
const first = await messagePromise;
|
|
118
|
+
expect(first.data).toStrictEqual({ v: 1 });
|
|
119
|
+
|
|
120
|
+
// Cause reconnection
|
|
121
|
+
localServer.terminateAllClients();
|
|
122
|
+
await sleep(600);
|
|
123
|
+
await waitForConnection(socket, 3000);
|
|
124
|
+
|
|
125
|
+
// Send after reconnection
|
|
126
|
+
messagePromise = localServer.waitForMessage();
|
|
127
|
+
await emitter.setPayload({ v: 2 }).emit();
|
|
128
|
+
const second = await messagePromise;
|
|
129
|
+
expect(second.data).toStrictEqual({ v: 2 });
|
|
130
|
+
|
|
131
|
+
await socket.disconnect();
|
|
132
|
+
await localServer.stopServer();
|
|
133
|
+
});
|
|
134
|
+
|
|
135
|
+
it("should send multiple messages sequentially", async () => {
|
|
136
|
+
const socket = new Socket({ url });
|
|
137
|
+
await waitForConnection(socket);
|
|
138
|
+
|
|
139
|
+
const emitter = socket.createEmitter<{ i: number }>()({ topic: "sequential" });
|
|
140
|
+
|
|
141
|
+
const messages: any[] = [];
|
|
142
|
+
wsServer.onMessage((msg) => {
|
|
143
|
+
if (msg.topic === "sequential") messages.push(msg);
|
|
144
|
+
});
|
|
145
|
+
|
|
146
|
+
for (let i = 0; i < 5; i += 1) {
|
|
147
|
+
// eslint-disable-next-line no-await-in-loop
|
|
148
|
+
await emitter.setPayload({ i }).emit();
|
|
149
|
+
}
|
|
150
|
+
|
|
151
|
+
await sleep(300);
|
|
152
|
+
|
|
153
|
+
expect(messages).toHaveLength(5);
|
|
154
|
+
messages.forEach((msg, idx) => {
|
|
155
|
+
expect(msg.data).toStrictEqual({ i: idx });
|
|
156
|
+
});
|
|
157
|
+
|
|
158
|
+
await socket.disconnect();
|
|
159
|
+
});
|
|
160
|
+
});
|
|
@@ -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
|
+
describe("E2E [ WebSocket Heartbeat ]", () => {
|
|
8
|
+
it("should send heartbeat messages at configured interval", async () => {
|
|
9
|
+
const { startServer, stopServer, onMessage } = createWebsocketE2EServer();
|
|
10
|
+
const url = await startServer();
|
|
11
|
+
|
|
12
|
+
const socket = new Socket({
|
|
13
|
+
url,
|
|
14
|
+
adapterOptions: {
|
|
15
|
+
heartbeat: true,
|
|
16
|
+
pingTimeout: 200,
|
|
17
|
+
pongTimeout: 5000,
|
|
18
|
+
},
|
|
19
|
+
});
|
|
20
|
+
|
|
21
|
+
await waitForConnection(socket);
|
|
22
|
+
|
|
23
|
+
const heartbeats: any[] = [];
|
|
24
|
+
onMessage((msg) => {
|
|
25
|
+
if (msg.topic === "heartbeat") heartbeats.push(msg);
|
|
26
|
+
});
|
|
27
|
+
|
|
28
|
+
// Wait for at least one heartbeat
|
|
29
|
+
await sleep(600);
|
|
30
|
+
|
|
31
|
+
expect(heartbeats.length).toBeGreaterThanOrEqual(1);
|
|
32
|
+
expect(heartbeats[0].data).toBe("heartbeat");
|
|
33
|
+
|
|
34
|
+
await socket.disconnect();
|
|
35
|
+
await stopServer();
|
|
36
|
+
});
|
|
37
|
+
|
|
38
|
+
it("should trigger reconnection when pong times out", async () => {
|
|
39
|
+
const { startServer, stopServer } = createWebsocketE2EServer();
|
|
40
|
+
const url = await startServer();
|
|
41
|
+
|
|
42
|
+
const socket = new Socket({
|
|
43
|
+
url,
|
|
44
|
+
reconnectTime: 200,
|
|
45
|
+
adapterOptions: {
|
|
46
|
+
heartbeat: true,
|
|
47
|
+
pingTimeout: 100,
|
|
48
|
+
pongTimeout: 100,
|
|
49
|
+
},
|
|
50
|
+
});
|
|
51
|
+
|
|
52
|
+
await waitForConnection(socket);
|
|
53
|
+
|
|
54
|
+
let reconnectFired = false;
|
|
55
|
+
socket.onReconnect(() => {
|
|
56
|
+
reconnectFired = true;
|
|
57
|
+
});
|
|
58
|
+
|
|
59
|
+
// Server doesn't respond to heartbeat, so pong times out -> close -> reconnect
|
|
60
|
+
await sleep(800);
|
|
61
|
+
|
|
62
|
+
expect(reconnectFired).toBe(true);
|
|
63
|
+
|
|
64
|
+
await socket.disconnect();
|
|
65
|
+
await stopServer();
|
|
66
|
+
});
|
|
67
|
+
|
|
68
|
+
it("should reset heartbeat timer on incoming messages", async () => {
|
|
69
|
+
const { startServer, stopServer, sendToAll, onMessage } = createWebsocketE2EServer();
|
|
70
|
+
const url = await startServer();
|
|
71
|
+
|
|
72
|
+
const socket = new Socket({
|
|
73
|
+
url,
|
|
74
|
+
adapterOptions: {
|
|
75
|
+
heartbeat: true,
|
|
76
|
+
pingTimeout: 300,
|
|
77
|
+
pongTimeout: 5000,
|
|
78
|
+
},
|
|
79
|
+
});
|
|
80
|
+
|
|
81
|
+
await waitForConnection(socket);
|
|
82
|
+
|
|
83
|
+
const heartbeats: any[] = [];
|
|
84
|
+
onMessage((msg) => {
|
|
85
|
+
if (msg.topic === "heartbeat") heartbeats.push(msg);
|
|
86
|
+
});
|
|
87
|
+
|
|
88
|
+
// Send activity messages to keep resetting the heartbeat timer
|
|
89
|
+
for (let i = 0; i < 3; i += 1) {
|
|
90
|
+
// eslint-disable-next-line no-await-in-loop
|
|
91
|
+
await sleep(150);
|
|
92
|
+
sendToAll("activity", { i });
|
|
93
|
+
}
|
|
94
|
+
|
|
95
|
+
// The heartbeat timer resets on each message, so fewer heartbeats should have been sent
|
|
96
|
+
const heartbeatsBefore = heartbeats.length;
|
|
97
|
+
|
|
98
|
+
// Now wait without activity for heartbeat to fire
|
|
99
|
+
await sleep(600);
|
|
100
|
+
|
|
101
|
+
expect(heartbeats.length).toBeGreaterThan(heartbeatsBefore);
|
|
102
|
+
|
|
103
|
+
await socket.disconnect();
|
|
104
|
+
await stopServer();
|
|
105
|
+
});
|
|
106
|
+
|
|
107
|
+
it("should not send heartbeats when heartbeat is disabled", async () => {
|
|
108
|
+
const { startServer, stopServer, onMessage } = createWebsocketE2EServer();
|
|
109
|
+
const url = await startServer();
|
|
110
|
+
|
|
111
|
+
const socket = new Socket({
|
|
112
|
+
url,
|
|
113
|
+
adapterOptions: {
|
|
114
|
+
heartbeat: false,
|
|
115
|
+
},
|
|
116
|
+
});
|
|
117
|
+
|
|
118
|
+
await waitForConnection(socket);
|
|
119
|
+
|
|
120
|
+
const heartbeats: any[] = [];
|
|
121
|
+
onMessage((msg) => {
|
|
122
|
+
if (msg.topic === "heartbeat") heartbeats.push(msg);
|
|
123
|
+
});
|
|
124
|
+
|
|
125
|
+
await sleep(600);
|
|
126
|
+
|
|
127
|
+
expect(heartbeats).toHaveLength(0);
|
|
128
|
+
|
|
129
|
+
await socket.disconnect();
|
|
130
|
+
await stopServer();
|
|
131
|
+
});
|
|
132
|
+
|
|
133
|
+
it("should use custom heartbeat message", async () => {
|
|
134
|
+
const { startServer, stopServer, onMessage } = createWebsocketE2EServer();
|
|
135
|
+
const url = await startServer();
|
|
136
|
+
|
|
137
|
+
const socket = new Socket({
|
|
138
|
+
url,
|
|
139
|
+
adapterOptions: {
|
|
140
|
+
heartbeat: true,
|
|
141
|
+
pingTimeout: 150,
|
|
142
|
+
pongTimeout: 5000,
|
|
143
|
+
heartbeatMessage: "ping",
|
|
144
|
+
},
|
|
145
|
+
});
|
|
146
|
+
|
|
147
|
+
await waitForConnection(socket);
|
|
148
|
+
|
|
149
|
+
const heartbeats: any[] = [];
|
|
150
|
+
onMessage((msg) => {
|
|
151
|
+
if (msg.topic === "heartbeat") heartbeats.push(msg);
|
|
152
|
+
});
|
|
153
|
+
|
|
154
|
+
await sleep(500);
|
|
155
|
+
|
|
156
|
+
expect(heartbeats.length).toBeGreaterThanOrEqual(1);
|
|
157
|
+
expect(heartbeats[0].data).toBe("ping");
|
|
158
|
+
|
|
159
|
+
await socket.disconnect();
|
|
160
|
+
await stopServer();
|
|
161
|
+
});
|
|
162
|
+
});
|
|
@@ -0,0 +1,215 @@
|
|
|
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 wsServer = createWebsocketE2EServer();
|
|
8
|
+
|
|
9
|
+
describe("E2E [ WebSocket Listeners ]", () => {
|
|
10
|
+
let url: string;
|
|
11
|
+
|
|
12
|
+
beforeAll(async () => {
|
|
13
|
+
url = await wsServer.startServer();
|
|
14
|
+
});
|
|
15
|
+
|
|
16
|
+
afterAll(async () => {
|
|
17
|
+
await wsServer.stopServer();
|
|
18
|
+
});
|
|
19
|
+
|
|
20
|
+
it("should receive a message on a matching topic", async () => {
|
|
21
|
+
const socket = new Socket({ url });
|
|
22
|
+
await waitForConnection(socket);
|
|
23
|
+
|
|
24
|
+
const listener = socket.createListener<{ name: string }>()({ topic: "user-update" });
|
|
25
|
+
|
|
26
|
+
const received: { data: { name: string } }[] = [];
|
|
27
|
+
listener.listen(({ data }) => {
|
|
28
|
+
received.push({ data });
|
|
29
|
+
});
|
|
30
|
+
|
|
31
|
+
await sleep(50);
|
|
32
|
+
wsServer.sendToAll("user-update", { name: "John" });
|
|
33
|
+
await sleep(200);
|
|
34
|
+
|
|
35
|
+
expect(received).toHaveLength(1);
|
|
36
|
+
expect(received[0].data).toStrictEqual({ name: "John" });
|
|
37
|
+
|
|
38
|
+
await socket.disconnect();
|
|
39
|
+
});
|
|
40
|
+
|
|
41
|
+
it("should route messages to correct listeners by topic", async () => {
|
|
42
|
+
const socket = new Socket({ url });
|
|
43
|
+
await waitForConnection(socket);
|
|
44
|
+
|
|
45
|
+
const userListener = socket.createListener<{ id: number }>()({ topic: "users" });
|
|
46
|
+
const orderListener = socket.createListener<{ orderId: string }>()({ topic: "orders" });
|
|
47
|
+
|
|
48
|
+
const userMessages: any[] = [];
|
|
49
|
+
const orderMessages: any[] = [];
|
|
50
|
+
|
|
51
|
+
userListener.listen(({ data }) => userMessages.push(data));
|
|
52
|
+
orderListener.listen(({ data }) => orderMessages.push(data));
|
|
53
|
+
|
|
54
|
+
await sleep(50);
|
|
55
|
+
wsServer.sendToAll("users", { id: 1 });
|
|
56
|
+
wsServer.sendToAll("orders", { orderId: "abc" });
|
|
57
|
+
wsServer.sendToAll("users", { id: 2 });
|
|
58
|
+
await sleep(200);
|
|
59
|
+
|
|
60
|
+
expect(userMessages).toStrictEqual([{ id: 1 }, { id: 2 }]);
|
|
61
|
+
expect(orderMessages).toStrictEqual([{ orderId: "abc" }]);
|
|
62
|
+
|
|
63
|
+
await socket.disconnect();
|
|
64
|
+
});
|
|
65
|
+
|
|
66
|
+
it("should deliver messages to multiple listeners on same topic", async () => {
|
|
67
|
+
const socket = new Socket({ url });
|
|
68
|
+
await waitForConnection(socket);
|
|
69
|
+
|
|
70
|
+
const listener1 = socket.createListener<{ v: number }>()({ topic: "shared" });
|
|
71
|
+
const listener2 = socket.createListener<{ v: number }>()({ topic: "shared" });
|
|
72
|
+
|
|
73
|
+
const results1: any[] = [];
|
|
74
|
+
const results2: any[] = [];
|
|
75
|
+
|
|
76
|
+
listener1.listen(({ data }) => results1.push(data));
|
|
77
|
+
listener2.listen(({ data }) => results2.push(data));
|
|
78
|
+
|
|
79
|
+
await sleep(50);
|
|
80
|
+
wsServer.sendToAll("shared", { v: 42 });
|
|
81
|
+
await sleep(200);
|
|
82
|
+
|
|
83
|
+
expect(results1).toStrictEqual([{ v: 42 }]);
|
|
84
|
+
expect(results2).toStrictEqual([{ v: 42 }]);
|
|
85
|
+
|
|
86
|
+
await socket.disconnect();
|
|
87
|
+
});
|
|
88
|
+
|
|
89
|
+
it("should stop receiving after remove listener", async () => {
|
|
90
|
+
const socket = new Socket({ url });
|
|
91
|
+
await waitForConnection(socket);
|
|
92
|
+
|
|
93
|
+
const listener = socket.createListener<{ v: number }>()({ topic: "removable" });
|
|
94
|
+
|
|
95
|
+
const received: any[] = [];
|
|
96
|
+
const remove = listener.listen(({ data }) => received.push(data));
|
|
97
|
+
|
|
98
|
+
await sleep(50);
|
|
99
|
+
wsServer.sendToAll("removable", { v: 1 });
|
|
100
|
+
await sleep(200);
|
|
101
|
+
|
|
102
|
+
expect(received).toHaveLength(1);
|
|
103
|
+
|
|
104
|
+
remove();
|
|
105
|
+
|
|
106
|
+
wsServer.sendToAll("removable", { v: 2 });
|
|
107
|
+
await sleep(200);
|
|
108
|
+
|
|
109
|
+
expect(received).toHaveLength(1);
|
|
110
|
+
|
|
111
|
+
await socket.disconnect();
|
|
112
|
+
});
|
|
113
|
+
|
|
114
|
+
it("should handle listener with params in topic", async () => {
|
|
115
|
+
const socket = new Socket({ url });
|
|
116
|
+
await waitForConnection(socket);
|
|
117
|
+
|
|
118
|
+
const listener = socket.createListener<{ status: string }>()({ topic: "room/:roomId/status" });
|
|
119
|
+
const boundListener = listener.setParams({ roomId: "lobby" });
|
|
120
|
+
|
|
121
|
+
const received: any[] = [];
|
|
122
|
+
boundListener.listen(({ data }) => received.push(data));
|
|
123
|
+
|
|
124
|
+
await sleep(50);
|
|
125
|
+
wsServer.sendToAll("room/lobby/status", { status: "active" });
|
|
126
|
+
await sleep(200);
|
|
127
|
+
|
|
128
|
+
expect(received).toStrictEqual([{ status: "active" }]);
|
|
129
|
+
|
|
130
|
+
await socket.disconnect();
|
|
131
|
+
});
|
|
132
|
+
|
|
133
|
+
it("should continue receiving messages after reconnection", async () => {
|
|
134
|
+
const localServer = createWebsocketE2EServer();
|
|
135
|
+
const localUrl = await localServer.startServer();
|
|
136
|
+
|
|
137
|
+
const socket = new Socket({ url: localUrl, reconnectTime: 200 });
|
|
138
|
+
await waitForConnection(socket);
|
|
139
|
+
|
|
140
|
+
const listener = socket.createListener<{ v: number }>()({ topic: "persist" });
|
|
141
|
+
const received: any[] = [];
|
|
142
|
+
listener.listen(({ data }) => received.push(data));
|
|
143
|
+
|
|
144
|
+
await sleep(50);
|
|
145
|
+
localServer.sendToAll("persist", { v: 1 });
|
|
146
|
+
await sleep(200);
|
|
147
|
+
|
|
148
|
+
expect(received).toStrictEqual([{ v: 1 }]);
|
|
149
|
+
|
|
150
|
+
// Trigger reconnection
|
|
151
|
+
localServer.terminateAllClients();
|
|
152
|
+
await sleep(600);
|
|
153
|
+
await waitForConnection(socket, 3000);
|
|
154
|
+
|
|
155
|
+
// Send after reconnect
|
|
156
|
+
localServer.sendToAll("persist", { v: 2 });
|
|
157
|
+
await sleep(200);
|
|
158
|
+
|
|
159
|
+
expect(received).toStrictEqual([{ v: 1 }, { v: 2 }]);
|
|
160
|
+
|
|
161
|
+
await socket.disconnect();
|
|
162
|
+
await localServer.stopServer();
|
|
163
|
+
});
|
|
164
|
+
|
|
165
|
+
it("should receive rapid messages in order", async () => {
|
|
166
|
+
const socket = new Socket({ url });
|
|
167
|
+
await waitForConnection(socket);
|
|
168
|
+
|
|
169
|
+
const listener = socket.createListener<{ i: number }>()({ topic: "rapid" });
|
|
170
|
+
const received: number[] = [];
|
|
171
|
+
listener.listen(({ data }) => received.push(data.i));
|
|
172
|
+
|
|
173
|
+
await sleep(50);
|
|
174
|
+
|
|
175
|
+
const count = 50;
|
|
176
|
+
for (let i = 0; i < count; i += 1) {
|
|
177
|
+
wsServer.sendToAll("rapid", { i });
|
|
178
|
+
}
|
|
179
|
+
|
|
180
|
+
await sleep(500);
|
|
181
|
+
|
|
182
|
+
expect(received).toHaveLength(count);
|
|
183
|
+
expect(received).toStrictEqual(Array.from({ length: count }, (_, i) => i));
|
|
184
|
+
|
|
185
|
+
await socket.disconnect();
|
|
186
|
+
});
|
|
187
|
+
|
|
188
|
+
it("should handle large payloads", async () => {
|
|
189
|
+
const socket = new Socket({ url });
|
|
190
|
+
await waitForConnection(socket);
|
|
191
|
+
|
|
192
|
+
const listener = socket.createListener<{ items: { id: number; name: string }[] }>()({ topic: "large" });
|
|
193
|
+
|
|
194
|
+
const largeData = {
|
|
195
|
+
items: Array.from({ length: 1000 }, (_, i) => ({
|
|
196
|
+
id: i,
|
|
197
|
+
name: `item-${i}-${"x".repeat(100)}`,
|
|
198
|
+
})),
|
|
199
|
+
};
|
|
200
|
+
|
|
201
|
+
const received: any[] = [];
|
|
202
|
+
listener.listen(({ data }) => received.push(data));
|
|
203
|
+
|
|
204
|
+
await sleep(50);
|
|
205
|
+
wsServer.sendToAll("large", largeData);
|
|
206
|
+
await sleep(500);
|
|
207
|
+
|
|
208
|
+
expect(received).toHaveLength(1);
|
|
209
|
+
expect(received[0].items).toHaveLength(1000);
|
|
210
|
+
expect(received[0].items[0].id).toBe(0);
|
|
211
|
+
expect(received[0].items[999].id).toBe(999);
|
|
212
|
+
|
|
213
|
+
await socket.disconnect();
|
|
214
|
+
});
|
|
215
|
+
});
|