@hyper-fetch/sockets 9.0.3 → 9.2.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.delivery.spec.ts +81 -0
- package/__tests__/features/adapter/adapter.sse.codec.spec.ts +101 -0
- package/__tests__/features/adapter/adapter.websocket.codec.spec.ts +208 -0
- package/__tests__/features/delivery/delivery.batch.spec.ts +203 -0
- package/__tests__/features/delivery/delivery.latest.spec.ts +254 -0
- package/__tests__/features/delivery/delivery.typescript.spec.ts +143 -0
- package/__tests__/features/delivery/delivery.utils.spec.ts +122 -0
- package/__tests__/features/listener/listener.delivery.spec.ts +385 -0
- package/__tests__/features/listener/listener.delivery.sse.spec.ts +55 -0
- package/__tests__/features/sdk/sdk.configuration.spec.ts +60 -0
- package/__tests__/features/sdk/sdk.types.spec.ts +41 -17
- package/__tests__/features/socket/socket.methods.spec.ts +40 -0
- package/dist/adapter-sse/sse-adapter.d.ts.map +1 -1
- package/dist/adapter-sse/sse-adapter.types.d.ts +11 -0
- package/dist/adapter-sse/sse-adapter.types.d.ts.map +1 -1
- package/dist/adapter-websockets/websocket-adapter.d.ts.map +1 -1
- package/dist/adapter-websockets/websocket-adapter.types.d.ts +23 -0
- package/dist/adapter-websockets/websocket-adapter.types.d.ts.map +1 -1
- package/dist/delivery/delivery.batch.d.ts +19 -0
- package/dist/delivery/delivery.batch.d.ts.map +1 -0
- package/dist/delivery/delivery.latest.d.ts +18 -0
- package/dist/delivery/delivery.latest.d.ts.map +1 -0
- package/dist/delivery/delivery.types.d.ts +113 -0
- package/dist/delivery/delivery.types.d.ts.map +1 -0
- package/dist/delivery/delivery.utils.d.ts +50 -0
- package/dist/delivery/delivery.utils.d.ts.map +1 -0
- package/dist/delivery/index.d.ts +5 -0
- package/dist/delivery/index.d.ts.map +1 -0
- package/dist/index.d.ts +1 -0
- package/dist/index.d.ts.map +1 -1
- package/dist/index.mjs +261 -20
- package/dist/index.mjs.map +1 -1
- package/dist/listener/listener.d.ts +22 -7
- package/dist/listener/listener.d.ts.map +1 -1
- package/dist/listener/listener.types.d.ts +29 -9
- package/dist/listener/listener.types.d.ts.map +1 -1
- package/dist/sdk/sdk.d.ts +6 -2
- package/dist/sdk/sdk.d.ts.map +1 -1
- package/dist/socket/socket.d.ts +8 -1
- package/dist/socket/socket.d.ts.map +1 -1
- package/dist/types/extract.types.d.ts +10 -4
- package/dist/types/extract.types.d.ts.map +1 -1
- package/package.json +1 -1
- package/src/adapter-sse/sse-adapter.ts +23 -4
- package/src/adapter-sse/sse-adapter.types.ts +9 -0
- package/src/adapter-websockets/websocket-adapter.ts +31 -6
- package/src/adapter-websockets/websocket-adapter.types.ts +20 -0
- package/src/delivery/delivery.batch.ts +71 -0
- package/src/delivery/delivery.latest.ts +64 -0
- package/src/delivery/delivery.types.ts +129 -0
- package/src/delivery/delivery.utils.ts +96 -0
- package/src/delivery/index.ts +4 -0
- package/src/index.ts +1 -0
- package/src/listener/listener.ts +48 -9
- package/src/listener/listener.types.ts +45 -10
- package/src/sdk/sdk.ts +27 -7
- package/src/socket/socket.ts +18 -2
- package/src/types/extract.types.ts +10 -4
- package/tsconfig.json +2 -0
|
@@ -0,0 +1,81 @@
|
|
|
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 Delivery ]", () => {
|
|
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 batch a real stream without losing messages", async () => {
|
|
21
|
+
const socket = new Socket({ url });
|
|
22
|
+
await waitForConnection(socket);
|
|
23
|
+
const listener = socket.createListener<{ id: number }>()({
|
|
24
|
+
topic: "trades",
|
|
25
|
+
delivery: { strategy: "batch", interval: 100 },
|
|
26
|
+
});
|
|
27
|
+
const batches: { id: number }[][] = [];
|
|
28
|
+
listener.listen(({ data }) => batches.push(data));
|
|
29
|
+
await sleep(50);
|
|
30
|
+
|
|
31
|
+
for (let i = 1; i <= 30; i += 1) {
|
|
32
|
+
wsServer.sendToAll("trades", { id: i });
|
|
33
|
+
}
|
|
34
|
+
await sleep(400);
|
|
35
|
+
|
|
36
|
+
expect(batches.length).toBeGreaterThanOrEqual(1);
|
|
37
|
+
expect(batches.length).toBeLessThan(30);
|
|
38
|
+
expect(batches.flat().map((m) => m.id)).toEqual(Array.from({ length: 30 }, (_, i) => i + 1));
|
|
39
|
+
await socket.disconnect();
|
|
40
|
+
});
|
|
41
|
+
|
|
42
|
+
it("should sample a real stream and end on the newest message", async () => {
|
|
43
|
+
const socket = new Socket({ url });
|
|
44
|
+
await waitForConnection(socket);
|
|
45
|
+
const listener = socket.createListener<{ id: number }>()({
|
|
46
|
+
topic: "prices",
|
|
47
|
+
delivery: { strategy: "latest", interval: 100 },
|
|
48
|
+
});
|
|
49
|
+
const received: number[] = [];
|
|
50
|
+
listener.listen(({ data }) => received.push(data.id));
|
|
51
|
+
await sleep(50);
|
|
52
|
+
|
|
53
|
+
for (let i = 1; i <= 30; i += 1) {
|
|
54
|
+
wsServer.sendToAll("prices", { id: i });
|
|
55
|
+
}
|
|
56
|
+
await sleep(400);
|
|
57
|
+
|
|
58
|
+
expect(received.length).toBeLessThan(30);
|
|
59
|
+
expect(received[0]).toBe(1);
|
|
60
|
+
expect(received.at(-1)).toBe(30);
|
|
61
|
+
await socket.disconnect();
|
|
62
|
+
});
|
|
63
|
+
|
|
64
|
+
it("should deliver nothing after unsubscribe", async () => {
|
|
65
|
+
const socket = new Socket({ url });
|
|
66
|
+
await waitForConnection(socket);
|
|
67
|
+
const listener = socket.createListener<{ id: number }>()({
|
|
68
|
+
topic: "late",
|
|
69
|
+
delivery: { strategy: "batch", interval: 100 },
|
|
70
|
+
});
|
|
71
|
+
const spy = vi.fn();
|
|
72
|
+
const stop = listener.listen(spy);
|
|
73
|
+
await sleep(50);
|
|
74
|
+
wsServer.sendToAll("late", { id: 1 });
|
|
75
|
+
await sleep(20);
|
|
76
|
+
stop();
|
|
77
|
+
await sleep(300);
|
|
78
|
+
expect(spy).not.toHaveBeenCalled();
|
|
79
|
+
await socket.disconnect();
|
|
80
|
+
});
|
|
81
|
+
});
|
|
@@ -0,0 +1,101 @@
|
|
|
1
|
+
import { createSseMockingServer } from "@hyper-fetch/testing";
|
|
2
|
+
import { waitFor } from "@testing-library/dom";
|
|
3
|
+
import type { SSEAdapterOptionsType, ServerSentEventsAdapterType } from "adapter-sse";
|
|
4
|
+
import { ServerSentEventsAdapter } from "adapter-sse";
|
|
5
|
+
|
|
6
|
+
import { createSocket } from "../../utils/socket.utils";
|
|
7
|
+
|
|
8
|
+
const decode: SSEAdapterOptionsType["decode"] = (event) => {
|
|
9
|
+
const message = JSON.parse(event.data);
|
|
10
|
+
if (message.type === "ping") {
|
|
11
|
+
return null;
|
|
12
|
+
}
|
|
13
|
+
return { topic: message.type, data: message.payload };
|
|
14
|
+
};
|
|
15
|
+
|
|
16
|
+
describe("SSE Adapter [ Decode ]", () => {
|
|
17
|
+
const { startServer, getSource } = createSseMockingServer();
|
|
18
|
+
|
|
19
|
+
const send = (data: string) => getSource().emitMessage(new MessageEvent("message", { data }));
|
|
20
|
+
|
|
21
|
+
const setup = async (adapterOptions?: SSEAdapterOptionsType) => {
|
|
22
|
+
const socket = createSocket<ServerSentEventsAdapterType>({
|
|
23
|
+
adapter: ServerSentEventsAdapter,
|
|
24
|
+
adapterOptions,
|
|
25
|
+
});
|
|
26
|
+
await startServer();
|
|
27
|
+
return socket;
|
|
28
|
+
};
|
|
29
|
+
|
|
30
|
+
beforeEach(() => {
|
|
31
|
+
vi.resetAllMocks();
|
|
32
|
+
});
|
|
33
|
+
|
|
34
|
+
it("should receive { topic, data } messages by default", async () => {
|
|
35
|
+
const socket = await setup();
|
|
36
|
+
const spy = vi.fn();
|
|
37
|
+
socket
|
|
38
|
+
.createListener()({ topic: "user" })
|
|
39
|
+
.listen(({ data }) => spy(data));
|
|
40
|
+
|
|
41
|
+
send(JSON.stringify({ topic: "user", data: { name: "Alice" } }));
|
|
42
|
+
|
|
43
|
+
await waitFor(() => {
|
|
44
|
+
expect(spy).toHaveBeenCalledWith({ name: "Alice" });
|
|
45
|
+
});
|
|
46
|
+
});
|
|
47
|
+
|
|
48
|
+
it("should map incoming messages to listener topics with custom decode", async () => {
|
|
49
|
+
const socket = await setup({ decode });
|
|
50
|
+
const spy = vi.fn();
|
|
51
|
+
socket
|
|
52
|
+
.createListener()({ topic: "user" })
|
|
53
|
+
.listen(({ data }) => spy(data));
|
|
54
|
+
|
|
55
|
+
send(JSON.stringify({ type: "user", payload: { name: "Alice" } }));
|
|
56
|
+
|
|
57
|
+
await waitFor(() => {
|
|
58
|
+
expect(spy).toHaveBeenCalledWith({ name: "Alice" });
|
|
59
|
+
});
|
|
60
|
+
});
|
|
61
|
+
|
|
62
|
+
it("should ignore messages decoded to null", async () => {
|
|
63
|
+
const socket = await setup({ decode });
|
|
64
|
+
const eventSpy = vi.fn();
|
|
65
|
+
socket.events.onListenerEvent(eventSpy);
|
|
66
|
+
|
|
67
|
+
send(JSON.stringify({ type: "ping" }));
|
|
68
|
+
send(JSON.stringify({ type: "user", payload: 1 }));
|
|
69
|
+
|
|
70
|
+
await waitFor(() => {
|
|
71
|
+
expect(eventSpy).toHaveBeenCalledTimes(1);
|
|
72
|
+
});
|
|
73
|
+
expect(eventSpy).toHaveBeenCalledWith(expect.objectContaining({ topic: "user", data: 1 }));
|
|
74
|
+
});
|
|
75
|
+
|
|
76
|
+
it("should report decoder errors and keep the connection", async () => {
|
|
77
|
+
const error = new Error("Malformed message");
|
|
78
|
+
const socket = await setup({
|
|
79
|
+
decode: (event) => {
|
|
80
|
+
if (event.data === "broken") {
|
|
81
|
+
throw error;
|
|
82
|
+
}
|
|
83
|
+
return decode(event);
|
|
84
|
+
},
|
|
85
|
+
});
|
|
86
|
+
const errorSpy = vi.fn();
|
|
87
|
+
const spy = vi.fn();
|
|
88
|
+
socket.onError(errorSpy);
|
|
89
|
+
socket.createListener()({ topic: "user" }).listen(spy);
|
|
90
|
+
|
|
91
|
+
send("broken");
|
|
92
|
+
send(JSON.stringify({ type: "user", payload: 1 }));
|
|
93
|
+
|
|
94
|
+
await waitFor(() => {
|
|
95
|
+
expect(spy).toHaveBeenCalledTimes(1);
|
|
96
|
+
});
|
|
97
|
+
expect(errorSpy).toHaveBeenCalledTimes(1);
|
|
98
|
+
expect(errorSpy).toHaveBeenCalledWith({ error });
|
|
99
|
+
expect(socket.adapter.connected).toBe(true);
|
|
100
|
+
});
|
|
101
|
+
});
|
|
@@ -0,0 +1,208 @@
|
|
|
1
|
+
import { createWebsocketMockingServer, waitForConnection } from "@hyper-fetch/testing";
|
|
2
|
+
import { waitFor } from "@testing-library/dom";
|
|
3
|
+
import type { WebsocketAdapterOptionsType } from "adapter-websockets";
|
|
4
|
+
|
|
5
|
+
import { createSocket } from "../../utils/socket.utils";
|
|
6
|
+
|
|
7
|
+
const decode: WebsocketAdapterOptionsType["decode"] = (event) => {
|
|
8
|
+
const message = JSON.parse(event.data);
|
|
9
|
+
if (message.type === "ping") {
|
|
10
|
+
return null;
|
|
11
|
+
}
|
|
12
|
+
return { topic: message.type, data: message.payload };
|
|
13
|
+
};
|
|
14
|
+
|
|
15
|
+
const encode: WebsocketAdapterOptionsType["encode"] = ({ topic, payload }) => JSON.stringify({ type: topic, payload });
|
|
16
|
+
|
|
17
|
+
describe("Websocket Adapter [ Encode / Decode ]", () => {
|
|
18
|
+
const { getServer, startServer, stopServer } = createWebsocketMockingServer();
|
|
19
|
+
|
|
20
|
+
beforeEach(() => {
|
|
21
|
+
vi.resetAllMocks();
|
|
22
|
+
startServer();
|
|
23
|
+
});
|
|
24
|
+
|
|
25
|
+
afterEach(() => {
|
|
26
|
+
stopServer();
|
|
27
|
+
});
|
|
28
|
+
|
|
29
|
+
describe("When using the default message format", () => {
|
|
30
|
+
it("should receive { topic, data } frames", async () => {
|
|
31
|
+
const socket = createSocket();
|
|
32
|
+
await waitForConnection(socket);
|
|
33
|
+
const spy = vi.fn();
|
|
34
|
+
socket
|
|
35
|
+
.createListener<{ name: string }>()({ topic: "user" })
|
|
36
|
+
.listen(({ data }) => spy(data));
|
|
37
|
+
|
|
38
|
+
getServer().send(JSON.stringify({ topic: "user", data: { name: "Alice" } }));
|
|
39
|
+
|
|
40
|
+
await waitFor(() => {
|
|
41
|
+
expect(spy).toHaveBeenCalledWith({ name: "Alice" });
|
|
42
|
+
});
|
|
43
|
+
});
|
|
44
|
+
|
|
45
|
+
it("should send { topic, data } frames", async () => {
|
|
46
|
+
const socket = createSocket();
|
|
47
|
+
await waitForConnection(socket);
|
|
48
|
+
|
|
49
|
+
socket
|
|
50
|
+
.createEmitter<{ name: string }>()({ topic: "user" })
|
|
51
|
+
.emit({ payload: { name: "Alice" } });
|
|
52
|
+
|
|
53
|
+
await expect(getServer()).toReceiveMessage(JSON.stringify({ topic: "user", data: { name: "Alice" } }));
|
|
54
|
+
});
|
|
55
|
+
});
|
|
56
|
+
|
|
57
|
+
describe("When using custom decode", () => {
|
|
58
|
+
it("should map incoming frames to listener topics", async () => {
|
|
59
|
+
const socket = createSocket({ adapterOptions: { decode } });
|
|
60
|
+
await waitForConnection(socket);
|
|
61
|
+
const spy = vi.fn();
|
|
62
|
+
const other = vi.fn();
|
|
63
|
+
socket
|
|
64
|
+
.createListener<{ name: string }>()({ topic: "user" })
|
|
65
|
+
.listen(({ data }) => spy(data));
|
|
66
|
+
socket.createListener()({ topic: "other" }).listen(other);
|
|
67
|
+
|
|
68
|
+
getServer().send(JSON.stringify({ type: "user", payload: { name: "Alice" } }));
|
|
69
|
+
|
|
70
|
+
await waitFor(() => {
|
|
71
|
+
expect(spy).toHaveBeenCalledWith({ name: "Alice" });
|
|
72
|
+
});
|
|
73
|
+
expect(other).not.toHaveBeenCalled();
|
|
74
|
+
});
|
|
75
|
+
|
|
76
|
+
it("should pass the original MessageEvent as extra", async () => {
|
|
77
|
+
const socket = createSocket({ adapterOptions: { decode } });
|
|
78
|
+
await waitForConnection(socket);
|
|
79
|
+
const spy = vi.fn();
|
|
80
|
+
socket
|
|
81
|
+
.createListener()({ topic: "user" })
|
|
82
|
+
.listen(({ extra }) => spy(extra));
|
|
83
|
+
const frame = JSON.stringify({ type: "user", payload: {} });
|
|
84
|
+
|
|
85
|
+
getServer().send(frame);
|
|
86
|
+
|
|
87
|
+
await waitFor(() => {
|
|
88
|
+
expect(spy).toHaveBeenCalledTimes(1);
|
|
89
|
+
});
|
|
90
|
+
expect(spy.mock.calls[0][0].type).toBe("message");
|
|
91
|
+
expect(spy.mock.calls[0][0].data).toBe(frame);
|
|
92
|
+
});
|
|
93
|
+
|
|
94
|
+
it("should ignore frames decoded to null", async () => {
|
|
95
|
+
const socket = createSocket({ adapterOptions: { decode } });
|
|
96
|
+
await waitForConnection(socket);
|
|
97
|
+
const spy = vi.fn();
|
|
98
|
+
const eventSpy = vi.fn();
|
|
99
|
+
socket.events.onListenerEvent(eventSpy);
|
|
100
|
+
socket.createListener()({ topic: "user" }).listen(spy);
|
|
101
|
+
|
|
102
|
+
getServer().send(JSON.stringify({ type: "ping" }));
|
|
103
|
+
getServer().send(JSON.stringify({ type: "user", payload: { name: "Alice" } }));
|
|
104
|
+
|
|
105
|
+
await waitFor(() => {
|
|
106
|
+
expect(spy).toHaveBeenCalledTimes(1);
|
|
107
|
+
});
|
|
108
|
+
expect(eventSpy).toHaveBeenCalledTimes(1);
|
|
109
|
+
});
|
|
110
|
+
|
|
111
|
+
it("should report decoder errors and keep the connection", async () => {
|
|
112
|
+
const error = new Error("Malformed frame");
|
|
113
|
+
const socket = createSocket({
|
|
114
|
+
adapterOptions: {
|
|
115
|
+
decode: (event) => {
|
|
116
|
+
if (event.data === "broken") {
|
|
117
|
+
throw error;
|
|
118
|
+
}
|
|
119
|
+
return decode(event);
|
|
120
|
+
},
|
|
121
|
+
},
|
|
122
|
+
});
|
|
123
|
+
await waitForConnection(socket);
|
|
124
|
+
const errorSpy = vi.fn();
|
|
125
|
+
const spy = vi.fn();
|
|
126
|
+
socket.onError(errorSpy);
|
|
127
|
+
socket.createListener()({ topic: "user" }).listen(spy);
|
|
128
|
+
|
|
129
|
+
getServer().send("broken");
|
|
130
|
+
getServer().send(JSON.stringify({ type: "user", payload: {} }));
|
|
131
|
+
|
|
132
|
+
await waitFor(() => {
|
|
133
|
+
expect(spy).toHaveBeenCalledTimes(1);
|
|
134
|
+
});
|
|
135
|
+
expect(errorSpy).toHaveBeenCalledTimes(1);
|
|
136
|
+
expect(errorSpy).toHaveBeenCalledWith({ error });
|
|
137
|
+
expect(socket.adapter.connected).toBe(true);
|
|
138
|
+
});
|
|
139
|
+
|
|
140
|
+
it("should use the decoder returned by onConnect", async () => {
|
|
141
|
+
// Registered synchronously - the initial connection attempt runs the interceptors asynchronously
|
|
142
|
+
const socket = createSocket().onConnect(({ connection }) => ({
|
|
143
|
+
...connection,
|
|
144
|
+
adapterOptions: { ...connection.adapterOptions, decode },
|
|
145
|
+
}));
|
|
146
|
+
await waitForConnection(socket);
|
|
147
|
+
const spy = vi.fn();
|
|
148
|
+
socket
|
|
149
|
+
.createListener()({ topic: "user" })
|
|
150
|
+
.listen(({ data }) => spy(data));
|
|
151
|
+
|
|
152
|
+
getServer().send(JSON.stringify({ type: "user", payload: 1 }));
|
|
153
|
+
|
|
154
|
+
await waitFor(() => {
|
|
155
|
+
expect(spy).toHaveBeenCalledWith(1);
|
|
156
|
+
});
|
|
157
|
+
});
|
|
158
|
+
});
|
|
159
|
+
|
|
160
|
+
describe("When using custom encode", () => {
|
|
161
|
+
it("should encode emitted messages", async () => {
|
|
162
|
+
const socket = createSocket({ adapterOptions: { encode } });
|
|
163
|
+
await waitForConnection(socket);
|
|
164
|
+
|
|
165
|
+
socket
|
|
166
|
+
.createEmitter<{ name: string }>()({ topic: "user" })
|
|
167
|
+
.emit({ payload: { name: "Alice" } });
|
|
168
|
+
|
|
169
|
+
await expect(getServer()).toReceiveMessage(JSON.stringify({ type: "user", payload: { name: "Alice" } }));
|
|
170
|
+
});
|
|
171
|
+
|
|
172
|
+
it("should encode heartbeat messages", async () => {
|
|
173
|
+
const socket = createSocket({
|
|
174
|
+
adapterOptions: {
|
|
175
|
+
encode,
|
|
176
|
+
heartbeat: true,
|
|
177
|
+
heartbeatMessage: "ping",
|
|
178
|
+
pingTimeout: 10,
|
|
179
|
+
pongTimeout: 1000,
|
|
180
|
+
},
|
|
181
|
+
});
|
|
182
|
+
await waitForConnection(socket);
|
|
183
|
+
|
|
184
|
+
await expect(getServer()).toReceiveMessage(JSON.stringify({ type: "heartbeat", payload: "ping" }));
|
|
185
|
+
});
|
|
186
|
+
|
|
187
|
+
it("should report encoder errors without sending the frame", async () => {
|
|
188
|
+
const error = new Error("Cannot encode");
|
|
189
|
+
const socket = createSocket({
|
|
190
|
+
adapterOptions: {
|
|
191
|
+
encode: () => {
|
|
192
|
+
throw error;
|
|
193
|
+
},
|
|
194
|
+
},
|
|
195
|
+
});
|
|
196
|
+
await waitForConnection(socket);
|
|
197
|
+
const errorSpy = vi.fn();
|
|
198
|
+
socket.onError(errorSpy);
|
|
199
|
+
const sendSpy = vi.fn();
|
|
200
|
+
getServer().on("message", sendSpy);
|
|
201
|
+
|
|
202
|
+
await socket.adapter.emit(socket.createEmitter()({ topic: "user" }));
|
|
203
|
+
|
|
204
|
+
expect(errorSpy).toHaveBeenCalledWith({ error });
|
|
205
|
+
expect(sendSpy).not.toHaveBeenCalled();
|
|
206
|
+
});
|
|
207
|
+
});
|
|
208
|
+
});
|
|
@@ -0,0 +1,203 @@
|
|
|
1
|
+
import { createBatchDeliveryStrategy } from "delivery";
|
|
2
|
+
|
|
3
|
+
type Message = { data: number; extra: { id: number } };
|
|
4
|
+
|
|
5
|
+
const message = (data: number): Message => ({ data, extra: { id: data } });
|
|
6
|
+
|
|
7
|
+
describe("Delivery [ Batch ]", () => {
|
|
8
|
+
const setup = (options: { interval: number; maxSize?: number }) => {
|
|
9
|
+
const deliver = vi.fn();
|
|
10
|
+
const controller = createBatchDeliveryStrategy<number, { id: number }>(options)({ deliver });
|
|
11
|
+
return { deliver, controller };
|
|
12
|
+
};
|
|
13
|
+
|
|
14
|
+
beforeEach(() => {
|
|
15
|
+
vi.useFakeTimers();
|
|
16
|
+
});
|
|
17
|
+
|
|
18
|
+
afterEach(() => {
|
|
19
|
+
vi.useRealTimers();
|
|
20
|
+
});
|
|
21
|
+
|
|
22
|
+
it("should deliver all messages in order when the window closes", () => {
|
|
23
|
+
const { deliver, controller } = setup({ interval: 100 });
|
|
24
|
+
controller.push(message(1));
|
|
25
|
+
controller.push(message(2));
|
|
26
|
+
controller.push(message(3));
|
|
27
|
+
expect(deliver).not.toHaveBeenCalled();
|
|
28
|
+
vi.advanceTimersByTime(100);
|
|
29
|
+
expect(deliver).toHaveBeenCalledOnce();
|
|
30
|
+
expect(deliver).toHaveBeenCalledWith({ data: [1, 2, 3], extra: { id: 3 } });
|
|
31
|
+
});
|
|
32
|
+
|
|
33
|
+
it("should measure the window from the first message", () => {
|
|
34
|
+
const { deliver, controller } = setup({ interval: 100 });
|
|
35
|
+
controller.push(message(1));
|
|
36
|
+
vi.advanceTimersByTime(60);
|
|
37
|
+
controller.push(message(2));
|
|
38
|
+
vi.advanceTimersByTime(40); // t=100 since first
|
|
39
|
+
expect(deliver).toHaveBeenCalledOnce();
|
|
40
|
+
expect(deliver).toHaveBeenCalledWith({ data: [1, 2], extra: { id: 2 } });
|
|
41
|
+
});
|
|
42
|
+
|
|
43
|
+
it("should flush early at maxSize and cancel the timer", () => {
|
|
44
|
+
const { deliver, controller } = setup({ interval: 100, maxSize: 2 });
|
|
45
|
+
controller.push(message(1));
|
|
46
|
+
controller.push(message(2));
|
|
47
|
+
expect(deliver).toHaveBeenCalledOnce();
|
|
48
|
+
expect(deliver).toHaveBeenCalledWith({ data: [1, 2], extra: { id: 2 } });
|
|
49
|
+
vi.advanceTimersByTime(100);
|
|
50
|
+
expect(deliver).toHaveBeenCalledOnce(); // the timer was cancelled, no empty batch
|
|
51
|
+
});
|
|
52
|
+
|
|
53
|
+
it("should open a new window after a flush", () => {
|
|
54
|
+
const { deliver, controller } = setup({ interval: 100 });
|
|
55
|
+
controller.push(message(1));
|
|
56
|
+
vi.advanceTimersByTime(100);
|
|
57
|
+
controller.push(message(2));
|
|
58
|
+
expect(deliver).toHaveBeenCalledOnce();
|
|
59
|
+
vi.advanceTimersByTime(100);
|
|
60
|
+
expect(deliver).toHaveBeenCalledTimes(2);
|
|
61
|
+
expect(deliver).toHaveBeenLastCalledWith({ data: [2], extra: { id: 2 } });
|
|
62
|
+
});
|
|
63
|
+
|
|
64
|
+
it("should never deliver an empty batch", () => {
|
|
65
|
+
const { deliver } = setup({ interval: 100 });
|
|
66
|
+
vi.advanceTimersByTime(1000);
|
|
67
|
+
expect(deliver).not.toHaveBeenCalled();
|
|
68
|
+
});
|
|
69
|
+
|
|
70
|
+
it("should drop the buffer on dispose", () => {
|
|
71
|
+
const { deliver, controller } = setup({ interval: 100 });
|
|
72
|
+
controller.push(message(1));
|
|
73
|
+
controller.push(message(2));
|
|
74
|
+
controller.dispose();
|
|
75
|
+
controller.dispose(); // idempotent
|
|
76
|
+
vi.advanceTimersByTime(500);
|
|
77
|
+
expect(deliver).not.toHaveBeenCalled();
|
|
78
|
+
});
|
|
79
|
+
|
|
80
|
+
it("should ignore messages pushed after dispose", () => {
|
|
81
|
+
const { deliver, controller } = setup({ interval: 100, maxSize: 1 });
|
|
82
|
+
controller.dispose();
|
|
83
|
+
controller.push(message(1));
|
|
84
|
+
expect(deliver).not.toHaveBeenCalled();
|
|
85
|
+
});
|
|
86
|
+
|
|
87
|
+
it("should split a burst into ceil(n / maxSize) batches", () => {
|
|
88
|
+
const { deliver, controller } = setup({ interval: 100, maxSize: 10 });
|
|
89
|
+
for (let i = 1; i <= 25; i += 1) {
|
|
90
|
+
controller.push(message(i));
|
|
91
|
+
}
|
|
92
|
+
expect(deliver).toHaveBeenCalledTimes(2);
|
|
93
|
+
vi.advanceTimersByTime(100);
|
|
94
|
+
expect(deliver).toHaveBeenCalledTimes(3);
|
|
95
|
+
expect(deliver.mock.calls.map(([{ data }]) => data.length)).toEqual([10, 10, 5]);
|
|
96
|
+
});
|
|
97
|
+
|
|
98
|
+
it("should allow disposing from inside the callback", () => {
|
|
99
|
+
const deliver = vi.fn();
|
|
100
|
+
const controller = createBatchDeliveryStrategy<number>({ interval: 100 })({
|
|
101
|
+
deliver: (msg) => {
|
|
102
|
+
deliver(msg);
|
|
103
|
+
controller.dispose();
|
|
104
|
+
},
|
|
105
|
+
});
|
|
106
|
+
controller.push(message(1));
|
|
107
|
+
vi.advanceTimersByTime(100);
|
|
108
|
+
controller.push(message(2));
|
|
109
|
+
vi.advanceTimersByTime(100);
|
|
110
|
+
expect(deliver).toHaveBeenCalledOnce();
|
|
111
|
+
});
|
|
112
|
+
|
|
113
|
+
it("should deliver every message immediately with maxSize 1", () => {
|
|
114
|
+
const { deliver, controller } = setup({ interval: 100, maxSize: 1 });
|
|
115
|
+
controller.push(message(1));
|
|
116
|
+
controller.push(message(2));
|
|
117
|
+
expect(deliver).toHaveBeenCalledTimes(2);
|
|
118
|
+
expect(deliver.mock.calls.map(([m]) => m.data)).toEqual([[1], [2]]);
|
|
119
|
+
expect(vi.getTimerCount()).toBe(0);
|
|
120
|
+
});
|
|
121
|
+
|
|
122
|
+
it("should flush exactly at the maxSize boundary", () => {
|
|
123
|
+
const { deliver, controller } = setup({ interval: 100, maxSize: 3 });
|
|
124
|
+
controller.push(message(1));
|
|
125
|
+
controller.push(message(2));
|
|
126
|
+
expect(deliver).not.toHaveBeenCalled();
|
|
127
|
+
controller.push(message(3));
|
|
128
|
+
expect(deliver).toHaveBeenCalledWith({ data: [1, 2, 3], extra: { id: 3 } });
|
|
129
|
+
controller.push(message(4));
|
|
130
|
+
controller.push(message(5));
|
|
131
|
+
expect(deliver).toHaveBeenCalledOnce();
|
|
132
|
+
vi.advanceTimersByTime(100);
|
|
133
|
+
expect(deliver).toHaveBeenLastCalledWith({ data: [4, 5], extra: { id: 5 } });
|
|
134
|
+
});
|
|
135
|
+
|
|
136
|
+
it("should keep a burst of 1000 messages in one ordered batch without maxSize", () => {
|
|
137
|
+
const { deliver, controller } = setup({ interval: 100 });
|
|
138
|
+
const expected: number[] = [];
|
|
139
|
+
for (let i = 1; i <= 1000; i += 1) {
|
|
140
|
+
controller.push(message(i));
|
|
141
|
+
expected.push(i);
|
|
142
|
+
}
|
|
143
|
+
vi.advanceTimersByTime(100);
|
|
144
|
+
expect(deliver).toHaveBeenCalledOnce();
|
|
145
|
+
expect(deliver.mock.calls[0][0].data).toEqual(expected);
|
|
146
|
+
});
|
|
147
|
+
|
|
148
|
+
it("should deliver a fresh array for each batch", () => {
|
|
149
|
+
const { deliver, controller } = setup({ interval: 100 });
|
|
150
|
+
controller.push(message(1));
|
|
151
|
+
vi.advanceTimersByTime(100);
|
|
152
|
+
controller.push(message(2));
|
|
153
|
+
vi.advanceTimersByTime(100);
|
|
154
|
+
expect(deliver.mock.calls[0][0].data).not.toBe(deliver.mock.calls[1][0].data);
|
|
155
|
+
expect(deliver.mock.calls[0][0].data).toEqual([1]);
|
|
156
|
+
expect(deliver.mock.calls[1][0].data).toEqual([2]);
|
|
157
|
+
});
|
|
158
|
+
|
|
159
|
+
it("should keep working after the callback throws", () => {
|
|
160
|
+
const deliver = vi.fn().mockImplementationOnce(() => {
|
|
161
|
+
throw new Error("boom");
|
|
162
|
+
});
|
|
163
|
+
const controller = createBatchDeliveryStrategy<number>({ interval: 100 })({ deliver });
|
|
164
|
+
controller.push(message(1));
|
|
165
|
+
expect(() => vi.advanceTimersByTime(100)).toThrow("boom");
|
|
166
|
+
controller.push(message(2));
|
|
167
|
+
controller.push(message(3));
|
|
168
|
+
vi.advanceTimersByTime(100);
|
|
169
|
+
expect(deliver).toHaveBeenCalledTimes(2);
|
|
170
|
+
expect(deliver).toHaveBeenLastCalledWith({ data: [2, 3], extra: { id: 3 } });
|
|
171
|
+
});
|
|
172
|
+
|
|
173
|
+
it("should not leak timers after dispose", () => {
|
|
174
|
+
const { controller } = setup({ interval: 100 });
|
|
175
|
+
controller.push(message(1));
|
|
176
|
+
expect(vi.getTimerCount()).toBe(1);
|
|
177
|
+
controller.dispose();
|
|
178
|
+
expect(vi.getTimerCount()).toBe(0);
|
|
179
|
+
});
|
|
180
|
+
|
|
181
|
+
it("should give independent buffers to controllers created from one factory", () => {
|
|
182
|
+
const factory = createBatchDeliveryStrategy<number>({ interval: 100 });
|
|
183
|
+
const first = vi.fn();
|
|
184
|
+
const second = vi.fn();
|
|
185
|
+
const a = factory({ deliver: first });
|
|
186
|
+
const b = factory({ deliver: second });
|
|
187
|
+
a.push(message(1));
|
|
188
|
+
b.push(message(10));
|
|
189
|
+
a.push(message(2));
|
|
190
|
+
vi.advanceTimersByTime(100);
|
|
191
|
+
expect(first).toHaveBeenCalledWith({ data: [1, 2], extra: { id: 2 } });
|
|
192
|
+
expect(second).toHaveBeenCalledWith({ data: [10], extra: { id: 10 } });
|
|
193
|
+
});
|
|
194
|
+
|
|
195
|
+
it("should flush pending messages with interval 0 on the next macrotask", () => {
|
|
196
|
+
const { deliver, controller } = setup({ interval: 0 });
|
|
197
|
+
controller.push(message(1));
|
|
198
|
+
controller.push(message(2));
|
|
199
|
+
expect(deliver).not.toHaveBeenCalled();
|
|
200
|
+
vi.advanceTimersByTime(0);
|
|
201
|
+
expect(deliver).toHaveBeenCalledWith({ data: [1, 2], extra: { id: 2 } });
|
|
202
|
+
});
|
|
203
|
+
});
|