@hyper-fetch/sockets 7.5.2 → 7.5.3

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 (30) hide show
  1. package/__tests__/features/adapter/adapter.base.spec.ts +80 -0
  2. package/__tests__/features/adapter/adapter.bindings.spec.ts +81 -0
  3. package/__tests__/features/adapter/adapter.connection.spec.ts +70 -0
  4. package/__tests__/features/adapter/adapter.error.spec.ts +127 -0
  5. package/__tests__/features/adapter/adapter.sse.connection.spec.ts +67 -0
  6. package/__tests__/features/adapter/adapter.sse.spec.ts +263 -0
  7. package/__tests__/features/adapter/adapter.websocket.heartbeat.spec.ts +62 -0
  8. package/__tests__/features/adapter/adapter.websocket.spec.ts +180 -0
  9. package/__tests__/features/emitter/emitter.base.spec.ts +63 -0
  10. package/__tests__/features/emitter/emitter.emit.spec.ts +43 -0
  11. package/__tests__/features/listener/listener.base.spec.ts +35 -0
  12. package/__tests__/features/listener/listener.listen.spec.ts +68 -0
  13. package/__tests__/features/listener/listener.sse.spec.ts +80 -0
  14. package/__tests__/features/listener/listener.typescript.spec.ts +31 -0
  15. package/__tests__/features/socket/socket.base.spec.ts +154 -0
  16. package/__tests__/features/socket/socket.callbacks.spec.ts +90 -0
  17. package/__tests__/features/socket/socket.events.spec.ts +183 -0
  18. package/__tests__/features/socket/socket.methods.spec.ts +52 -0
  19. package/__tests__/features/socket/socket.misc.spec.ts +84 -0
  20. package/__tests__/features/socket/socket.utils.spec.ts +32 -0
  21. package/__tests__/global.d.ts +2 -0
  22. package/__tests__/jest.setup.ts +7 -0
  23. package/__tests__/tsconfig.json +13 -0
  24. package/__tests__/utils/client.utils.ts +8 -0
  25. package/__tests__/utils/emitter.utils.ts +15 -0
  26. package/__tests__/utils/listener.utils.ts +13 -0
  27. package/__tests__/utils/socket.utils.ts +9 -0
  28. package/jest.config.ts +6 -0
  29. package/package.json +1 -1
  30. package/project.json +4 -0
@@ -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
+ jest.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,180 @@
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 { WebsocketAdapter, WebsocketAdapterType } from "../../../src/adapter-websockets/websocket-adapter";
6
+ import { createSocket } from "../../utils/socket.utils";
7
+ import { Socket } from "socket";
8
+
9
+ describe("Websocket Adapter [ Base ]", () => {
10
+ const { url, startServer, stopServer } = createWebsocketMockingServer();
11
+ const socketOptions = {
12
+ url,
13
+ adapter: WebsocketAdapter(),
14
+ adapterOptions: {
15
+ autoConnect: true,
16
+ },
17
+ };
18
+ let socket: Socket<WebsocketAdapterType>;
19
+
20
+ beforeEach(async () => {
21
+ jest.resetAllMocks();
22
+ startServer();
23
+ socket = createSocket(socketOptions);
24
+ });
25
+
26
+ it("should create socket instance", () => {
27
+ expect(socket).toBeDefined();
28
+ expect(socket.adapter.name).toBe("websockets");
29
+ });
30
+
31
+ it("should handle open connection state", async () => {
32
+ await waitForConnection(socket);
33
+ expect(socket.adapter.connected).toBe(true);
34
+ });
35
+
36
+ it("should handle missing WebSocket gracefully", async () => {
37
+ const eventSource = window.WebSocket;
38
+ // eslint-disable-next-line @typescript-eslint/ban-ts-comment
39
+ // @ts-ignore-error
40
+ window.WebSocket = undefined;
41
+
42
+ const spy = jest.fn();
43
+ const newSocket = createSocket(socketOptions);
44
+ newSocket.events.onConnected(spy);
45
+
46
+ const promise = await newSocket.adapter.connect();
47
+
48
+ expect(promise).toBe(false);
49
+
50
+ await waitFor(() => {
51
+ expect(spy).not.toHaveBeenCalled();
52
+ expect(newSocket.adapter.connected).toBe(false);
53
+ });
54
+
55
+ window.WebSocket = eventSource;
56
+ });
57
+
58
+ it("should handle disconnect before connection is established gracefully", async () => {
59
+ const spy = jest.fn();
60
+ const newSocket = createSocket({
61
+ adapter: WebsocketAdapter(),
62
+ adapterOptions: {
63
+ autoConnect: false,
64
+ },
65
+ });
66
+ newSocket.events.onConnected(spy);
67
+
68
+ await expect(newSocket.adapter.disconnect()).resolves.toBe(true);
69
+ });
70
+
71
+ it("should resolve immediately when WebSocket is already in OPEN state", async () => {
72
+ const ws = window.WebSocket;
73
+ class NewWebsocket extends WebSocket {
74
+ constructor(u: string, protocols?: string | string[]) {
75
+ super(u, protocols);
76
+ Object.defineProperty(this, "readyState", {
77
+ get: () => WebSocket.OPEN,
78
+ set: () => {},
79
+ });
80
+ }
81
+ }
82
+ // eslint-disable-next-line @typescript-eslint/ban-ts-comment
83
+ // @ts-ignore-error
84
+ window.WebSocket = NewWebsocket;
85
+
86
+ const newSocket = createSocket({
87
+ ...socketOptions,
88
+ adapter: WebsocketAdapter(),
89
+ adapterOptions: { autoConnect: false },
90
+ });
91
+
92
+ const result = await newSocket.adapter.connect();
93
+
94
+ expect(result).toBe(true);
95
+ expect(newSocket.adapter.connected).toBe(true);
96
+ expect(newSocket.adapter.connecting).toBe(false);
97
+ window.WebSocket = ws;
98
+ });
99
+
100
+ it("should resolve immediately when WebSocket is already in CLOSED state", async () => {
101
+ const ws = window.WebSocket;
102
+ class NewWebsocket extends WebSocket {
103
+ constructor(u: string, protocols?: string | string[]) {
104
+ super(u, protocols);
105
+ Object.defineProperty(this, "readyState", {
106
+ get: () => WebSocket.CLOSED,
107
+ set: () => {},
108
+ });
109
+ }
110
+ }
111
+ // eslint-disable-next-line @typescript-eslint/ban-ts-comment
112
+ // @ts-ignore-error
113
+ window.WebSocket = NewWebsocket;
114
+
115
+ const newSocket = createSocket();
116
+
117
+ const result = await newSocket.adapter.disconnect();
118
+
119
+ expect(result).toBe(true);
120
+ expect(newSocket.adapter.connected).toBe(false);
121
+ expect(newSocket.adapter.connecting).toBe(false);
122
+ window.WebSocket = ws;
123
+ });
124
+
125
+ it("should respect autoConnect setting when going online", async () => {
126
+ const spy = jest.fn();
127
+ const socketWithoutAutoConnect = createSocket({
128
+ adapter: WebsocketAdapter,
129
+ adapterOptions: {
130
+ autoConnect: false,
131
+ },
132
+ });
133
+
134
+ socketWithoutAutoConnect.events.onConnected(spy);
135
+ startServer();
136
+
137
+ // Simulate offline/online cycle
138
+ socketWithoutAutoConnect.appManager.setOnline(false);
139
+ socketWithoutAutoConnect.adapter.disconnect();
140
+ socketWithoutAutoConnect.appManager.setOnline(true);
141
+
142
+ // Give it some time to potentially reconnect
143
+ await waitFor(() => {
144
+ expect(spy).not.toHaveBeenCalled();
145
+ expect(socketWithoutAutoConnect.adapter.connected).toBe(false);
146
+ });
147
+ });
148
+
149
+ it("should properly clean up error event listeners on disconnect", async () => {
150
+ const errorSpy = jest.fn();
151
+ socket.events.onDisconnected(errorSpy);
152
+
153
+ // Disconnect and verify cleanup
154
+ socket.adapter.disconnect();
155
+
156
+ // Emit error after disconnect
157
+ stopServer({
158
+ code: 1000,
159
+ reason: "Test error",
160
+ wasClean: false,
161
+ });
162
+
163
+ // Give time for any potential events
164
+ await waitFor(() => {
165
+ expect(socket.adapter.connected).toBe(false);
166
+ expect(socket.adapter.connecting).toBe(false);
167
+ });
168
+ });
169
+
170
+ it("should log error when trying to send payload through closed socket", async () => {
171
+ // Ensure socket is disconnected
172
+ await socket.adapter.disconnect();
173
+
174
+ // Try to send payload through closed socket
175
+ const result = await socket.adapter.emit(socket.createEmitter()({ topic: "test" }));
176
+
177
+ // Verify the result and error logging
178
+ expect(result).toBe(undefined);
179
+ });
180
+ });
@@ -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
+ jest.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 = jest.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, { timeout: 4000 });
17
+
18
+ beforeEach(async () => {
19
+ startServer();
20
+ socket = createSocket();
21
+ emitter = createEmitter<DataType>(socket, { timeout: 4000 });
22
+ jest.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
+ });
@@ -0,0 +1,35 @@
1
+ import { createWebsocketMockingServer } from "@hyper-fetch/testing";
2
+
3
+ import { createListener } from "../../utils/listener.utils";
4
+ import { createSocket } from "../../utils/socket.utils";
5
+
6
+ describe("Listener [ Base ]", () => {
7
+ const { startServer } = createWebsocketMockingServer();
8
+ let socket = createSocket();
9
+ let listener = createListener(socket);
10
+
11
+ beforeEach(async () => {
12
+ startServer();
13
+ socket = createSocket();
14
+ listener = createListener(socket);
15
+ jest.resetAllMocks();
16
+ });
17
+
18
+ it("should initialize Listener with correct topic", async () => {
19
+ const topic = "my-custom-topic";
20
+ listener = createListener(socket, { topic });
21
+ expect(listener.topic).toBe(topic);
22
+ });
23
+
24
+ it("should allow to set additional adapter options", async () => {
25
+ const options = { something: "custom" };
26
+ const newListener = listener.setOptions(options);
27
+ expect(newListener.options).toStrictEqual(options);
28
+ });
29
+
30
+ it("should allow to set params", async () => {
31
+ const newListener = socket.createListener()({ topic: "test/:testId" }).setParams({ testId: 1 });
32
+ expect(newListener.topic).toBe("test/1");
33
+ expect(newListener.clone().topic).toBe("test/1");
34
+ });
35
+ });
@@ -0,0 +1,68 @@
1
+ import { waitFor } from "@testing-library/dom";
2
+ import { createWebsocketMockingServer, sleep } from "@hyper-fetch/testing";
3
+
4
+ import { createListener } from "../../utils/listener.utils";
5
+ import { createSocket } from "../../utils/socket.utils";
6
+
7
+ type DataType = { topic: string; age: number };
8
+
9
+ describe("Listener [ Listen ]", () => {
10
+ const { startServer, emitListenerEvent } = createWebsocketMockingServer();
11
+ let socket = createSocket();
12
+ let listener = createListener<DataType>(socket);
13
+
14
+ beforeEach(async () => {
15
+ startServer();
16
+ socket = createSocket();
17
+ listener = createListener<DataType>(socket);
18
+ jest.resetAllMocks();
19
+ });
20
+
21
+ it("should listen to given event topic", async () => {
22
+ const spy = jest.fn();
23
+ const message = { topic: "Maciej", age: 99 };
24
+ let receivedExtra: any;
25
+
26
+ listener.listen((data) => {
27
+ spy(data);
28
+ receivedExtra = data.extra;
29
+ });
30
+
31
+ emitListenerEvent(listener, message);
32
+
33
+ await waitFor(() => {
34
+ expect(spy).toHaveBeenCalledOnce();
35
+ expect(spy).toHaveBeenCalledWith({ data: message, extra: receivedExtra });
36
+ });
37
+
38
+ await sleep(10);
39
+ expect(spy).toHaveBeenCalledTimes(1);
40
+ });
41
+
42
+ it("should allow to remove given listener", async () => {
43
+ const spy = jest.fn();
44
+ const removeListener = listener.listen(spy);
45
+ const message = { topic: "Maciej", age: 99 };
46
+ emitListenerEvent(listener, message);
47
+ expect(spy).toHaveBeenCalledOnce();
48
+ removeListener();
49
+ emitListenerEvent(listener, message);
50
+ emitListenerEvent(listener, message);
51
+ emitListenerEvent(listener, message);
52
+ expect(spy).toHaveBeenCalledOnce();
53
+ });
54
+
55
+ it("should allow to set params", async () => {
56
+ const spy = jest.fn();
57
+ const listenerWithParams = socket.createListener<{ response: ResponseType }>()({ topic: "test/:testId" });
58
+ const removeListener = listenerWithParams.setParams({ testId: 1 }).listen(spy);
59
+ const message = { topic: "Maciej", age: 99 };
60
+ emitListenerEvent(listenerWithParams.setParams({ testId: 1 }), message);
61
+ expect(spy).toHaveBeenCalledOnce();
62
+ removeListener();
63
+ emitListenerEvent(listenerWithParams, message);
64
+ emitListenerEvent(listenerWithParams, message);
65
+ emitListenerEvent(listenerWithParams, message);
66
+ expect(spy).toHaveBeenCalledOnce();
67
+ });
68
+ });
@@ -0,0 +1,80 @@
1
+ import { waitFor } from "@testing-library/dom";
2
+ import { createSseMockingServer, sleep, waitForConnection } from "@hyper-fetch/testing";
3
+
4
+ import { createListener } from "../../utils/listener.utils";
5
+ import { createSocket } from "../../utils/socket.utils";
6
+ import { ServerSentEventsAdapter } from "adapter-sse/sse-adapter";
7
+
8
+ const config = {
9
+ adapter: ServerSentEventsAdapter,
10
+ };
11
+
12
+ type DataType = { topic: string; age: number };
13
+
14
+ describe("Listener [ SSE ]", () => {
15
+ const { startServer, emitListenerEvent } = createSseMockingServer();
16
+ let socket = createSocket(config);
17
+ let listener = createListener<DataType>(socket);
18
+
19
+ beforeEach(async () => {
20
+ socket = createSocket(config);
21
+ startServer();
22
+ listener = createListener<DataType>(socket);
23
+ await waitForConnection(socket);
24
+ jest.resetAllMocks();
25
+ });
26
+
27
+ it("should listen to given event topic", async () => {
28
+ const spy = jest.fn();
29
+ const message = { topic: "Maciej", age: 99 };
30
+ let receivedExtra: any;
31
+
32
+ listener.listen((data) => {
33
+ spy(data);
34
+ receivedExtra = data.extra;
35
+ });
36
+
37
+ emitListenerEvent(listener, message);
38
+
39
+ await waitFor(() => {
40
+ expect(spy).toHaveBeenCalledOnce();
41
+ expect(spy).toHaveBeenCalledWith({ data: message, extra: receivedExtra });
42
+ });
43
+
44
+ await sleep(10);
45
+ expect(spy).toHaveBeenCalledTimes(1);
46
+ });
47
+
48
+ it("should allow to remove given listener", async () => {
49
+ const spy = jest.fn();
50
+ const removeListener = listener.listen((data) => spy(data));
51
+ const message = { topic: "Maciej", age: 99 };
52
+ emitListenerEvent(listener, message);
53
+
54
+ await waitFor(() => {
55
+ expect(spy).toHaveBeenCalledOnce();
56
+ });
57
+
58
+ removeListener();
59
+ emitListenerEvent(listener, message);
60
+ emitListenerEvent(listener, message);
61
+ emitListenerEvent(listener, message);
62
+ expect(spy).toHaveBeenCalledOnce();
63
+ });
64
+
65
+ it("should allow to set params", async () => {
66
+ const spy = jest.fn();
67
+ const listenerWithParams = socket
68
+ .createListener<{ response: ResponseType }>()({ topic: "test/:testId" })
69
+ .setParams({ testId: 1 });
70
+ const removeListener = listenerWithParams.listen((data) => spy(data));
71
+ const message = { topic: "Maciej", age: 99 };
72
+ emitListenerEvent(listenerWithParams.setParams({ testId: 1 }), message);
73
+ expect(spy).toHaveBeenCalledOnce();
74
+ removeListener();
75
+ emitListenerEvent(listenerWithParams, message);
76
+ emitListenerEvent(listenerWithParams, message);
77
+ emitListenerEvent(listenerWithParams, message);
78
+ expect(spy).toHaveBeenCalledOnce();
79
+ });
80
+ });
@@ -0,0 +1,31 @@
1
+ import { expectType } from "@hyper-fetch/testing";
2
+
3
+ import { Socket } from "socket";
4
+
5
+ const client = new Socket({
6
+ url: "ws://localhost:3000",
7
+ });
8
+
9
+ const listenForUsers = client.createListener<{ response: { data: string }[] }>()({
10
+ topic: "/users",
11
+ });
12
+
13
+ const listenForUser = client.createListener<{ response: { data: string } }>()({
14
+ topic: "/users/:id",
15
+ });
16
+
17
+ describe("when request does not require params", () => {
18
+ it("should allow to make request with no parameters", () => {
19
+ expectType<(callback: any, options: { params: null }) => void>(listenForUsers.listen);
20
+ });
21
+ it("should not allow to set params", () => {
22
+ expectType<(options: null) => void>(listenForUsers.setParams);
23
+ });
24
+ });
25
+
26
+ describe("when listener has required params", () => {
27
+ it("should allow to add listener with parameters", () => {
28
+ expectType<(callback: any, options: { params: { id: string } }) => void>(listenForUser.listen);
29
+ expectType<(callback: any, options?: { params: never }) => void>(listenForUser.setParams({ id: 1 }).listen);
30
+ });
31
+ });