@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.
Files changed (117) hide show
  1. package/.eslintrc.cjs +12 -0
  2. package/__tests__/features/adapter/adapter.base.spec.ts +80 -0
  3. package/__tests__/features/adapter/adapter.bindings.spec.ts +81 -0
  4. package/__tests__/features/adapter/adapter.connection.spec.ts +70 -0
  5. package/__tests__/features/adapter/adapter.error.spec.ts +127 -0
  6. package/__tests__/features/adapter/adapter.sse.connection.spec.ts +67 -0
  7. package/__tests__/features/adapter/adapter.sse.spec.ts +284 -0
  8. package/__tests__/features/adapter/adapter.websocket.heartbeat.spec.ts +62 -0
  9. package/__tests__/features/adapter/adapter.websocket.spec.ts +254 -0
  10. package/__tests__/features/emitter/emitter.base.spec.ts +63 -0
  11. package/__tests__/features/emitter/emitter.emit.spec.ts +43 -0
  12. package/__tests__/features/listener/listener.base.spec.ts +35 -0
  13. package/__tests__/features/listener/listener.listen.spec.ts +68 -0
  14. package/__tests__/features/listener/listener.sse.spec.ts +80 -0
  15. package/__tests__/features/listener/listener.typescript.spec.ts +31 -0
  16. package/__tests__/features/socket/socket.base.spec.ts +154 -0
  17. package/__tests__/features/socket/socket.callbacks.spec.ts +90 -0
  18. package/__tests__/features/socket/socket.events.spec.ts +183 -0
  19. package/__tests__/features/socket/socket.methods.spec.ts +52 -0
  20. package/__tests__/features/socket/socket.misc.spec.ts +85 -0
  21. package/__tests__/features/socket/socket.utils.spec.ts +30 -0
  22. package/__tests__/tsconfig.json +24 -0
  23. package/__tests__/utils/client.utils.ts +8 -0
  24. package/__tests__/utils/emitter.utils.ts +15 -0
  25. package/__tests__/utils/listener.utils.ts +13 -0
  26. package/__tests__/utils/socket.utils.ts +10 -0
  27. package/__tests__/vitest.setup.ts +12 -0
  28. package/dist/adapter/adapter.bindings.d.ts +40 -0
  29. package/dist/adapter/adapter.bindings.d.ts.map +1 -0
  30. package/dist/adapter/adapter.d.ts +75 -0
  31. package/dist/adapter/adapter.d.ts.map +1 -0
  32. package/dist/adapter/adapter.types.d.ts +13 -0
  33. package/dist/adapter/adapter.types.d.ts.map +1 -0
  34. package/dist/adapter/index.d.ts +8 -0
  35. package/dist/adapter/index.d.ts.map +1 -0
  36. package/dist/adapter-sse/index.d.ts +4 -0
  37. package/dist/adapter-sse/index.d.ts.map +1 -0
  38. package/dist/adapter-sse/sse-adapter.d.ts +11 -0
  39. package/dist/adapter-sse/sse-adapter.d.ts.map +1 -0
  40. package/dist/adapter-sse/sse-adapter.types.d.ts +5 -0
  41. package/dist/adapter-sse/sse-adapter.types.d.ts.map +1 -0
  42. package/dist/adapter-sse/sse-adapter.utils.d.ts +26 -0
  43. package/dist/adapter-sse/sse-adapter.utils.d.ts.map +1 -0
  44. package/dist/adapter-websockets/index.d.ts +4 -0
  45. package/dist/adapter-websockets/index.d.ts.map +1 -0
  46. package/dist/adapter-websockets/websocket-adapter.d.ts +11 -0
  47. package/dist/adapter-websockets/websocket-adapter.d.ts.map +1 -0
  48. package/dist/adapter-websockets/websocket-adapter.types.d.ts +9 -0
  49. package/dist/adapter-websockets/websocket-adapter.types.d.ts.map +1 -0
  50. package/dist/adapter-websockets/websocket-adapter.utils.d.ts +32 -0
  51. package/dist/adapter-websockets/websocket-adapter.utils.d.ts.map +1 -0
  52. package/dist/emitter/emitter.d.ts +28 -0
  53. package/dist/emitter/emitter.d.ts.map +1 -0
  54. package/dist/emitter/emitter.types.d.ts +51 -0
  55. package/dist/emitter/emitter.types.d.ts.map +1 -0
  56. package/dist/emitter/index.d.ts +3 -0
  57. package/dist/emitter/index.d.ts.map +1 -0
  58. package/dist/index.d.ts +9 -682
  59. package/dist/index.d.ts.map +1 -0
  60. package/dist/index.mjs +1425 -0
  61. package/dist/index.mjs.map +1 -0
  62. package/dist/listener/index.d.ts +3 -0
  63. package/dist/listener/index.d.ts.map +1 -0
  64. package/dist/listener/listener.d.ts +18 -0
  65. package/dist/listener/listener.d.ts.map +1 -0
  66. package/dist/listener/listener.types.d.ts +37 -0
  67. package/dist/listener/listener.types.d.ts.map +1 -0
  68. package/dist/socket/index.d.ts +5 -0
  69. package/dist/socket/index.d.ts.map +1 -0
  70. package/dist/socket/socket.d.ts +205 -0
  71. package/dist/socket/socket.d.ts.map +1 -0
  72. package/dist/socket/socket.events.d.ts +81 -0
  73. package/dist/socket/socket.events.d.ts.map +1 -0
  74. package/dist/socket/socket.types.d.ts +27 -0
  75. package/dist/socket/socket.types.d.ts.map +1 -0
  76. package/dist/socket/socket.utils.d.ts +25 -0
  77. package/dist/socket/socket.utils.d.ts.map +1 -0
  78. package/dist/types/connect.types.d.ts +4 -0
  79. package/dist/types/connect.types.d.ts.map +1 -0
  80. package/dist/types/extract.types.d.ts +30 -0
  81. package/dist/types/extract.types.d.ts.map +1 -0
  82. package/dist/types/index.d.ts +4 -0
  83. package/dist/types/index.d.ts.map +1 -0
  84. package/dist/types/tuple.types.d.ts +2 -0
  85. package/dist/types/tuple.types.d.ts.map +1 -0
  86. package/dist/utils/index.d.ts +4 -0
  87. package/dist/utils/index.d.ts.map +1 -0
  88. package/dist/utils/message-event.utils.d.ts +8 -0
  89. package/dist/utils/message-event.utils.d.ts.map +1 -0
  90. package/dist/utils/socket.errors.d.ts +2 -0
  91. package/dist/utils/socket.errors.d.ts.map +1 -0
  92. package/dist/utils/socket.utils.d.ts +2 -0
  93. package/dist/utils/socket.utils.d.ts.map +1 -0
  94. package/package.json +7 -10
  95. package/project.json +4 -0
  96. package/src/adapter/adapter.bindings.ts +6 -6
  97. package/src/adapter/adapter.ts +13 -10
  98. package/src/adapter/adapter.types.ts +4 -7
  99. package/src/adapter-sse/sse-adapter.ts +6 -6
  100. package/src/adapter-sse/sse-adapter.utils.ts +2 -2
  101. package/src/adapter-websockets/websocket-adapter.ts +7 -7
  102. package/src/adapter-websockets/websocket-adapter.utils.ts +2 -2
  103. package/src/emitter/emitter.ts +4 -4
  104. package/src/emitter/emitter.types.ts +6 -5
  105. package/src/listener/listener.ts +4 -4
  106. package/src/listener/listener.types.ts +8 -5
  107. package/src/socket/socket.events.ts +5 -5
  108. package/src/socket/socket.ts +12 -10
  109. package/src/socket/socket.types.ts +4 -4
  110. package/src/socket/socket.utils.ts +2 -2
  111. package/src/types/connect.types.ts +2 -2
  112. package/src/types/extract.types.ts +5 -5
  113. package/tsconfig.json +1 -1
  114. package/vite.config.ts +45 -0
  115. package/.eslintrc.json +0 -11
  116. package/dist/index.js +0 -1236
  117. 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
+ });