@hyper-fetch/sockets 9.0.2 → 9.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.delivery.spec.ts +81 -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/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 +198 -4
- 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 +2 -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/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 +8 -2
- package/src/types/extract.types.ts +10 -4
- package/tsconfig.json +2 -0
|
@@ -0,0 +1,122 @@
|
|
|
1
|
+
import type { DeliveryControllerType } from "delivery";
|
|
2
|
+
import {
|
|
3
|
+
assertDelivery,
|
|
4
|
+
createDeliveryController,
|
|
5
|
+
createDeliveryStrategy,
|
|
6
|
+
getDeliveryKey,
|
|
7
|
+
isDeliveryStrategy,
|
|
8
|
+
} from "delivery";
|
|
9
|
+
|
|
10
|
+
describe("Delivery [ Utils ]", () => {
|
|
11
|
+
describe("createDeliveryStrategy", () => {
|
|
12
|
+
it("should return the given strategy untouched", () => {
|
|
13
|
+
const strategy = createDeliveryStrategy<number, string>(({ deliver }) => ({
|
|
14
|
+
push: ({ data, extra }) => deliver({ data: String(data), extra }),
|
|
15
|
+
dispose: () => null,
|
|
16
|
+
}));
|
|
17
|
+
expect(typeof strategy).toBe("function");
|
|
18
|
+
expect(isDeliveryStrategy(strategy)).toBeTrue();
|
|
19
|
+
expect(isDeliveryStrategy({ strategy: "latest", interval: 1 })).toBeFalse();
|
|
20
|
+
});
|
|
21
|
+
});
|
|
22
|
+
|
|
23
|
+
describe("assertDelivery", () => {
|
|
24
|
+
it("should accept presets and custom strategies", () => {
|
|
25
|
+
expect(() => assertDelivery({ strategy: "latest", interval: 10 })).not.toThrow();
|
|
26
|
+
expect(() => assertDelivery({ strategy: "batch", interval: 10 })).not.toThrow();
|
|
27
|
+
expect(() => assertDelivery(() => ({ push: () => null, dispose: () => null }))).not.toThrow();
|
|
28
|
+
});
|
|
29
|
+
it("should throw for an unknown preset", () => {
|
|
30
|
+
expect(() => assertDelivery({ strategy: "nope", interval: 10 } as any)).toThrow(
|
|
31
|
+
/Unknown delivery strategy: nope/,
|
|
32
|
+
);
|
|
33
|
+
});
|
|
34
|
+
});
|
|
35
|
+
|
|
36
|
+
describe("createDeliveryController", () => {
|
|
37
|
+
it("should call a custom strategy with the context", () => {
|
|
38
|
+
const controller: DeliveryControllerType<number> = { push: vi.fn(), dispose: vi.fn() };
|
|
39
|
+
const strategy = vi.fn(() => controller);
|
|
40
|
+
const deliver = vi.fn();
|
|
41
|
+
const result = createDeliveryController<number, number, unknown>(strategy, { deliver });
|
|
42
|
+
expect(strategy).toHaveBeenCalledOnce();
|
|
43
|
+
expect(strategy).toHaveBeenCalledWith({ deliver });
|
|
44
|
+
expect(result).toBe(controller);
|
|
45
|
+
});
|
|
46
|
+
it("should build the latest preset", () => {
|
|
47
|
+
const deliver = vi.fn();
|
|
48
|
+
const controller = createDeliveryController({ strategy: "latest", interval: 100 }, { deliver });
|
|
49
|
+
controller.push({ data: 1, extra: null });
|
|
50
|
+
expect(deliver).toHaveBeenCalledWith({ data: 1, extra: null });
|
|
51
|
+
controller.dispose();
|
|
52
|
+
});
|
|
53
|
+
it("should build the batch preset", () => {
|
|
54
|
+
vi.useFakeTimers();
|
|
55
|
+
const deliver = vi.fn();
|
|
56
|
+
const controller = createDeliveryController({ strategy: "batch", interval: 100 }, { deliver });
|
|
57
|
+
controller.push({ data: 1, extra: null });
|
|
58
|
+
controller.push({ data: 2, extra: null });
|
|
59
|
+
vi.advanceTimersByTime(100);
|
|
60
|
+
expect(deliver).toHaveBeenCalledWith({ data: [1, 2], extra: null });
|
|
61
|
+
controller.dispose();
|
|
62
|
+
vi.useRealTimers();
|
|
63
|
+
});
|
|
64
|
+
});
|
|
65
|
+
|
|
66
|
+
describe("getDeliveryKey", () => {
|
|
67
|
+
it("should compare presets by value and strategies by identity", () => {
|
|
68
|
+
const strategy = () => ({ push: () => null, dispose: () => null });
|
|
69
|
+
expect(getDeliveryKey()).toBe("");
|
|
70
|
+
expect(getDeliveryKey({ strategy: "latest", interval: 16 })).toBe(
|
|
71
|
+
getDeliveryKey({ strategy: "latest", interval: 16 }),
|
|
72
|
+
);
|
|
73
|
+
expect(getDeliveryKey({ strategy: "latest", interval: 16 })).not.toBe(
|
|
74
|
+
getDeliveryKey({ strategy: "latest", interval: 32 }),
|
|
75
|
+
);
|
|
76
|
+
expect(getDeliveryKey(strategy)).toBe(strategy);
|
|
77
|
+
});
|
|
78
|
+
});
|
|
79
|
+
|
|
80
|
+
describe("edge cases", () => {
|
|
81
|
+
it("should throw a helpful error when the strategy key is missing", () => {
|
|
82
|
+
expect(() => assertDelivery({ interval: 10 } as any)).toThrow(/Unknown delivery strategy: undefined/);
|
|
83
|
+
expect(() => assertDelivery({ interval: 10 } as any)).toThrow(/createDeliveryStrategy/);
|
|
84
|
+
});
|
|
85
|
+
it("should build latest without leading", () => {
|
|
86
|
+
vi.useFakeTimers();
|
|
87
|
+
const deliver = vi.fn();
|
|
88
|
+
const controller = createDeliveryController({ strategy: "latest", interval: 100, leading: false }, { deliver });
|
|
89
|
+
controller.push({ data: 1, extra: null });
|
|
90
|
+
expect(deliver).not.toHaveBeenCalled();
|
|
91
|
+
vi.advanceTimersByTime(100);
|
|
92
|
+
expect(deliver).toHaveBeenCalledWith({ data: 1, extra: null });
|
|
93
|
+
controller.dispose();
|
|
94
|
+
vi.useRealTimers();
|
|
95
|
+
});
|
|
96
|
+
it("should build batch with maxSize", () => {
|
|
97
|
+
const deliver = vi.fn();
|
|
98
|
+
const controller = createDeliveryController({ strategy: "batch", interval: 100, maxSize: 2 }, { deliver });
|
|
99
|
+
controller.push({ data: 1, extra: null });
|
|
100
|
+
controller.push({ data: 2, extra: null });
|
|
101
|
+
expect(deliver).toHaveBeenCalledWith({ data: [1, 2], extra: null });
|
|
102
|
+
controller.dispose();
|
|
103
|
+
});
|
|
104
|
+
it("should produce different keys for different presets", () => {
|
|
105
|
+
expect(getDeliveryKey({ strategy: "latest", interval: 16 })).not.toBe(
|
|
106
|
+
getDeliveryKey({ strategy: "batch", interval: 16 }),
|
|
107
|
+
);
|
|
108
|
+
expect(getDeliveryKey({ strategy: "batch", interval: 16 })).not.toBe(
|
|
109
|
+
getDeliveryKey({ strategy: "batch", interval: 16, maxSize: 5 }),
|
|
110
|
+
);
|
|
111
|
+
expect(getDeliveryKey({ strategy: "latest", interval: 16, leading: false })).not.toBe(
|
|
112
|
+
getDeliveryKey({ strategy: "latest", interval: 16 }),
|
|
113
|
+
);
|
|
114
|
+
});
|
|
115
|
+
it("should produce different keys for different strategy functions", () => {
|
|
116
|
+
const a = () => ({ push: () => null, dispose: () => null });
|
|
117
|
+
const b = () => ({ push: () => null, dispose: () => null });
|
|
118
|
+
expect(getDeliveryKey(a)).not.toBe(getDeliveryKey(b));
|
|
119
|
+
expect(getDeliveryKey(a)).toBe(getDeliveryKey(a));
|
|
120
|
+
});
|
|
121
|
+
});
|
|
122
|
+
});
|
|
@@ -0,0 +1,385 @@
|
|
|
1
|
+
import { createWebsocketMockingServer, waitForConnection } from "@hyper-fetch/testing";
|
|
2
|
+
import { createDeliveryStrategy } from "delivery";
|
|
3
|
+
|
|
4
|
+
import { createListener } from "../../utils/listener.utils";
|
|
5
|
+
import { createSocket } from "../../utils/socket.utils";
|
|
6
|
+
|
|
7
|
+
type DataType = { price: number };
|
|
8
|
+
|
|
9
|
+
describe("Listener [ Delivery ]", () => {
|
|
10
|
+
const { startServer, stopServer, emitListenerEvent } = createWebsocketMockingServer();
|
|
11
|
+
let socket = createSocket();
|
|
12
|
+
|
|
13
|
+
beforeEach(async () => {
|
|
14
|
+
startServer();
|
|
15
|
+
socket = createSocket();
|
|
16
|
+
await waitForConnection(socket);
|
|
17
|
+
vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
|
|
18
|
+
});
|
|
19
|
+
|
|
20
|
+
afterEach(() => {
|
|
21
|
+
vi.useRealTimers();
|
|
22
|
+
stopServer();
|
|
23
|
+
});
|
|
24
|
+
|
|
25
|
+
it("should register the original callback when no delivery is configured", () => {
|
|
26
|
+
const listener = createListener<DataType>(socket);
|
|
27
|
+
const spy = vi.fn();
|
|
28
|
+
const stop = listener.listen(spy);
|
|
29
|
+
expect(socket.adapter.listeners.get(listener.topic)?.has(spy)).toBeTrue();
|
|
30
|
+
stop();
|
|
31
|
+
expect(socket.adapter.listeners.get(listener.topic)?.has(spy)).toBeFalse();
|
|
32
|
+
});
|
|
33
|
+
|
|
34
|
+
it("should register a wrapper and remove it on unsubscribe when delivery is configured", () => {
|
|
35
|
+
const listener = createListener<DataType>(socket, { delivery: { strategy: "latest", interval: 100 } });
|
|
36
|
+
const spy = vi.fn();
|
|
37
|
+
const stop = listener.listen(spy);
|
|
38
|
+
const group = socket.adapter.listeners.get(listener.topic);
|
|
39
|
+
expect(group?.size).toBe(1);
|
|
40
|
+
expect(group?.has(spy)).toBeFalse();
|
|
41
|
+
stop();
|
|
42
|
+
expect(group?.size).toBe(0);
|
|
43
|
+
});
|
|
44
|
+
|
|
45
|
+
it("should sample messages with the latest strategy", () => {
|
|
46
|
+
const listener = createListener<DataType>(socket, { delivery: { strategy: "latest", interval: 100 } });
|
|
47
|
+
const spy = vi.fn();
|
|
48
|
+
listener.listen(({ data }) => spy(data));
|
|
49
|
+
|
|
50
|
+
emitListenerEvent(listener, { price: 1 });
|
|
51
|
+
emitListenerEvent(listener, { price: 2 });
|
|
52
|
+
emitListenerEvent(listener, { price: 3 });
|
|
53
|
+
expect(spy).toHaveBeenCalledOnce();
|
|
54
|
+
expect(spy).toHaveBeenCalledWith({ price: 1 });
|
|
55
|
+
|
|
56
|
+
vi.advanceTimersByTime(100);
|
|
57
|
+
expect(spy).toHaveBeenCalledTimes(2);
|
|
58
|
+
expect(spy).toHaveBeenLastCalledWith({ price: 3 });
|
|
59
|
+
});
|
|
60
|
+
|
|
61
|
+
it("should batch messages with the batch strategy", () => {
|
|
62
|
+
const listener = createListener<DataType>(socket, { delivery: { strategy: "batch", interval: 100 } });
|
|
63
|
+
const spy = vi.fn();
|
|
64
|
+
listener.listen(({ data, extra }) => spy(data, extra));
|
|
65
|
+
|
|
66
|
+
emitListenerEvent(listener, { price: 1 });
|
|
67
|
+
emitListenerEvent(listener, { price: 2 });
|
|
68
|
+
expect(spy).not.toHaveBeenCalled();
|
|
69
|
+
|
|
70
|
+
vi.advanceTimersByTime(100);
|
|
71
|
+
expect(spy).toHaveBeenCalledOnce();
|
|
72
|
+
expect(spy.mock.calls[0][0]).toEqual([{ price: 1 }, { price: 2 }]);
|
|
73
|
+
expect(spy.mock.calls[0][1]).toHaveProperty("data");
|
|
74
|
+
});
|
|
75
|
+
|
|
76
|
+
it("should not deliver after unsubscribe", () => {
|
|
77
|
+
const listener = createListener<DataType>(socket, { delivery: { strategy: "batch", interval: 100 } });
|
|
78
|
+
const spy = vi.fn();
|
|
79
|
+
const stop = listener.listen(spy);
|
|
80
|
+
emitListenerEvent(listener, { price: 1 });
|
|
81
|
+
stop();
|
|
82
|
+
vi.advanceTimersByTime(500);
|
|
83
|
+
emitListenerEvent(listener, { price: 2 });
|
|
84
|
+
vi.advanceTimersByTime(500);
|
|
85
|
+
expect(spy).not.toHaveBeenCalled();
|
|
86
|
+
});
|
|
87
|
+
|
|
88
|
+
it("should run a custom strategy", () => {
|
|
89
|
+
const summarize = createDeliveryStrategy<DataType, { count: number; max: number }>(({ deliver }) => {
|
|
90
|
+
let count = 0;
|
|
91
|
+
let max = -Infinity;
|
|
92
|
+
let timer: ReturnType<typeof setTimeout> | undefined;
|
|
93
|
+
return {
|
|
94
|
+
push: ({ data, extra }) => {
|
|
95
|
+
count += 1;
|
|
96
|
+
max = Math.max(max, data.price);
|
|
97
|
+
timer ??= setTimeout(() => {
|
|
98
|
+
timer = undefined;
|
|
99
|
+
deliver({ data: { count, max }, extra });
|
|
100
|
+
count = 0;
|
|
101
|
+
max = -Infinity;
|
|
102
|
+
}, 50);
|
|
103
|
+
},
|
|
104
|
+
dispose: () => clearTimeout(timer),
|
|
105
|
+
};
|
|
106
|
+
});
|
|
107
|
+
const listener = createListener<DataType>(socket, { delivery: summarize });
|
|
108
|
+
const spy = vi.fn();
|
|
109
|
+
listener.listen(({ data }) => spy(data));
|
|
110
|
+
|
|
111
|
+
emitListenerEvent(listener, { price: 5 });
|
|
112
|
+
emitListenerEvent(listener, { price: 9 });
|
|
113
|
+
emitListenerEvent(listener, { price: 2 });
|
|
114
|
+
vi.advanceTimersByTime(50);
|
|
115
|
+
expect(spy).toHaveBeenCalledOnce();
|
|
116
|
+
expect(spy).toHaveBeenCalledWith({ count: 3, max: 9 });
|
|
117
|
+
});
|
|
118
|
+
|
|
119
|
+
it("should give every listen() call its own controller", () => {
|
|
120
|
+
const listener = createListener<DataType>(socket, { delivery: { strategy: "batch", interval: 100 } });
|
|
121
|
+
const first = vi.fn();
|
|
122
|
+
const second = vi.fn();
|
|
123
|
+
const stopFirst = listener.listen(first);
|
|
124
|
+
listener.listen(second);
|
|
125
|
+
emitListenerEvent(listener, { price: 1 });
|
|
126
|
+
stopFirst();
|
|
127
|
+
vi.advanceTimersByTime(100);
|
|
128
|
+
expect(first).not.toHaveBeenCalled();
|
|
129
|
+
expect(second).toHaveBeenCalledOnce();
|
|
130
|
+
});
|
|
131
|
+
|
|
132
|
+
it("should carry delivery through setParams, setOptions and clone", () => {
|
|
133
|
+
const delivery = { strategy: "latest", interval: 16 } as const;
|
|
134
|
+
const listener = socket.createListener<DataType>()({ topic: "prices/:symbol", delivery });
|
|
135
|
+
expect(listener.setParams({ symbol: "BTC" }).delivery).toStrictEqual(delivery);
|
|
136
|
+
expect(listener.setOptions(undefined).delivery).toStrictEqual(delivery);
|
|
137
|
+
expect(listener.clone().delivery).toStrictEqual(delivery);
|
|
138
|
+
});
|
|
139
|
+
|
|
140
|
+
it("should return a clone from setDelivery and allow clearing it", () => {
|
|
141
|
+
const listener = createListener<DataType>(socket);
|
|
142
|
+
const batched = listener.setDelivery({ strategy: "batch", interval: 100 });
|
|
143
|
+
expect(batched).not.toBe(listener);
|
|
144
|
+
expect(listener.delivery).toBeUndefined();
|
|
145
|
+
expect(batched.delivery).toStrictEqual({ strategy: "batch", interval: 100 });
|
|
146
|
+
expect(batched.setDelivery(undefined).delivery).toBeUndefined();
|
|
147
|
+
});
|
|
148
|
+
|
|
149
|
+
it("should throw on an unknown strategy at creation time", () => {
|
|
150
|
+
expect(() =>
|
|
151
|
+
socket.createListener<DataType>()({ topic: "prices", delivery: { strategy: "nope", interval: 1 } as any }),
|
|
152
|
+
).toThrow(/Unknown delivery strategy/);
|
|
153
|
+
});
|
|
154
|
+
|
|
155
|
+
it("should wrap adapters that call the callback directly (Firebase-style)", () => {
|
|
156
|
+
const listener = createListener<DataType>(socket, { delivery: { strategy: "batch", interval: 100 } });
|
|
157
|
+
const spy = vi.fn();
|
|
158
|
+
listener.listen(({ data }) => spy(data));
|
|
159
|
+
const [registered] = [...socket.adapter.listeners.get(listener.topic)!.keys()];
|
|
160
|
+
|
|
161
|
+
// Simulate an adapter invoking the registered callback directly, bypassing triggerListeners.
|
|
162
|
+
registered({ data: { price: 1 }, extra: null as any });
|
|
163
|
+
registered({ data: { price: 2 }, extra: null as any });
|
|
164
|
+
expect(spy).not.toHaveBeenCalled();
|
|
165
|
+
vi.advanceTimersByTime(100);
|
|
166
|
+
expect(spy).toHaveBeenCalledWith([{ price: 1 }, { price: 2 }]);
|
|
167
|
+
});
|
|
168
|
+
|
|
169
|
+
it("should run onMessage interceptors per raw message before batching", () => {
|
|
170
|
+
const interceptor = vi.fn(({ event }) => event);
|
|
171
|
+
socket.onMessage(interceptor);
|
|
172
|
+
const listener = createListener<DataType>(socket, { delivery: { strategy: "batch", interval: 100 } });
|
|
173
|
+
listener.listen(() => null);
|
|
174
|
+
emitListenerEvent(listener, { price: 1 });
|
|
175
|
+
emitListenerEvent(listener, { price: 2 });
|
|
176
|
+
expect(interceptor).toHaveBeenCalledTimes(2);
|
|
177
|
+
});
|
|
178
|
+
|
|
179
|
+
it("should expose params on the listener", () => {
|
|
180
|
+
const listener = socket.createListener<DataType>()({ topic: "prices/:symbol" }).setParams({ symbol: "BTC" });
|
|
181
|
+
expect(listener.params).toStrictEqual({ symbol: "BTC" });
|
|
182
|
+
expect(listener.topic).toBe("prices/BTC");
|
|
183
|
+
});
|
|
184
|
+
|
|
185
|
+
it("should keep socket.events broadcasts unthrottled", () => {
|
|
186
|
+
const listener = createListener<DataType>(socket, { delivery: { strategy: "batch", interval: 100 } });
|
|
187
|
+
const callback = vi.fn();
|
|
188
|
+
const byTopic = vi.fn();
|
|
189
|
+
const global = vi.fn();
|
|
190
|
+
listener.listen(callback);
|
|
191
|
+
socket.events.onListenerEventByTopic(listener, byTopic);
|
|
192
|
+
socket.events.onListenerEvent(global);
|
|
193
|
+
|
|
194
|
+
emitListenerEvent(listener, { price: 1 });
|
|
195
|
+
emitListenerEvent(listener, { price: 2 });
|
|
196
|
+
emitListenerEvent(listener, { price: 3 });
|
|
197
|
+
|
|
198
|
+
expect(callback).not.toHaveBeenCalled();
|
|
199
|
+
expect(byTopic).toHaveBeenCalledTimes(3);
|
|
200
|
+
expect(global).toHaveBeenCalledTimes(3);
|
|
201
|
+
vi.advanceTimersByTime(100);
|
|
202
|
+
expect(callback).toHaveBeenCalledOnce();
|
|
203
|
+
});
|
|
204
|
+
|
|
205
|
+
it("should isolate delivery per dynamic topic", () => {
|
|
206
|
+
const template = socket.createListener<DataType>()({
|
|
207
|
+
topic: "prices/:symbol",
|
|
208
|
+
delivery: { strategy: "batch", interval: 100 },
|
|
209
|
+
});
|
|
210
|
+
const btc = template.setParams({ symbol: "BTC" });
|
|
211
|
+
const eth = template.setParams({ symbol: "ETH" });
|
|
212
|
+
const btcSpy = vi.fn();
|
|
213
|
+
const ethSpy = vi.fn();
|
|
214
|
+
btc.listen(({ data }) => btcSpy(data));
|
|
215
|
+
eth.listen(({ data }) => ethSpy(data));
|
|
216
|
+
|
|
217
|
+
emitListenerEvent(btc, { price: 1 });
|
|
218
|
+
emitListenerEvent(eth, { price: 10 });
|
|
219
|
+
emitListenerEvent(btc, { price: 2 });
|
|
220
|
+
vi.advanceTimersByTime(100);
|
|
221
|
+
|
|
222
|
+
expect(btcSpy).toHaveBeenCalledWith([{ price: 1 }, { price: 2 }]);
|
|
223
|
+
expect(ethSpy).toHaveBeenCalledWith([{ price: 10 }]);
|
|
224
|
+
});
|
|
225
|
+
|
|
226
|
+
it("should not affect listeners on other topics", () => {
|
|
227
|
+
const batched = createListener<DataType>(socket, { delivery: { strategy: "batch", interval: 100 } });
|
|
228
|
+
const immediate = createListener<DataType>(socket);
|
|
229
|
+
const batchedSpy = vi.fn();
|
|
230
|
+
const immediateSpy = vi.fn();
|
|
231
|
+
batched.listen(batchedSpy);
|
|
232
|
+
immediate.listen(immediateSpy);
|
|
233
|
+
|
|
234
|
+
emitListenerEvent(batched, { price: 1 });
|
|
235
|
+
emitListenerEvent(immediate, { price: 2 });
|
|
236
|
+
expect(batchedSpy).not.toHaveBeenCalled();
|
|
237
|
+
expect(immediateSpy).toHaveBeenCalledOnce();
|
|
238
|
+
});
|
|
239
|
+
|
|
240
|
+
it("should allow mixing immediate and delivered subscriptions on one topic", () => {
|
|
241
|
+
const listener = createListener<DataType>(socket);
|
|
242
|
+
const immediateSpy = vi.fn();
|
|
243
|
+
const batchedSpy = vi.fn();
|
|
244
|
+
listener.listen(immediateSpy);
|
|
245
|
+
listener.setDelivery({ strategy: "batch", interval: 100 }).listen(batchedSpy);
|
|
246
|
+
|
|
247
|
+
emitListenerEvent(listener, { price: 1 });
|
|
248
|
+
emitListenerEvent(listener, { price: 2 });
|
|
249
|
+
expect(immediateSpy).toHaveBeenCalledTimes(2);
|
|
250
|
+
expect(batchedSpy).not.toHaveBeenCalled();
|
|
251
|
+
vi.advanceTimersByTime(100);
|
|
252
|
+
expect(batchedSpy).toHaveBeenCalledOnce();
|
|
253
|
+
});
|
|
254
|
+
|
|
255
|
+
it("should create independent subscriptions for the same callback passed twice", () => {
|
|
256
|
+
const listener = createListener<DataType>(socket, { delivery: { strategy: "latest", interval: 100 } });
|
|
257
|
+
const spy = vi.fn();
|
|
258
|
+
const stopFirst = listener.listen(spy);
|
|
259
|
+
const stopSecond = listener.listen(spy);
|
|
260
|
+
expect(socket.adapter.listeners.get(listener.topic)?.size).toBe(2);
|
|
261
|
+
|
|
262
|
+
emitListenerEvent(listener, { price: 1 });
|
|
263
|
+
expect(spy).toHaveBeenCalledTimes(2);
|
|
264
|
+
|
|
265
|
+
stopFirst();
|
|
266
|
+
expect(socket.adapter.listeners.get(listener.topic)?.size).toBe(1);
|
|
267
|
+
emitListenerEvent(listener, { price: 2 });
|
|
268
|
+
vi.advanceTimersByTime(100);
|
|
269
|
+
expect(spy).toHaveBeenCalledTimes(3);
|
|
270
|
+
stopSecond();
|
|
271
|
+
expect(socket.adapter.listeners.get(listener.topic)?.size).toBe(0);
|
|
272
|
+
});
|
|
273
|
+
|
|
274
|
+
it("should unsubscribe safely from inside the callback", () => {
|
|
275
|
+
const listener = createListener<DataType>(socket, { delivery: { strategy: "batch", interval: 100 } });
|
|
276
|
+
const spy = vi.fn();
|
|
277
|
+
const stop = listener.listen(({ data }) => {
|
|
278
|
+
spy(data);
|
|
279
|
+
stop();
|
|
280
|
+
});
|
|
281
|
+
emitListenerEvent(listener, { price: 1 });
|
|
282
|
+
vi.advanceTimersByTime(100);
|
|
283
|
+
emitListenerEvent(listener, { price: 2 });
|
|
284
|
+
vi.advanceTimersByTime(100);
|
|
285
|
+
expect(spy).toHaveBeenCalledOnce();
|
|
286
|
+
expect(socket.adapter.listeners.get(listener.topic)?.size).toBe(0);
|
|
287
|
+
});
|
|
288
|
+
|
|
289
|
+
it("should handle a large burst with the latest strategy", () => {
|
|
290
|
+
const listener = createListener<DataType>(socket, { delivery: { strategy: "latest", interval: 16 } });
|
|
291
|
+
const spy = vi.fn();
|
|
292
|
+
listener.listen(({ data }) => spy(data));
|
|
293
|
+
for (let i = 1; i <= 500; i += 1) {
|
|
294
|
+
emitListenerEvent(listener, { price: i });
|
|
295
|
+
}
|
|
296
|
+
expect(spy).toHaveBeenCalledOnce();
|
|
297
|
+
vi.advanceTimersByTime(16);
|
|
298
|
+
expect(spy).toHaveBeenCalledTimes(2);
|
|
299
|
+
expect(spy).toHaveBeenLastCalledWith({ price: 500 });
|
|
300
|
+
});
|
|
301
|
+
|
|
302
|
+
it("should handle a large burst with the batch strategy and maxSize", () => {
|
|
303
|
+
const listener = createListener<DataType>(socket, {
|
|
304
|
+
delivery: { strategy: "batch", interval: 100, maxSize: 100 },
|
|
305
|
+
});
|
|
306
|
+
const spy = vi.fn();
|
|
307
|
+
listener.listen(({ data }) => spy(data));
|
|
308
|
+
for (let i = 1; i <= 250; i += 1) {
|
|
309
|
+
emitListenerEvent(listener, { price: i });
|
|
310
|
+
}
|
|
311
|
+
expect(spy).toHaveBeenCalledTimes(2);
|
|
312
|
+
vi.advanceTimersByTime(100);
|
|
313
|
+
expect(spy).toHaveBeenCalledTimes(3);
|
|
314
|
+
const all = spy.mock.calls.flatMap(([batch]) => batch.map((m: DataType) => m.price));
|
|
315
|
+
expect(all).toEqual(Array.from({ length: 250 }, (_, i) => i + 1));
|
|
316
|
+
});
|
|
317
|
+
|
|
318
|
+
it("should expose delivery on listenerOptions and keep options untouched", () => {
|
|
319
|
+
const delivery = { strategy: "batch", interval: 100 } as const;
|
|
320
|
+
const listener = createListener<DataType>(socket, { delivery });
|
|
321
|
+
expect(listener.listenerOptions.delivery).toStrictEqual(delivery);
|
|
322
|
+
expect(listener.options).toBeUndefined();
|
|
323
|
+
expect(listener.setOptions({ anything: true } as any).delivery).toStrictEqual(delivery);
|
|
324
|
+
});
|
|
325
|
+
|
|
326
|
+
it("should allow overriding delivery through clone", () => {
|
|
327
|
+
const listener = createListener<DataType>(socket, { delivery: { strategy: "batch", interval: 100 } });
|
|
328
|
+
const cloned = listener.clone({ delivery: { strategy: "latest", interval: 16 } });
|
|
329
|
+
expect(cloned.delivery).toStrictEqual({ strategy: "latest", interval: 16 });
|
|
330
|
+
expect(listener.delivery).toStrictEqual({ strategy: "batch", interval: 100 });
|
|
331
|
+
});
|
|
332
|
+
|
|
333
|
+
it("should accept a custom strategy through setDelivery", () => {
|
|
334
|
+
const listener = createListener<DataType>(socket);
|
|
335
|
+
const passthrough = createDeliveryStrategy<DataType, number>(({ deliver }) => ({
|
|
336
|
+
push: ({ data, extra }) => deliver({ data: data.price * 2, extra }),
|
|
337
|
+
dispose: () => null,
|
|
338
|
+
}));
|
|
339
|
+
const spy = vi.fn();
|
|
340
|
+
listener.setDelivery(passthrough).listen(({ data }) => spy(data));
|
|
341
|
+
emitListenerEvent(listener, { price: 21 });
|
|
342
|
+
expect(spy).toHaveBeenCalledWith(42);
|
|
343
|
+
});
|
|
344
|
+
|
|
345
|
+
it("should call a custom strategy factory once per listen()", () => {
|
|
346
|
+
const factory = vi.fn((_context: unknown) => ({ push: vi.fn(), dispose: vi.fn() }));
|
|
347
|
+
const listener = createListener<DataType>(socket, { delivery: factory as any });
|
|
348
|
+
const stopA = listener.listen(() => null);
|
|
349
|
+
const stopB = listener.listen(() => null);
|
|
350
|
+
expect(factory).toHaveBeenCalledTimes(2);
|
|
351
|
+
expect(factory.mock.calls[0][0]).toHaveProperty("deliver");
|
|
352
|
+
stopA();
|
|
353
|
+
stopB();
|
|
354
|
+
expect(factory.mock.results[0].value.dispose).toHaveBeenCalledOnce();
|
|
355
|
+
expect(factory.mock.results[1].value.dispose).toHaveBeenCalledOnce();
|
|
356
|
+
});
|
|
357
|
+
|
|
358
|
+
it("should restore immediate delivery after setDelivery(undefined)", () => {
|
|
359
|
+
const listener = createListener<DataType>(socket, { delivery: { strategy: "batch", interval: 100 } });
|
|
360
|
+
const spy = vi.fn();
|
|
361
|
+
listener.setDelivery(undefined).listen(spy);
|
|
362
|
+
emitListenerEvent(listener, { price: 1 });
|
|
363
|
+
expect(spy).toHaveBeenCalledOnce();
|
|
364
|
+
expect(socket.adapter.listeners.get(listener.topic)?.has(spy)).toBeTrue();
|
|
365
|
+
});
|
|
366
|
+
|
|
367
|
+
it("should keep delivering after the socket reconnects", async () => {
|
|
368
|
+
vi.useRealTimers();
|
|
369
|
+
const listener = createListener<DataType>(socket, { delivery: { strategy: "batch", interval: 20 } });
|
|
370
|
+
const spy = vi.fn();
|
|
371
|
+
listener.listen(({ data }) => spy(data));
|
|
372
|
+
|
|
373
|
+
socket.disconnect();
|
|
374
|
+
socket.connect();
|
|
375
|
+
await waitForConnection(socket);
|
|
376
|
+
|
|
377
|
+
emitListenerEvent(listener, { price: 1 });
|
|
378
|
+
emitListenerEvent(listener, { price: 2 });
|
|
379
|
+
await new Promise((resolve) => {
|
|
380
|
+
setTimeout(resolve, 60);
|
|
381
|
+
});
|
|
382
|
+
expect(spy).toHaveBeenCalledOnce();
|
|
383
|
+
expect(spy).toHaveBeenCalledWith([{ price: 1 }, { price: 2 }]);
|
|
384
|
+
});
|
|
385
|
+
});
|
|
@@ -0,0 +1,55 @@
|
|
|
1
|
+
import { createSseMockingServer, waitForConnection } from "@hyper-fetch/testing";
|
|
2
|
+
import { ServerSentEventsAdapter } from "adapter-sse/sse-adapter";
|
|
3
|
+
|
|
4
|
+
import { createListener } from "../../utils/listener.utils";
|
|
5
|
+
import { createSocket } from "../../utils/socket.utils";
|
|
6
|
+
|
|
7
|
+
type DataType = { price: number };
|
|
8
|
+
|
|
9
|
+
describe("Listener [ Delivery SSE ]", () => {
|
|
10
|
+
const { startServer, emitListenerEvent } = createSseMockingServer();
|
|
11
|
+
let socket = createSocket({ adapter: ServerSentEventsAdapter });
|
|
12
|
+
|
|
13
|
+
beforeEach(async () => {
|
|
14
|
+
socket = createSocket({ adapter: ServerSentEventsAdapter });
|
|
15
|
+
startServer();
|
|
16
|
+
await waitForConnection(socket);
|
|
17
|
+
vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
|
|
18
|
+
});
|
|
19
|
+
|
|
20
|
+
afterEach(() => {
|
|
21
|
+
vi.useRealTimers();
|
|
22
|
+
});
|
|
23
|
+
|
|
24
|
+
it("should batch SSE messages", () => {
|
|
25
|
+
const listener = createListener<DataType>(socket, { delivery: { strategy: "batch", interval: 100 } });
|
|
26
|
+
const spy = vi.fn();
|
|
27
|
+
listener.listen(({ data }) => spy(data));
|
|
28
|
+
emitListenerEvent(listener, { price: 1 });
|
|
29
|
+
emitListenerEvent(listener, { price: 2 });
|
|
30
|
+
expect(spy).not.toHaveBeenCalled();
|
|
31
|
+
vi.advanceTimersByTime(100);
|
|
32
|
+
expect(spy).toHaveBeenCalledWith([{ price: 1 }, { price: 2 }]);
|
|
33
|
+
});
|
|
34
|
+
|
|
35
|
+
it("should sample SSE messages", () => {
|
|
36
|
+
const listener = createListener<DataType>(socket, { delivery: { strategy: "latest", interval: 100 } });
|
|
37
|
+
const spy = vi.fn();
|
|
38
|
+
listener.listen(({ data }) => spy(data));
|
|
39
|
+
emitListenerEvent(listener, { price: 1 });
|
|
40
|
+
emitListenerEvent(listener, { price: 2 });
|
|
41
|
+
expect(spy).toHaveBeenCalledWith({ price: 1 });
|
|
42
|
+
vi.advanceTimersByTime(100);
|
|
43
|
+
expect(spy).toHaveBeenLastCalledWith({ price: 2 });
|
|
44
|
+
});
|
|
45
|
+
|
|
46
|
+
it("should drop pending SSE messages on unsubscribe", () => {
|
|
47
|
+
const listener = createListener<DataType>(socket, { delivery: { strategy: "batch", interval: 100 } });
|
|
48
|
+
const spy = vi.fn();
|
|
49
|
+
const stop = listener.listen(spy);
|
|
50
|
+
emitListenerEvent(listener, { price: 1 });
|
|
51
|
+
stop();
|
|
52
|
+
vi.advanceTimersByTime(100);
|
|
53
|
+
expect(spy).not.toHaveBeenCalled();
|
|
54
|
+
});
|
|
55
|
+
});
|
|
@@ -107,6 +107,66 @@ describe("Socket SDK [ Configuration ]", () => {
|
|
|
107
107
|
});
|
|
108
108
|
});
|
|
109
109
|
|
|
110
|
+
describe("delivery defaults", () => {
|
|
111
|
+
it("should apply delivery via plain object to listeners only", () => {
|
|
112
|
+
const sdk = createSocketSdk<TestSocket, TestSchema>(socket);
|
|
113
|
+
const configured = sdk.$configure({
|
|
114
|
+
"*": { delivery: { strategy: "batch", interval: 100 } },
|
|
115
|
+
});
|
|
116
|
+
|
|
117
|
+
expect(configured.chat.messages.$listener.delivery).toStrictEqual({ strategy: "batch", interval: 100 });
|
|
118
|
+
expect(configured.notifications.$listener.delivery).toStrictEqual({ strategy: "batch", interval: 100 });
|
|
119
|
+
expect((configured.chat.messages.$emitter as any).delivery).toBeUndefined();
|
|
120
|
+
});
|
|
121
|
+
|
|
122
|
+
it("should apply delivery together with options", () => {
|
|
123
|
+
const sdk = createSocketSdk<TestSocket, TestSchema>(socket);
|
|
124
|
+
const configured = sdk.$configure({
|
|
125
|
+
"chat/messages": { options: { fast: true }, delivery: { strategy: "latest", interval: 16 } },
|
|
126
|
+
});
|
|
127
|
+
|
|
128
|
+
const listener = configured.chat.messages.$listener;
|
|
129
|
+
expect(listener.options).toStrictEqual({ fast: true });
|
|
130
|
+
expect(listener.delivery).toStrictEqual({ strategy: "latest", interval: 16 });
|
|
131
|
+
expect(configured.notifications.$listener.delivery).toBeUndefined();
|
|
132
|
+
});
|
|
133
|
+
});
|
|
134
|
+
|
|
135
|
+
describe("delivery via function configuration", () => {
|
|
136
|
+
it("should allow setDelivery inside a function configuration", () => {
|
|
137
|
+
const sdk = createSocketSdk<TestSocket, TestSchema>(socket);
|
|
138
|
+
const configured = sdk.$configure({
|
|
139
|
+
"chat.messages.$listener": (instance) =>
|
|
140
|
+
"setDelivery" in instance ? instance.setDelivery({ strategy: "latest", interval: 16 }) : instance,
|
|
141
|
+
});
|
|
142
|
+
expect(configured.chat.messages.$listener.delivery).toStrictEqual({ strategy: "latest", interval: 16 });
|
|
143
|
+
expect(configured.chat.rooms.$listener.delivery).toBeUndefined();
|
|
144
|
+
});
|
|
145
|
+
|
|
146
|
+
it("should apply delivery on a topic prefix", () => {
|
|
147
|
+
const sdk = createSocketSdk<TestSocket, TestSchema>(socket);
|
|
148
|
+
const configured = sdk.$configure({
|
|
149
|
+
"chat/*": { delivery: { strategy: "batch", interval: 50 } },
|
|
150
|
+
});
|
|
151
|
+
expect(configured.chat.messages.$listener.delivery).toStrictEqual({ strategy: "batch", interval: 50 });
|
|
152
|
+
expect(configured.chat.rooms.$listener.delivery).toStrictEqual({ strategy: "batch", interval: 50 });
|
|
153
|
+
expect(configured.notifications.$listener.delivery).toBeUndefined();
|
|
154
|
+
});
|
|
155
|
+
|
|
156
|
+
it("should keep listeners working after SDK delivery configuration", () => {
|
|
157
|
+
const sdk = createSocketSdk<TestSocket, TestSchema>(socket);
|
|
158
|
+
const configured = sdk.$configure({
|
|
159
|
+
"*": { delivery: { strategy: "batch", interval: 100 } },
|
|
160
|
+
});
|
|
161
|
+
const listener = configured.notifications.$listener;
|
|
162
|
+
const spy = vi.fn();
|
|
163
|
+
const stop = listener.listen(spy);
|
|
164
|
+
expect(socket.adapter.listeners.get(listener.topic)?.size).toBe(1);
|
|
165
|
+
stop();
|
|
166
|
+
expect(socket.adapter.listeners.get(listener.topic)?.size).toBe(0);
|
|
167
|
+
});
|
|
168
|
+
});
|
|
169
|
+
|
|
110
170
|
describe("topic group matching", () => {
|
|
111
171
|
it("should apply config to an exact topic", () => {
|
|
112
172
|
const sdk = createSocketSdk<TestSocket, TestSchema>(socket);
|