@hyper-fetch/sockets 7.5.2 → 8.0.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/.eslintrc.cjs +12 -0
- package/__tests__/features/adapter/adapter.base.spec.ts +80 -0
- package/__tests__/features/adapter/adapter.bindings.spec.ts +81 -0
- package/__tests__/features/adapter/adapter.connection.spec.ts +70 -0
- package/__tests__/features/adapter/adapter.error.spec.ts +127 -0
- package/__tests__/features/adapter/adapter.sse.connection.spec.ts +67 -0
- package/__tests__/features/adapter/adapter.sse.spec.ts +284 -0
- package/__tests__/features/adapter/adapter.websocket.heartbeat.spec.ts +62 -0
- package/__tests__/features/adapter/adapter.websocket.spec.ts +254 -0
- package/__tests__/features/emitter/emitter.base.spec.ts +63 -0
- package/__tests__/features/emitter/emitter.emit.spec.ts +43 -0
- package/__tests__/features/listener/listener.base.spec.ts +35 -0
- package/__tests__/features/listener/listener.listen.spec.ts +68 -0
- package/__tests__/features/listener/listener.sse.spec.ts +80 -0
- package/__tests__/features/listener/listener.typescript.spec.ts +31 -0
- package/__tests__/features/socket/socket.base.spec.ts +154 -0
- package/__tests__/features/socket/socket.callbacks.spec.ts +90 -0
- package/__tests__/features/socket/socket.events.spec.ts +183 -0
- package/__tests__/features/socket/socket.methods.spec.ts +52 -0
- package/__tests__/features/socket/socket.misc.spec.ts +85 -0
- package/__tests__/features/socket/socket.utils.spec.ts +30 -0
- package/__tests__/tsconfig.json +24 -0
- package/__tests__/utils/client.utils.ts +8 -0
- package/__tests__/utils/emitter.utils.ts +15 -0
- package/__tests__/utils/listener.utils.ts +13 -0
- package/__tests__/utils/socket.utils.ts +10 -0
- package/__tests__/vitest.setup.ts +12 -0
- package/dist/adapter/adapter.bindings.d.ts +40 -0
- package/dist/adapter/adapter.bindings.d.ts.map +1 -0
- package/dist/adapter/adapter.d.ts +75 -0
- package/dist/adapter/adapter.d.ts.map +1 -0
- package/dist/adapter/adapter.types.d.ts +13 -0
- package/dist/adapter/adapter.types.d.ts.map +1 -0
- package/dist/adapter/index.d.ts +8 -0
- package/dist/adapter/index.d.ts.map +1 -0
- package/dist/adapter-sse/index.d.ts +4 -0
- package/dist/adapter-sse/index.d.ts.map +1 -0
- package/dist/adapter-sse/sse-adapter.d.ts +11 -0
- package/dist/adapter-sse/sse-adapter.d.ts.map +1 -0
- package/dist/adapter-sse/sse-adapter.types.d.ts +5 -0
- package/dist/adapter-sse/sse-adapter.types.d.ts.map +1 -0
- package/dist/adapter-sse/sse-adapter.utils.d.ts +26 -0
- package/dist/adapter-sse/sse-adapter.utils.d.ts.map +1 -0
- package/dist/adapter-websockets/index.d.ts +4 -0
- package/dist/adapter-websockets/index.d.ts.map +1 -0
- package/dist/adapter-websockets/websocket-adapter.d.ts +11 -0
- package/dist/adapter-websockets/websocket-adapter.d.ts.map +1 -0
- package/dist/adapter-websockets/websocket-adapter.types.d.ts +9 -0
- package/dist/adapter-websockets/websocket-adapter.types.d.ts.map +1 -0
- package/dist/adapter-websockets/websocket-adapter.utils.d.ts +32 -0
- package/dist/adapter-websockets/websocket-adapter.utils.d.ts.map +1 -0
- package/dist/emitter/emitter.d.ts +28 -0
- package/dist/emitter/emitter.d.ts.map +1 -0
- package/dist/emitter/emitter.types.d.ts +51 -0
- package/dist/emitter/emitter.types.d.ts.map +1 -0
- package/dist/emitter/index.d.ts +3 -0
- package/dist/emitter/index.d.ts.map +1 -0
- package/dist/index.d.ts +9 -682
- package/dist/index.d.ts.map +1 -0
- package/dist/index.mjs +1425 -0
- package/dist/index.mjs.map +1 -0
- package/dist/listener/index.d.ts +3 -0
- package/dist/listener/index.d.ts.map +1 -0
- package/dist/listener/listener.d.ts +18 -0
- package/dist/listener/listener.d.ts.map +1 -0
- package/dist/listener/listener.types.d.ts +37 -0
- package/dist/listener/listener.types.d.ts.map +1 -0
- package/dist/socket/index.d.ts +5 -0
- package/dist/socket/index.d.ts.map +1 -0
- package/dist/socket/socket.d.ts +205 -0
- package/dist/socket/socket.d.ts.map +1 -0
- package/dist/socket/socket.events.d.ts +81 -0
- package/dist/socket/socket.events.d.ts.map +1 -0
- package/dist/socket/socket.types.d.ts +27 -0
- package/dist/socket/socket.types.d.ts.map +1 -0
- package/dist/socket/socket.utils.d.ts +25 -0
- package/dist/socket/socket.utils.d.ts.map +1 -0
- package/dist/types/connect.types.d.ts +4 -0
- package/dist/types/connect.types.d.ts.map +1 -0
- package/dist/types/extract.types.d.ts +30 -0
- package/dist/types/extract.types.d.ts.map +1 -0
- package/dist/types/index.d.ts +4 -0
- package/dist/types/index.d.ts.map +1 -0
- package/dist/types/tuple.types.d.ts +2 -0
- package/dist/types/tuple.types.d.ts.map +1 -0
- package/dist/utils/index.d.ts +4 -0
- package/dist/utils/index.d.ts.map +1 -0
- package/dist/utils/message-event.utils.d.ts +8 -0
- package/dist/utils/message-event.utils.d.ts.map +1 -0
- package/dist/utils/socket.errors.d.ts +2 -0
- package/dist/utils/socket.errors.d.ts.map +1 -0
- package/dist/utils/socket.utils.d.ts +2 -0
- package/dist/utils/socket.utils.d.ts.map +1 -0
- package/package.json +7 -10
- package/project.json +4 -0
- package/src/adapter/adapter.bindings.ts +6 -6
- package/src/adapter/adapter.ts +13 -10
- package/src/adapter/adapter.types.ts +4 -7
- package/src/adapter-sse/sse-adapter.ts +6 -6
- package/src/adapter-sse/sse-adapter.utils.ts +2 -2
- package/src/adapter-websockets/websocket-adapter.ts +7 -7
- package/src/adapter-websockets/websocket-adapter.utils.ts +2 -2
- package/src/emitter/emitter.ts +4 -4
- package/src/emitter/emitter.types.ts +6 -5
- package/src/listener/listener.ts +4 -4
- package/src/listener/listener.types.ts +8 -5
- package/src/socket/socket.events.ts +5 -5
- package/src/socket/socket.ts +12 -10
- package/src/socket/socket.types.ts +4 -4
- package/src/socket/socket.utils.ts +2 -2
- package/src/types/connect.types.ts +2 -2
- package/src/types/extract.types.ts +5 -5
- package/tsconfig.json +1 -1
- package/vite.config.ts +45 -0
- package/.eslintrc.json +0 -11
- package/dist/index.js +0 -1236
- package/dist/index.js.map +0 -7
|
@@ -0,0 +1,284 @@
|
|
|
1
|
+
/* eslint-disable max-classes-per-file */
|
|
2
|
+
import { waitFor } from "@testing-library/dom";
|
|
3
|
+
import { createSseMockingServer, sleep } from "@hyper-fetch/testing";
|
|
4
|
+
|
|
5
|
+
import { createSocket } from "../../utils/socket.utils";
|
|
6
|
+
import type { ServerSentEventsAdapterType } from "adapter-sse/sse-adapter";
|
|
7
|
+
import { ServerSentEventsAdapter } from "adapter-sse/sse-adapter";
|
|
8
|
+
import { getServerSentEventsAdapter } from "../../../src/adapter-sse/sse-adapter.utils";
|
|
9
|
+
|
|
10
|
+
const socketOptions: Parameters<typeof createSocket>[0] = {
|
|
11
|
+
adapter: ServerSentEventsAdapter,
|
|
12
|
+
adapterOptions: { eventSourceInit: { withCredentials: true } },
|
|
13
|
+
};
|
|
14
|
+
|
|
15
|
+
describe("Socket Adapter [ SSE ]", () => {
|
|
16
|
+
const { startServer, emitError } = createSseMockingServer();
|
|
17
|
+
let socket = createSocket<ServerSentEventsAdapterType>(socketOptions);
|
|
18
|
+
let originalEventSource: typeof EventSource;
|
|
19
|
+
|
|
20
|
+
beforeEach(async () => {
|
|
21
|
+
socket = createSocket<ServerSentEventsAdapterType>(socketOptions);
|
|
22
|
+
originalEventSource = window.EventSource;
|
|
23
|
+
vi.resetAllMocks();
|
|
24
|
+
});
|
|
25
|
+
|
|
26
|
+
afterEach(() => {
|
|
27
|
+
window.EventSource = originalEventSource;
|
|
28
|
+
});
|
|
29
|
+
|
|
30
|
+
it("should emit event on disconnect", async () => {
|
|
31
|
+
startServer();
|
|
32
|
+
|
|
33
|
+
const spy = vi.fn();
|
|
34
|
+
socket.onDisconnected(spy);
|
|
35
|
+
expect(socket.adapter.connected).toBe(true);
|
|
36
|
+
socket.adapter.disconnect();
|
|
37
|
+
await waitFor(() => {
|
|
38
|
+
expect(spy).toHaveBeenCalledTimes(1);
|
|
39
|
+
});
|
|
40
|
+
});
|
|
41
|
+
|
|
42
|
+
it("should throw error when emitting", async () => {
|
|
43
|
+
startServer();
|
|
44
|
+
|
|
45
|
+
expect(() => socket.adapter.emit({} as any)).rejects.toThrow();
|
|
46
|
+
});
|
|
47
|
+
|
|
48
|
+
it("should reconnect when going online", async () => {
|
|
49
|
+
const spy = vi.fn();
|
|
50
|
+
socket.events.onConnected(spy);
|
|
51
|
+
|
|
52
|
+
startServer();
|
|
53
|
+
|
|
54
|
+
// Wait for initial connection
|
|
55
|
+
await waitFor(() => {
|
|
56
|
+
expect(spy).toHaveBeenCalledTimes(1);
|
|
57
|
+
});
|
|
58
|
+
|
|
59
|
+
// Simulate going offline and disconnecting
|
|
60
|
+
socket.appManager.setOnline(false);
|
|
61
|
+
socket.adapter.disconnect();
|
|
62
|
+
|
|
63
|
+
// Wait for disconnect to complete
|
|
64
|
+
await waitFor(() => {
|
|
65
|
+
expect(socket.adapter.connected).toBe(false);
|
|
66
|
+
});
|
|
67
|
+
|
|
68
|
+
// Simulate going back online
|
|
69
|
+
socket.appManager.setOnline(true);
|
|
70
|
+
startServer();
|
|
71
|
+
|
|
72
|
+
// Should reconnect automatically
|
|
73
|
+
await waitFor(() => {
|
|
74
|
+
expect(spy).toHaveBeenCalledTimes(2);
|
|
75
|
+
expect(socket.adapter.connected).toBe(true);
|
|
76
|
+
});
|
|
77
|
+
});
|
|
78
|
+
|
|
79
|
+
it("should not reconnect when connection is open", async () => {
|
|
80
|
+
const spy = vi.fn();
|
|
81
|
+
|
|
82
|
+
socket.events.onConnected(spy);
|
|
83
|
+
|
|
84
|
+
startServer();
|
|
85
|
+
|
|
86
|
+
await waitFor(() => {
|
|
87
|
+
expect(spy).toHaveBeenCalledTimes(1);
|
|
88
|
+
});
|
|
89
|
+
|
|
90
|
+
socket.appManager.setOnline(true);
|
|
91
|
+
startServer();
|
|
92
|
+
|
|
93
|
+
await waitFor(() => {
|
|
94
|
+
expect(spy).toHaveBeenCalledTimes(2);
|
|
95
|
+
});
|
|
96
|
+
});
|
|
97
|
+
|
|
98
|
+
it("should not connect again when connection is open", async () => {
|
|
99
|
+
const spy = vi.fn();
|
|
100
|
+
|
|
101
|
+
socket.events.onConnected(spy);
|
|
102
|
+
startServer();
|
|
103
|
+
socket.adapter.connect();
|
|
104
|
+
|
|
105
|
+
await waitFor(() => {
|
|
106
|
+
expect(spy).toHaveBeenCalledTimes(1);
|
|
107
|
+
});
|
|
108
|
+
|
|
109
|
+
await socket.adapter.connect();
|
|
110
|
+
|
|
111
|
+
await waitFor(() => {
|
|
112
|
+
expect(spy).toHaveBeenCalledTimes(1);
|
|
113
|
+
});
|
|
114
|
+
});
|
|
115
|
+
|
|
116
|
+
it("should emit and receive error event", async () => {
|
|
117
|
+
const spy = vi.fn();
|
|
118
|
+
socket.events.onError(spy);
|
|
119
|
+
emitError({
|
|
120
|
+
code: 1000,
|
|
121
|
+
reason: "Test error",
|
|
122
|
+
wasClean: false,
|
|
123
|
+
});
|
|
124
|
+
|
|
125
|
+
await waitFor(() => {
|
|
126
|
+
expect(spy).toHaveBeenCalledTimes(1);
|
|
127
|
+
expect(spy).toHaveBeenCalledWith({
|
|
128
|
+
error: new Error(
|
|
129
|
+
"Normal closure, meaning that the purpose for which the connection was established has been fulfilled.",
|
|
130
|
+
),
|
|
131
|
+
});
|
|
132
|
+
});
|
|
133
|
+
});
|
|
134
|
+
|
|
135
|
+
it("should handle missing EventSource gracefully", async () => {
|
|
136
|
+
const eventSource = window.EventSource;
|
|
137
|
+
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
|
|
138
|
+
// @ts-ignore-error
|
|
139
|
+
window.EventSource = undefined;
|
|
140
|
+
|
|
141
|
+
const spy = vi.fn();
|
|
142
|
+
const newSocket = createSocket<ServerSentEventsAdapterType>(socketOptions);
|
|
143
|
+
newSocket.events.onConnected(spy);
|
|
144
|
+
|
|
145
|
+
const promise = await newSocket.adapter.connect();
|
|
146
|
+
|
|
147
|
+
expect(promise).toBe(false);
|
|
148
|
+
|
|
149
|
+
await waitFor(() => {
|
|
150
|
+
expect(spy).not.toHaveBeenCalled();
|
|
151
|
+
expect(newSocket.adapter.connected).toBe(false);
|
|
152
|
+
});
|
|
153
|
+
|
|
154
|
+
window.EventSource = eventSource;
|
|
155
|
+
});
|
|
156
|
+
|
|
157
|
+
it("should handle disconnect before connection is established gracefully", async () => {
|
|
158
|
+
const spy = vi.fn();
|
|
159
|
+
const newSocket = createSocket<ServerSentEventsAdapterType>({
|
|
160
|
+
adapter: ServerSentEventsAdapter(),
|
|
161
|
+
adapterOptions: {
|
|
162
|
+
autoConnect: false,
|
|
163
|
+
},
|
|
164
|
+
});
|
|
165
|
+
newSocket.events.onConnected(spy);
|
|
166
|
+
|
|
167
|
+
await expect(newSocket.adapter.disconnect()).resolves.toBe(true);
|
|
168
|
+
});
|
|
169
|
+
|
|
170
|
+
it("should resolve immediately when EventSource is already in OPEN state", async () => {
|
|
171
|
+
class OpenEventSource extends EventSource {
|
|
172
|
+
constructor(url: string, eventSourceInitDict?: EventSourceInit) {
|
|
173
|
+
super(url, eventSourceInitDict);
|
|
174
|
+
Object.defineProperty(this, "readyState", {
|
|
175
|
+
get: () => EventSource.OPEN,
|
|
176
|
+
});
|
|
177
|
+
}
|
|
178
|
+
}
|
|
179
|
+
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
|
|
180
|
+
// @ts-ignore-error
|
|
181
|
+
window.EventSource = OpenEventSource;
|
|
182
|
+
|
|
183
|
+
const newSocket = createSocket<ServerSentEventsAdapterType>({
|
|
184
|
+
...socketOptions,
|
|
185
|
+
adapterOptions: { autoConnect: false },
|
|
186
|
+
});
|
|
187
|
+
|
|
188
|
+
const result = await newSocket.adapter.connect();
|
|
189
|
+
|
|
190
|
+
expect(result).toBe(true);
|
|
191
|
+
expect(newSocket.adapter.connected).toBe(true);
|
|
192
|
+
expect(newSocket.adapter.connecting).toBe(false);
|
|
193
|
+
});
|
|
194
|
+
|
|
195
|
+
it("should resolve immediately when EventSource is already in CLOSED state", async () => {
|
|
196
|
+
class OpenEventSource extends EventSource {
|
|
197
|
+
constructor(url: string, eventSourceInitDict?: EventSourceInit) {
|
|
198
|
+
super(url, eventSourceInitDict);
|
|
199
|
+
Object.defineProperty(this, "readyState", {
|
|
200
|
+
get: () => EventSource.CLOSED,
|
|
201
|
+
set: () => {},
|
|
202
|
+
});
|
|
203
|
+
}
|
|
204
|
+
}
|
|
205
|
+
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
|
|
206
|
+
// @ts-ignore-error
|
|
207
|
+
window.EventSource = OpenEventSource;
|
|
208
|
+
|
|
209
|
+
const newSocket = createSocket<ServerSentEventsAdapterType>(socketOptions);
|
|
210
|
+
|
|
211
|
+
const result = await newSocket.adapter.disconnect();
|
|
212
|
+
|
|
213
|
+
expect(result).toBe(true);
|
|
214
|
+
expect(newSocket.adapter.connected).toBe(false);
|
|
215
|
+
expect(newSocket.adapter.connecting).toBe(false);
|
|
216
|
+
});
|
|
217
|
+
|
|
218
|
+
it("should respect autoConnect setting when going online", async () => {
|
|
219
|
+
const spy = vi.fn();
|
|
220
|
+
const socketWithoutAutoConnect = createSocket<ServerSentEventsAdapterType>({
|
|
221
|
+
adapter: ServerSentEventsAdapter,
|
|
222
|
+
adapterOptions: {
|
|
223
|
+
eventSourceInit: { withCredentials: true },
|
|
224
|
+
autoConnect: false,
|
|
225
|
+
},
|
|
226
|
+
});
|
|
227
|
+
|
|
228
|
+
socketWithoutAutoConnect.events.onConnected(spy);
|
|
229
|
+
startServer();
|
|
230
|
+
|
|
231
|
+
// Simulate offline/online cycle
|
|
232
|
+
socketWithoutAutoConnect.appManager.setOnline(false);
|
|
233
|
+
socketWithoutAutoConnect.adapter.disconnect();
|
|
234
|
+
socketWithoutAutoConnect.appManager.setOnline(true);
|
|
235
|
+
|
|
236
|
+
// Give it some time to potentially reconnect
|
|
237
|
+
await new Promise((resolve) => {
|
|
238
|
+
setTimeout(resolve, 100);
|
|
239
|
+
});
|
|
240
|
+
|
|
241
|
+
expect(spy).not.toHaveBeenCalled();
|
|
242
|
+
expect(socketWithoutAutoConnect.adapter.connected).toBe(false);
|
|
243
|
+
});
|
|
244
|
+
|
|
245
|
+
it("should return null from getServerSentEventsAdapter when window access throws", () => {
|
|
246
|
+
const originalWindow = global.window;
|
|
247
|
+
Object.defineProperty(global, "window", {
|
|
248
|
+
get() {
|
|
249
|
+
throw new ReferenceError("window is not defined");
|
|
250
|
+
},
|
|
251
|
+
configurable: true,
|
|
252
|
+
});
|
|
253
|
+
|
|
254
|
+
const result = getServerSentEventsAdapter("http://localhost:1234", {} as any);
|
|
255
|
+
expect(result).toBeNull();
|
|
256
|
+
|
|
257
|
+
Object.defineProperty(global, "window", {
|
|
258
|
+
value: originalWindow,
|
|
259
|
+
writable: true,
|
|
260
|
+
configurable: true,
|
|
261
|
+
});
|
|
262
|
+
});
|
|
263
|
+
|
|
264
|
+
it("should properly clean up error event listeners on disconnect", async () => {
|
|
265
|
+
const errorSpy = vi.fn();
|
|
266
|
+
socket.events.onError(errorSpy);
|
|
267
|
+
|
|
268
|
+
// Disconnect and verify cleanup
|
|
269
|
+
socket.adapter.disconnect();
|
|
270
|
+
|
|
271
|
+
// Emit error after disconnect
|
|
272
|
+
emitError({
|
|
273
|
+
code: 1000,
|
|
274
|
+
reason: "Test error",
|
|
275
|
+
wasClean: false,
|
|
276
|
+
});
|
|
277
|
+
|
|
278
|
+
// Give time for any potential error events
|
|
279
|
+
await sleep(10);
|
|
280
|
+
|
|
281
|
+
expect(errorSpy).toHaveBeenCalled();
|
|
282
|
+
expect(socket.adapter.connected).toBe(false);
|
|
283
|
+
});
|
|
284
|
+
});
|
|
@@ -0,0 +1,62 @@
|
|
|
1
|
+
import { waitFor } from "@testing-library/dom";
|
|
2
|
+
import { createWebsocketMockingServer } from "@hyper-fetch/testing";
|
|
3
|
+
|
|
4
|
+
import { createSocket } from "../../utils/socket.utils";
|
|
5
|
+
|
|
6
|
+
const socketOptions: Parameters<typeof createSocket>[0] = {
|
|
7
|
+
adapterOptions: {
|
|
8
|
+
heartbeat: true,
|
|
9
|
+
heartbeatMessage: "Test Heartbeat",
|
|
10
|
+
pingTimeout: 10,
|
|
11
|
+
pongTimeout: 10,
|
|
12
|
+
},
|
|
13
|
+
};
|
|
14
|
+
|
|
15
|
+
describe("Socket Adapter [ Heartbeat ]", () => {
|
|
16
|
+
const { getServer, startServer } = createWebsocketMockingServer();
|
|
17
|
+
let socket: ReturnType<typeof createSocket>;
|
|
18
|
+
let server: ReturnType<typeof getServer>;
|
|
19
|
+
|
|
20
|
+
beforeEach(async () => {
|
|
21
|
+
startServer();
|
|
22
|
+
server = getServer();
|
|
23
|
+
socket = createSocket(socketOptions);
|
|
24
|
+
vi.resetAllMocks();
|
|
25
|
+
});
|
|
26
|
+
|
|
27
|
+
it("should send heartbeat to server", async () => {
|
|
28
|
+
await expect(server).toReceiveMessage(
|
|
29
|
+
JSON.stringify({
|
|
30
|
+
topic: "heartbeat",
|
|
31
|
+
data: socketOptions.adapterOptions.heartbeatMessage,
|
|
32
|
+
}),
|
|
33
|
+
);
|
|
34
|
+
});
|
|
35
|
+
|
|
36
|
+
it("should receive heartbeat to keep the connection", async () => {
|
|
37
|
+
await expect(server).toReceiveMessage(
|
|
38
|
+
JSON.stringify({
|
|
39
|
+
topic: "heartbeat",
|
|
40
|
+
data: socketOptions.adapterOptions.heartbeatMessage,
|
|
41
|
+
}),
|
|
42
|
+
);
|
|
43
|
+
server.send(JSON.stringify({ topic: "heartbeat", data: new Date().toISOString() }));
|
|
44
|
+
await expect(server).toReceiveMessage(
|
|
45
|
+
JSON.stringify({
|
|
46
|
+
topic: "heartbeat",
|
|
47
|
+
data: socketOptions.adapterOptions.heartbeatMessage,
|
|
48
|
+
}),
|
|
49
|
+
);
|
|
50
|
+
});
|
|
51
|
+
it("should close connection when no heartbeat event sent", async () => {
|
|
52
|
+
await expect(server).toReceiveMessage(
|
|
53
|
+
JSON.stringify({
|
|
54
|
+
topic: "heartbeat",
|
|
55
|
+
data: socketOptions.adapterOptions.heartbeatMessage,
|
|
56
|
+
}),
|
|
57
|
+
);
|
|
58
|
+
await waitFor(() => {
|
|
59
|
+
expect(socket.adapter.connected).toBeFalse();
|
|
60
|
+
});
|
|
61
|
+
});
|
|
62
|
+
});
|
|
@@ -0,0 +1,254 @@
|
|
|
1
|
+
/* eslint-disable max-classes-per-file */
|
|
2
|
+
import { waitFor } from "@testing-library/dom";
|
|
3
|
+
import { createWebsocketMockingServer, waitForConnection } from "@hyper-fetch/testing";
|
|
4
|
+
|
|
5
|
+
import type { WebsocketAdapterType } from "../../../src/adapter-websockets/websocket-adapter";
|
|
6
|
+
import { WebsocketAdapter } from "../../../src/adapter-websockets/websocket-adapter";
|
|
7
|
+
import { getWebsocketAdapter } from "../../../src/adapter-websockets/websocket-adapter.utils";
|
|
8
|
+
import { createSocket } from "../../utils/socket.utils";
|
|
9
|
+
import type { Socket } from "socket";
|
|
10
|
+
|
|
11
|
+
describe("Websocket Adapter [ Base ]", () => {
|
|
12
|
+
const { url, getServer, startServer, stopServer } = createWebsocketMockingServer();
|
|
13
|
+
const socketOptions = {
|
|
14
|
+
url,
|
|
15
|
+
adapter: WebsocketAdapter(),
|
|
16
|
+
adapterOptions: {
|
|
17
|
+
autoConnect: true,
|
|
18
|
+
},
|
|
19
|
+
};
|
|
20
|
+
let socket: Socket<WebsocketAdapterType>;
|
|
21
|
+
|
|
22
|
+
beforeEach(async () => {
|
|
23
|
+
vi.resetAllMocks();
|
|
24
|
+
startServer();
|
|
25
|
+
socket = createSocket(socketOptions);
|
|
26
|
+
});
|
|
27
|
+
|
|
28
|
+
it("should create socket instance", () => {
|
|
29
|
+
expect(socket).toBeDefined();
|
|
30
|
+
expect(socket.adapter.name).toBe("websockets");
|
|
31
|
+
});
|
|
32
|
+
|
|
33
|
+
it("should handle open connection state", async () => {
|
|
34
|
+
await waitForConnection(socket);
|
|
35
|
+
expect(socket.adapter.connected).toBe(true);
|
|
36
|
+
});
|
|
37
|
+
|
|
38
|
+
it("should handle missing WebSocket gracefully", async () => {
|
|
39
|
+
const eventSource = window.WebSocket;
|
|
40
|
+
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
|
|
41
|
+
// @ts-ignore-error
|
|
42
|
+
window.WebSocket = undefined;
|
|
43
|
+
|
|
44
|
+
const spy = vi.fn();
|
|
45
|
+
const newSocket = createSocket(socketOptions);
|
|
46
|
+
newSocket.events.onConnected(spy);
|
|
47
|
+
|
|
48
|
+
const promise = await newSocket.adapter.connect();
|
|
49
|
+
|
|
50
|
+
expect(promise).toBe(false);
|
|
51
|
+
|
|
52
|
+
await waitFor(() => {
|
|
53
|
+
expect(spy).not.toHaveBeenCalled();
|
|
54
|
+
expect(newSocket.adapter.connected).toBe(false);
|
|
55
|
+
});
|
|
56
|
+
|
|
57
|
+
window.WebSocket = eventSource;
|
|
58
|
+
});
|
|
59
|
+
|
|
60
|
+
it("should handle disconnect before connection is established gracefully", async () => {
|
|
61
|
+
const spy = vi.fn();
|
|
62
|
+
const newSocket = createSocket({
|
|
63
|
+
adapter: WebsocketAdapter(),
|
|
64
|
+
adapterOptions: {
|
|
65
|
+
autoConnect: false,
|
|
66
|
+
},
|
|
67
|
+
});
|
|
68
|
+
newSocket.events.onConnected(spy);
|
|
69
|
+
|
|
70
|
+
await expect(newSocket.adapter.disconnect()).resolves.toBe(true);
|
|
71
|
+
});
|
|
72
|
+
|
|
73
|
+
it("should resolve immediately when WebSocket is already in OPEN state", async () => {
|
|
74
|
+
const ws = window.WebSocket;
|
|
75
|
+
class NewWebsocket extends WebSocket {
|
|
76
|
+
constructor(u: string, protocols?: string | string[]) {
|
|
77
|
+
super(u, protocols);
|
|
78
|
+
Object.defineProperty(this, "readyState", {
|
|
79
|
+
get: () => WebSocket.OPEN,
|
|
80
|
+
set: () => {},
|
|
81
|
+
});
|
|
82
|
+
}
|
|
83
|
+
}
|
|
84
|
+
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
|
|
85
|
+
// @ts-ignore-error
|
|
86
|
+
window.WebSocket = NewWebsocket;
|
|
87
|
+
|
|
88
|
+
const newSocket = createSocket({
|
|
89
|
+
...socketOptions,
|
|
90
|
+
adapter: WebsocketAdapter(),
|
|
91
|
+
adapterOptions: { autoConnect: false },
|
|
92
|
+
});
|
|
93
|
+
|
|
94
|
+
const result = await newSocket.adapter.connect();
|
|
95
|
+
|
|
96
|
+
expect(result).toBe(true);
|
|
97
|
+
expect(newSocket.adapter.connected).toBe(true);
|
|
98
|
+
expect(newSocket.adapter.connecting).toBe(false);
|
|
99
|
+
window.WebSocket = ws;
|
|
100
|
+
});
|
|
101
|
+
|
|
102
|
+
it("should resolve immediately when WebSocket is already in CLOSED state", async () => {
|
|
103
|
+
const ws = window.WebSocket;
|
|
104
|
+
class NewWebsocket extends WebSocket {
|
|
105
|
+
constructor(u: string, protocols?: string | string[]) {
|
|
106
|
+
super(u, protocols);
|
|
107
|
+
Object.defineProperty(this, "readyState", {
|
|
108
|
+
get: () => WebSocket.CLOSED,
|
|
109
|
+
set: () => {},
|
|
110
|
+
});
|
|
111
|
+
}
|
|
112
|
+
}
|
|
113
|
+
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
|
|
114
|
+
// @ts-ignore-error
|
|
115
|
+
window.WebSocket = NewWebsocket;
|
|
116
|
+
|
|
117
|
+
const newSocket = createSocket();
|
|
118
|
+
|
|
119
|
+
const result = await newSocket.adapter.disconnect();
|
|
120
|
+
|
|
121
|
+
expect(result).toBe(true);
|
|
122
|
+
expect(newSocket.adapter.connected).toBe(false);
|
|
123
|
+
expect(newSocket.adapter.connecting).toBe(false);
|
|
124
|
+
window.WebSocket = ws;
|
|
125
|
+
});
|
|
126
|
+
|
|
127
|
+
it("should respect autoConnect setting when going online", async () => {
|
|
128
|
+
const spy = vi.fn();
|
|
129
|
+
const socketWithoutAutoConnect = createSocket({
|
|
130
|
+
adapter: WebsocketAdapter,
|
|
131
|
+
adapterOptions: {
|
|
132
|
+
autoConnect: false,
|
|
133
|
+
},
|
|
134
|
+
});
|
|
135
|
+
|
|
136
|
+
socketWithoutAutoConnect.events.onConnected(spy);
|
|
137
|
+
startServer();
|
|
138
|
+
|
|
139
|
+
// Simulate offline/online cycle
|
|
140
|
+
socketWithoutAutoConnect.appManager.setOnline(false);
|
|
141
|
+
socketWithoutAutoConnect.adapter.disconnect();
|
|
142
|
+
socketWithoutAutoConnect.appManager.setOnline(true);
|
|
143
|
+
|
|
144
|
+
// Give it some time to potentially reconnect
|
|
145
|
+
await waitFor(() => {
|
|
146
|
+
expect(spy).not.toHaveBeenCalled();
|
|
147
|
+
expect(socketWithoutAutoConnect.adapter.connected).toBe(false);
|
|
148
|
+
});
|
|
149
|
+
});
|
|
150
|
+
|
|
151
|
+
it("should properly clean up error event listeners on disconnect", async () => {
|
|
152
|
+
const errorSpy = vi.fn();
|
|
153
|
+
socket.events.onDisconnected(errorSpy);
|
|
154
|
+
|
|
155
|
+
// Disconnect and verify cleanup
|
|
156
|
+
socket.adapter.disconnect();
|
|
157
|
+
|
|
158
|
+
// Emit error after disconnect
|
|
159
|
+
stopServer({
|
|
160
|
+
code: 1000,
|
|
161
|
+
reason: "Test error",
|
|
162
|
+
wasClean: false,
|
|
163
|
+
});
|
|
164
|
+
|
|
165
|
+
// Give time for any potential events
|
|
166
|
+
await waitFor(() => {
|
|
167
|
+
expect(socket.adapter.connected).toBe(false);
|
|
168
|
+
expect(socket.adapter.connecting).toBe(false);
|
|
169
|
+
});
|
|
170
|
+
});
|
|
171
|
+
|
|
172
|
+
it("should log error when trying to send payload through closed socket", async () => {
|
|
173
|
+
// Ensure socket is disconnected
|
|
174
|
+
await socket.adapter.disconnect();
|
|
175
|
+
|
|
176
|
+
// Try to send payload through closed socket
|
|
177
|
+
const result = await socket.adapter.emit(socket.createEmitter()({ topic: "test" }));
|
|
178
|
+
|
|
179
|
+
// Verify the result and error logging
|
|
180
|
+
expect(result).toBe(undefined);
|
|
181
|
+
});
|
|
182
|
+
|
|
183
|
+
it("should return null from getWebsocketAdapter when window access throws", () => {
|
|
184
|
+
const originalWindow = global.window;
|
|
185
|
+
Object.defineProperty(global, "window", {
|
|
186
|
+
get() {
|
|
187
|
+
throw new ReferenceError("window is not defined");
|
|
188
|
+
},
|
|
189
|
+
configurable: true,
|
|
190
|
+
});
|
|
191
|
+
|
|
192
|
+
const result = getWebsocketAdapter("ws://localhost:1234", {} as any);
|
|
193
|
+
expect(result).toBeNull();
|
|
194
|
+
|
|
195
|
+
Object.defineProperty(global, "window", {
|
|
196
|
+
value: originalWindow,
|
|
197
|
+
writable: true,
|
|
198
|
+
configurable: true,
|
|
199
|
+
});
|
|
200
|
+
});
|
|
201
|
+
|
|
202
|
+
it("should trigger reconnect timeout when websocket closes with a non-1000 code", async () => {
|
|
203
|
+
const reconnectingSpy = vi.fn();
|
|
204
|
+
const disconnectedSpy = vi.fn();
|
|
205
|
+
|
|
206
|
+
const newSocket = createSocket({
|
|
207
|
+
url,
|
|
208
|
+
adapter: WebsocketAdapter(),
|
|
209
|
+
reconnectTime: 10,
|
|
210
|
+
adapterOptions: { autoConnect: false },
|
|
211
|
+
});
|
|
212
|
+
newSocket.events.onReconnecting(reconnectingSpy);
|
|
213
|
+
newSocket.events.onDisconnected(disconnectedSpy);
|
|
214
|
+
|
|
215
|
+
await newSocket.adapter.connect();
|
|
216
|
+
await waitForConnection(newSocket);
|
|
217
|
+
|
|
218
|
+
getServer().close({
|
|
219
|
+
code: 1006,
|
|
220
|
+
reason: "Abnormal closure",
|
|
221
|
+
wasClean: false,
|
|
222
|
+
});
|
|
223
|
+
|
|
224
|
+
await waitFor(
|
|
225
|
+
() => {
|
|
226
|
+
expect(disconnectedSpy).toHaveBeenCalled();
|
|
227
|
+
},
|
|
228
|
+
{ timeout: 2000 },
|
|
229
|
+
);
|
|
230
|
+
|
|
231
|
+
startServer();
|
|
232
|
+
|
|
233
|
+
await waitFor(
|
|
234
|
+
() => {
|
|
235
|
+
expect(reconnectingSpy).toHaveBeenCalled();
|
|
236
|
+
},
|
|
237
|
+
{ timeout: 2000 },
|
|
238
|
+
);
|
|
239
|
+
});
|
|
240
|
+
|
|
241
|
+
it("should return false from sendEventMessage when websocket is not set", async () => {
|
|
242
|
+
const newSocket = createSocket({
|
|
243
|
+
...socketOptions,
|
|
244
|
+
adapterOptions: {
|
|
245
|
+
autoConnect: false,
|
|
246
|
+
},
|
|
247
|
+
});
|
|
248
|
+
|
|
249
|
+
const emitter = newSocket.createEmitter()({ topic: "test" });
|
|
250
|
+
const result = await newSocket.adapter.emit(emitter);
|
|
251
|
+
|
|
252
|
+
expect(result).toBeUndefined();
|
|
253
|
+
});
|
|
254
|
+
});
|
|
@@ -0,0 +1,63 @@
|
|
|
1
|
+
import { createWebsocketMockingServer, waitForConnection } from "@hyper-fetch/testing";
|
|
2
|
+
import { waitFor } from "@testing-library/react";
|
|
3
|
+
|
|
4
|
+
import { createEmitter } from "../../utils/emitter.utils";
|
|
5
|
+
import { createSocket } from "../../utils/socket.utils";
|
|
6
|
+
|
|
7
|
+
type DataType = {
|
|
8
|
+
test: string;
|
|
9
|
+
};
|
|
10
|
+
|
|
11
|
+
describe("Emitter [ Base ]", () => {
|
|
12
|
+
const { startServer, expectEmitterEvent } = createWebsocketMockingServer();
|
|
13
|
+
let socket = createSocket();
|
|
14
|
+
let emitter = createEmitter<DataType>(socket);
|
|
15
|
+
|
|
16
|
+
beforeEach(async () => {
|
|
17
|
+
startServer();
|
|
18
|
+
socket = createSocket();
|
|
19
|
+
emitter = createEmitter<DataType>(socket);
|
|
20
|
+
vi.resetAllMocks();
|
|
21
|
+
await waitForConnection(socket);
|
|
22
|
+
});
|
|
23
|
+
|
|
24
|
+
it("should initialize emitter with correct name", async () => {
|
|
25
|
+
const topic = "my-custom-name";
|
|
26
|
+
emitter = createEmitter(socket, { topic });
|
|
27
|
+
expect(emitter.topic).toBe(topic);
|
|
28
|
+
});
|
|
29
|
+
|
|
30
|
+
it("should allow to set additional adapter options", async () => {
|
|
31
|
+
const options = { something: "custom" };
|
|
32
|
+
const newEmitter = (emitter as any).setOptions(options);
|
|
33
|
+
expect(newEmitter.options).toStrictEqual(options);
|
|
34
|
+
});
|
|
35
|
+
|
|
36
|
+
it("should allow to set event data", async () => {
|
|
37
|
+
const data = { test: "test-data" };
|
|
38
|
+
const newEmitter = emitter.setPayload(data);
|
|
39
|
+
expect(newEmitter.payload).toStrictEqual(data);
|
|
40
|
+
});
|
|
41
|
+
|
|
42
|
+
it("should allow to set data mapper", async () => {
|
|
43
|
+
const data = { test: "test-data" };
|
|
44
|
+
const spy = vi.fn();
|
|
45
|
+
const dataMapper = (d: DataType) => {
|
|
46
|
+
spy();
|
|
47
|
+
return Object.keys(d);
|
|
48
|
+
};
|
|
49
|
+
const newEmitter = emitter.setPayloadMapper(dataMapper).setPayload(data);
|
|
50
|
+
expect(newEmitter.payload).toStrictEqual(data);
|
|
51
|
+
newEmitter.emit();
|
|
52
|
+
await waitFor(() => {
|
|
53
|
+
expect(spy).toHaveBeenCalled();
|
|
54
|
+
});
|
|
55
|
+
await expectEmitterEvent(emitter, Object.keys(data));
|
|
56
|
+
});
|
|
57
|
+
|
|
58
|
+
it("should allow inherit params", async () => {
|
|
59
|
+
const newEmitter = socket.createEmitter()({ topic: "test/:testId" }).setParams({ testId: 1 });
|
|
60
|
+
expect(newEmitter.clone().params).toStrictEqual({ testId: 1 });
|
|
61
|
+
expect(newEmitter.clone({ params: { testId: 3 } }).params).toStrictEqual({ testId: 3 });
|
|
62
|
+
});
|
|
63
|
+
});
|
|
@@ -0,0 +1,43 @@
|
|
|
1
|
+
import { createWebsocketMockingServer, waitForConnection } from "@hyper-fetch/testing";
|
|
2
|
+
|
|
3
|
+
import { createEmitter } from "../../utils/emitter.utils";
|
|
4
|
+
import { createSocket } from "../../utils/socket.utils";
|
|
5
|
+
|
|
6
|
+
type DataType = {
|
|
7
|
+
topic: string;
|
|
8
|
+
age: number;
|
|
9
|
+
};
|
|
10
|
+
|
|
11
|
+
describe("Emitter [ Emit ]", () => {
|
|
12
|
+
const { getServer, startServer, expectEmitterEvent } = createWebsocketMockingServer();
|
|
13
|
+
const message = { topic: "Maciej", age: 99 };
|
|
14
|
+
|
|
15
|
+
let socket = createSocket();
|
|
16
|
+
let emitter = createEmitter<DataType>(socket);
|
|
17
|
+
|
|
18
|
+
beforeEach(async () => {
|
|
19
|
+
startServer();
|
|
20
|
+
socket = createSocket();
|
|
21
|
+
emitter = createEmitter<DataType>(socket);
|
|
22
|
+
vi.resetAllMocks();
|
|
23
|
+
await waitForConnection(socket);
|
|
24
|
+
});
|
|
25
|
+
|
|
26
|
+
it("should emit event message", async () => {
|
|
27
|
+
emitter.emit({ payload: message });
|
|
28
|
+
|
|
29
|
+
await expect(getServer()).toReceiveMessage(
|
|
30
|
+
JSON.stringify({
|
|
31
|
+
topic: emitter.topic,
|
|
32
|
+
data: message,
|
|
33
|
+
}),
|
|
34
|
+
);
|
|
35
|
+
});
|
|
36
|
+
|
|
37
|
+
it("should allow to set params", async () => {
|
|
38
|
+
const emitterWithParams = socket.createEmitter<DataType>()({ topic: "test/:testId" });
|
|
39
|
+
emitterWithParams.emit({ payload: message, params: { testId: 1 } });
|
|
40
|
+
|
|
41
|
+
await expectEmitterEvent(emitterWithParams.setParams({ testId: 1 }), message);
|
|
42
|
+
});
|
|
43
|
+
});
|