@hyper-fetch/sockets 7.5.1 → 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,154 @@
1
+ import { waitFor } from "@testing-library/dom";
2
+ import { createWebsocketMockingServer, waitForConnection } from "@hyper-fetch/testing";
3
+
4
+ import { Socket } from "socket";
5
+ import { createSocket } from "../../utils/socket.utils";
6
+ import { createEmitter } from "../../utils/emitter.utils";
7
+ import { Emitter } from "emitter";
8
+
9
+ type DataType = {
10
+ test: string;
11
+ };
12
+
13
+ describe("Socket [ Base ]", () => {
14
+ const { getServer, startServer, stopServer, emitListenerEvent } = createWebsocketMockingServer();
15
+ let server = getServer();
16
+ let socket: ReturnType<typeof createSocket>;
17
+ let emitter: ReturnType<typeof createEmitter<DataType>>;
18
+
19
+ beforeEach(async () => {
20
+ startServer();
21
+ server = getServer();
22
+ socket = createSocket();
23
+ emitter = createEmitter<DataType>(socket);
24
+ jest.resetAllMocks();
25
+ await waitForConnection(socket);
26
+ });
27
+
28
+ it("should initialize Socket", async () => {
29
+ const s = new Socket({ url: "ws://localhost:8080" });
30
+ expect(s).toBeDefined();
31
+ });
32
+
33
+ it("should initialize with autoConnect", async () => {
34
+ const s = new Socket({ url: "ws://localhost:8080", adapterOptions: { autoConnect: true } });
35
+ expect(s.options.adapterOptions?.autoConnect).toBeTrue();
36
+ });
37
+
38
+ it("should emit message", async () => {
39
+ const message: DataType = { test: "Maciej" };
40
+
41
+ const emitterInstance = emitter.setPayload(message);
42
+ emitterInstance.emit();
43
+
44
+ expect(server).toReceiveMessage(
45
+ JSON.stringify({
46
+ topic: emitter.topic,
47
+ data: message,
48
+ }),
49
+ );
50
+ });
51
+ it("should not throw on message without name", async () => {
52
+ const spy = jest.fn().mockImplementation((res) => res);
53
+ socket.onMessage(spy);
54
+ socket.adapter.listeners.get = jest.fn();
55
+ server.send(undefined as any);
56
+ expect(spy).toHaveBeenCalledTimes(1);
57
+ expect(socket.adapter.listeners.get).toHaveBeenCalledWith(undefined);
58
+ });
59
+ it("should allow to connect", async () => {
60
+ const spy = jest.fn();
61
+ socket.events.onConnected(spy);
62
+ socket.adapter.connect();
63
+ await waitFor(() => {
64
+ expect(spy).toHaveBeenCalledTimes(1);
65
+ });
66
+ });
67
+ it("should allow to disconnect", async () => {
68
+ const spy = jest.fn();
69
+ socket.events.onDisconnected(spy);
70
+ socket.adapter.disconnect();
71
+ await waitFor(() => {
72
+ expect(spy).toHaveBeenCalledTimes(1);
73
+ });
74
+ });
75
+ it("should handle errors and trigger error callbacks", async () => {
76
+ const errorSpy = jest.fn();
77
+
78
+ socket.onError(errorSpy);
79
+
80
+ stopServer({
81
+ code: 1000,
82
+ reason: "Test reason",
83
+ wasClean: false,
84
+ });
85
+
86
+ await waitFor(() => {
87
+ expect(errorSpy).toHaveBeenCalledTimes(1);
88
+ });
89
+ });
90
+ it("should handle message callbacks with data and extra info", async () => {
91
+ const messageSpy = jest.fn();
92
+ const testData = { topic: "message", data: "test" };
93
+
94
+ const messageListener = socket.createListener<{ data: any; extra: any }>()({ topic: "message" });
95
+ socket.onMessage(({ event }) => {
96
+ messageSpy(event);
97
+
98
+ return event;
99
+ });
100
+ emitListenerEvent(messageListener, testData);
101
+
102
+ await waitFor(() => {
103
+ expect(messageSpy).toHaveBeenCalledTimes(1);
104
+ expect(messageSpy).toHaveBeenCalledWith(testData);
105
+ });
106
+ });
107
+ it("should handle send callbacks", async () => {
108
+ const sendSpy = jest.fn();
109
+ const message: DataType = { test: "test" };
110
+
111
+ socket.onSend(({ emitter: e }) => {
112
+ sendSpy(e);
113
+ expect(e).toBeInstanceOf(Emitter);
114
+ return e;
115
+ });
116
+ const emitterInstance = emitter.setPayload(message);
117
+ emitterInstance.emit();
118
+
119
+ await waitFor(() => {
120
+ expect(sendSpy).toHaveBeenCalledTimes(1);
121
+ expect(sendSpy).toHaveBeenCalledWith(
122
+ expect.objectContaining({
123
+ payload: message,
124
+ }),
125
+ );
126
+ });
127
+ });
128
+ it("should set query params and allow chaining", () => {
129
+ const queryParams = { token: "test-token" };
130
+ const setQueryParamsSpy = jest.spyOn(socket.adapter, "setQueryParams");
131
+
132
+ const result = socket.setQueryParams(queryParams);
133
+
134
+ expect(setQueryParamsSpy).toHaveBeenCalledWith(queryParams);
135
+ expect(result).toBe(socket);
136
+ });
137
+ it("should allow to reconnect", async () => {
138
+ const spy = jest.fn();
139
+ socket.events.onConnected(spy);
140
+
141
+ await socket.reconnect();
142
+
143
+ await waitFor(() => {
144
+ expect(spy).toHaveBeenCalledTimes(1);
145
+ });
146
+ });
147
+ it("should call adapter connect method", async () => {
148
+ const connectSpy = jest.spyOn(socket.adapter, "connect");
149
+
150
+ await socket.connect();
151
+
152
+ expect(connectSpy).toHaveBeenCalledTimes(1);
153
+ });
154
+ });
@@ -0,0 +1,90 @@
1
+ import { waitFor } from "@testing-library/dom";
2
+ import { createWebsocketMockingServer, waitForConnection } from "@hyper-fetch/testing";
3
+
4
+ import { createEmitter } from "../../utils/emitter.utils";
5
+ import { createSocket } from "../../utils/socket.utils";
6
+
7
+ describe("Socket Client [ Callbacks ]", () => {
8
+ const { getServer, startServer } = createWebsocketMockingServer();
9
+ beforeEach(async () => {
10
+ startServer();
11
+ jest.resetAllMocks();
12
+ });
13
+
14
+ it("should trigger onConnected callbacks", async () => {
15
+ const spy = jest.fn();
16
+ createSocket().onConnected(spy);
17
+
18
+ await waitFor(() => {
19
+ expect(spy).toHaveBeenCalledTimes(1);
20
+ });
21
+ });
22
+
23
+ it("should trigger onDisconnected callbacks", async () => {
24
+ const spy = jest.fn();
25
+ const socket = createSocket().onDisconnected(spy);
26
+ socket.adapter.disconnect();
27
+
28
+ await waitFor(() => {
29
+ expect(spy).toHaveBeenCalledTimes(1);
30
+ });
31
+ });
32
+
33
+ it("should trigger onError callbacks", async () => {
34
+ const spy = jest.fn();
35
+ createSocket().onError(spy);
36
+ getServer().error({
37
+ code: 1000,
38
+ reason: "test",
39
+ wasClean: false,
40
+ });
41
+
42
+ await waitFor(() => {
43
+ expect(spy).toHaveBeenCalledTimes(1);
44
+ });
45
+ });
46
+
47
+ it("should trigger onMessage callbacks", async () => {
48
+ const spy = jest.fn().mockImplementation((res) => res);
49
+ createSocket().onMessage(spy);
50
+ getServer().send({ data: { topic: "test", data: "test" } });
51
+
52
+ await waitFor(() => {
53
+ expect(spy).toHaveBeenCalledTimes(1);
54
+ });
55
+ });
56
+
57
+ it("should trigger onSend callbacks", async () => {
58
+ const spy = jest.fn().mockImplementation((em) => em);
59
+ const socket = createSocket().onSend(spy);
60
+ const emitter = createEmitter(socket);
61
+
62
+ await waitForConnection(socket);
63
+
64
+ emitter.setPayload({ test: "1" }).emit();
65
+
66
+ await waitFor(() => {
67
+ expect(spy).toHaveBeenCalledTimes(1);
68
+ });
69
+ });
70
+
71
+ it("should trigger onReconnect callbacks", async () => {
72
+ const spy = jest.fn();
73
+ const socket = createSocket().onReconnect(spy);
74
+ socket.adapter.reconnect();
75
+
76
+ await waitFor(() => {
77
+ expect(spy).toHaveBeenCalledTimes(1);
78
+ });
79
+ });
80
+
81
+ it("should trigger onReconnectFailed callbacks", async () => {
82
+ const spy = jest.fn();
83
+ const socket = createSocket({ reconnect: 0 }).onReconnectFailed(spy);
84
+ socket.adapter.reconnect();
85
+
86
+ await waitFor(() => {
87
+ expect(spy).toHaveBeenCalledTimes(1);
88
+ });
89
+ });
90
+ });
@@ -0,0 +1,183 @@
1
+ import { createEmitter } from "../../utils/emitter.utils";
2
+ import { createListener } from "../../utils/listener.utils";
3
+ import { createSocket } from "../../utils/socket.utils";
4
+
5
+ describe("Socket [ Events ]", () => {
6
+ const spy = jest.fn();
7
+ let socket = createSocket();
8
+ let emitter = createEmitter(socket);
9
+ let listener = createListener(socket);
10
+
11
+ beforeEach(() => {
12
+ socket = createSocket();
13
+ emitter = createEmitter(socket);
14
+ listener = createListener(socket);
15
+ jest.resetAllMocks();
16
+ });
17
+
18
+ it("should emit and receive error event", async () => {
19
+ const value = { test: 1 };
20
+ socket.events.onError(spy);
21
+ socket.events.emitError({ error: value });
22
+
23
+ expect(spy).toHaveBeenCalledTimes(1);
24
+ expect(spy).toHaveBeenCalledWith({ error: value });
25
+ });
26
+
27
+ it("should emit and receive open event", async () => {
28
+ socket.events.onConnected(spy);
29
+ socket.events.emitConnected();
30
+
31
+ expect(spy).toHaveBeenCalledTimes(1);
32
+ });
33
+
34
+ it("should emit and receive close event", async () => {
35
+ socket.events.onDisconnected(spy);
36
+ socket.events.emitDisconnected();
37
+
38
+ expect(spy).toHaveBeenCalledTimes(1);
39
+ });
40
+
41
+ it("should emit and receive connecting event", async () => {
42
+ socket.events.onConnecting(spy);
43
+ socket.events.emitConnecting({ connecting: true });
44
+
45
+ expect(spy).toHaveBeenCalledTimes(1);
46
+ });
47
+
48
+ it("should emit and receive reconnecting event", async () => {
49
+ const value = 1;
50
+ socket.events.onReconnecting(spy);
51
+ socket.events.emitReconnecting({ attempts: value });
52
+
53
+ expect(spy).toHaveBeenCalledTimes(1);
54
+ expect(spy).toHaveBeenCalledWith({ attempts: value });
55
+ });
56
+
57
+ it("should emit and receive reconnecting stop event", async () => {
58
+ const value = 1;
59
+ socket.events.onReconnectingFailed(spy);
60
+ socket.events.emitReconnectingFailed({ attempts: value });
61
+
62
+ expect(spy).toHaveBeenCalledTimes(1);
63
+ expect(spy).toHaveBeenCalledWith({ attempts: value });
64
+ });
65
+
66
+ it("should emit and receive listener event", async () => {
67
+ const value = 1;
68
+ const extra = {} as MessageEvent;
69
+ socket.events.onListenerEvent(spy);
70
+ socket.events.onListenerEventByTopic(listener, spy);
71
+ socket.events.emitListenerEvent({ topic: listener.topic, data: value, extra });
72
+
73
+ expect(spy).toHaveBeenCalledTimes(2);
74
+ expect(spy).toHaveBeenCalledWith({ topic: listener.topic, data: value, extra });
75
+ });
76
+
77
+ it("should emit and receive listener remove event", async () => {
78
+ socket.events.onListenerRemove(spy);
79
+ socket.events.onListenerRemoveByTopic(listener, spy);
80
+ socket.events.emitListenerRemoveEvent({ topic: listener.topic });
81
+
82
+ expect(spy).toHaveBeenCalledTimes(2);
83
+ expect(spy).toHaveBeenCalledWith({ topic: listener.topic });
84
+ });
85
+
86
+ it("should emit and receive emitter start event", async () => {
87
+ socket.events.onEmitterStartEvent(spy);
88
+ socket.events.onEmitterStartEventByTopic(emitter, spy);
89
+ socket.events.emitEmitterStartEvent({ emitter });
90
+
91
+ expect(spy).toHaveBeenCalledTimes(2);
92
+ expect(spy).toHaveBeenCalledWith({ emitter });
93
+ });
94
+
95
+ describe("Cleanup functions", () => {
96
+ it("should remove error event listener when cleanup is called", () => {
97
+ const cleanup = socket.events.onError(spy);
98
+ cleanup();
99
+ socket.events.emitError({ error: { test: 1 } });
100
+ expect(spy).not.toHaveBeenCalled();
101
+ });
102
+
103
+ it("should remove connected event listener when cleanup is called", () => {
104
+ const cleanup = socket.events.onConnected(spy);
105
+ cleanup();
106
+ socket.events.emitConnected();
107
+ expect(spy).not.toHaveBeenCalled();
108
+ });
109
+
110
+ it("should remove disconnected event listener when cleanup is called", () => {
111
+ const cleanup = socket.events.onDisconnected(spy);
112
+ cleanup();
113
+ socket.events.emitDisconnected();
114
+ expect(spy).not.toHaveBeenCalled();
115
+ });
116
+
117
+ it("should remove connecting event listener when cleanup is called", () => {
118
+ const cleanup = socket.events.onConnecting(spy);
119
+ cleanup();
120
+ socket.events.emitConnecting({ connecting: true });
121
+ expect(spy).not.toHaveBeenCalled();
122
+ });
123
+
124
+ it("should remove reconnecting event listener when cleanup is called", () => {
125
+ const cleanup = socket.events.onReconnecting(spy);
126
+ cleanup();
127
+ socket.events.emitReconnecting({ attempts: 1 });
128
+ expect(spy).not.toHaveBeenCalled();
129
+ });
130
+
131
+ it("should remove reconnecting failed event listener when cleanup is called", () => {
132
+ const cleanup = socket.events.onReconnectingFailed(spy);
133
+ cleanup();
134
+ socket.events.emitReconnectingFailed({ attempts: 1 });
135
+ expect(spy).not.toHaveBeenCalled();
136
+ });
137
+
138
+ it("should remove listener event handlers when cleanup is called", () => {
139
+ const cleanup1 = socket.events.onListenerEvent(spy);
140
+ const cleanup2 = socket.events.onListenerEventByTopic(listener, spy);
141
+
142
+ cleanup1();
143
+ cleanup2();
144
+
145
+ socket.events.emitListenerEvent({ topic: listener.topic, data: 1, extra: {} as MessageEvent });
146
+ expect(spy).not.toHaveBeenCalled();
147
+ });
148
+
149
+ it("should remove listener remove event handlers when cleanup is called", () => {
150
+ const cleanup1 = socket.events.onListenerRemove(spy);
151
+ const cleanup2 = socket.events.onListenerRemoveByTopic(listener, spy);
152
+
153
+ cleanup1();
154
+ cleanup2();
155
+
156
+ socket.events.emitListenerRemoveEvent({ topic: listener.topic });
157
+ expect(spy).not.toHaveBeenCalled();
158
+ });
159
+
160
+ it("should remove emitter start event handlers when cleanup is called", () => {
161
+ const cleanup1 = socket.events.onEmitterStartEvent(spy);
162
+ const cleanup2 = socket.events.onEmitterStartEventByTopic(emitter, spy);
163
+
164
+ cleanup1();
165
+ cleanup2();
166
+
167
+ socket.events.emitEmitterStartEvent({ emitter });
168
+ expect(spy).not.toHaveBeenCalled();
169
+ });
170
+
171
+ it("should remove emitter error event handlers when cleanup is called", () => {
172
+ const error = new Error("test error");
173
+ const cleanup1 = socket.events.onEmitterError(spy);
174
+ const cleanup2 = socket.events.onEmitterErrorByTopic(emitter, spy);
175
+
176
+ cleanup1();
177
+ cleanup2();
178
+
179
+ socket.events.emitEmitterError({ error, emitter });
180
+ expect(spy).not.toHaveBeenCalled();
181
+ });
182
+ });
183
+ });
@@ -0,0 +1,52 @@
1
+ import { LoggerManager } from "@hyper-fetch/core";
2
+
3
+ import { Socket } from "socket";
4
+ import { WebsocketAdapter } from "adapter-websockets/websocket-adapter";
5
+
6
+ describe("Socket [ Methods ]", () => {
7
+ beforeEach(() => {
8
+ jest.resetAllMocks();
9
+ });
10
+
11
+ it("should allow to set new query params config", async () => {
12
+ const settings = { skipEmptyString: true };
13
+ const adapter = WebsocketAdapter().setQueryParamsConfig(settings);
14
+ const socket = new Socket({ url: "ws://localhost:1234", adapter });
15
+ expect(socket.adapter.queryParamsConfig).toBe(settings);
16
+ });
17
+
18
+ it("should allow to set new query params stringify", async () => {
19
+ const method = () => "testing";
20
+ const socket = new Socket({ url: "ws://localhost:1234" });
21
+ socket.adapter.setQueryParamsMapper(method);
22
+ const queryParams = socket.adapter.unstable_queryParamsMapper({ test: 1 });
23
+ expect(queryParams).toBe("testing");
24
+ });
25
+
26
+ it("should allow to activate debug", async () => {
27
+ const socket = new Socket({ url: "ws://localhost:1234" });
28
+ socket.setDebug(true);
29
+ expect(socket.debug).toBeTrue();
30
+ });
31
+
32
+ it("should allow to set log severity", async () => {
33
+ const socket = new Socket({ url: "ws://localhost:1234" });
34
+ socket.setLogLevel("info");
35
+ expect(socket.loggerManager.level).toBe("info");
36
+ });
37
+
38
+ it("should allow to set logger", async () => {
39
+ const customLogger = new LoggerManager();
40
+ const method = () => customLogger;
41
+ const socket = new Socket({ url: "ws://localhost:1234" });
42
+ socket.setLogger(method);
43
+ expect(socket.loggerManager).toBe(customLogger);
44
+ });
45
+
46
+ it("should allow to set query", async () => {
47
+ const value = { test: 1 };
48
+ const socket = new Socket({ url: "ws://localhost:1234" });
49
+ socket.adapter.setQueryParams(value);
50
+ expect(socket.adapter.queryParams).toBe(value);
51
+ });
52
+ });
@@ -0,0 +1,84 @@
1
+ import { createWebsocketMockingServer } from "@hyper-fetch/testing";
2
+
3
+ import { createSocket } from "../../utils/socket.utils";
4
+ import { getWebsocketAdapter } from "adapter-websockets/websocket-adapter.utils";
5
+ import { getServerSentEventsAdapter } from "adapter-sse/sse-adapter.utils";
6
+
7
+ const windowInstance = global.window;
8
+
9
+ describe("Socket Client [ Utils ]", () => {
10
+ const { startServer } = createWebsocketMockingServer();
11
+ let socket = createSocket();
12
+ let windowSpy: jest.SpyInstance<Window & typeof globalThis, []>;
13
+ const url = "ws://localhost:1234";
14
+
15
+ beforeEach(async () => {
16
+ startServer();
17
+ windowSpy = jest.spyOn(global, "window", "get");
18
+ socket = createSocket();
19
+ jest.resetAllMocks();
20
+ });
21
+
22
+ it("should allow to remove listener", async () => {
23
+ const spy = jest.fn();
24
+ const spy2 = jest.fn();
25
+ socket.adapter.listeners.set("test", new Map<any, any>().set(spy, spy2));
26
+ const removed = socket.adapter.removeListener({ topic: "test", callback: spy });
27
+ expect(removed).toBeTrue();
28
+ expect(spy2).toHaveBeenCalledOnce();
29
+ });
30
+
31
+ it("should not throw when removing not existing listener", async () => {
32
+ const spy = jest.fn();
33
+ const removed = socket.adapter.removeListener({ topic: "test", callback: spy });
34
+ expect(removed).toBeFalse();
35
+ });
36
+
37
+ describe("getAdapter utils no window", () => {
38
+ beforeEach(() => {
39
+ windowSpy.mockImplementation(() => undefined as any);
40
+ });
41
+ it("should not throw when there is no window", () => {
42
+ const adapter = getWebsocketAdapter(url, {});
43
+ expect(adapter).toBeNull();
44
+ });
45
+ it("should not throw SSE when there is no window", () => {
46
+ const adapter = getServerSentEventsAdapter(url, {});
47
+ expect(adapter).toBeNull();
48
+ });
49
+ });
50
+
51
+ describe("getAdapter utils no instances", () => {
52
+ beforeEach(() => {
53
+ windowSpy.mockImplementation(() => ({}) as any);
54
+ });
55
+ it("should not throw when there is no window", () => {
56
+ const adapter = getWebsocketAdapter(url, {});
57
+ expect(adapter).toBeNull();
58
+ });
59
+ it("should not throw SSE when there is no window", () => {
60
+ const adapter = getServerSentEventsAdapter(url, {});
61
+ expect(adapter).toBeNull();
62
+ });
63
+ });
64
+
65
+ describe("getWebsocketAdapter utils", () => {
66
+ beforeEach(() => {
67
+ windowSpy.mockImplementation(() => windowInstance);
68
+ jest.clearAllMocks();
69
+ });
70
+ it("should create correct url", () => {
71
+ socket = createSocket({ queryParams: { bar: 2 } });
72
+ const adapter = getWebsocketAdapter(url, {});
73
+ expect(adapter?.url).toBe(`${url}/`);
74
+ });
75
+ it("should initialize Websocket", () => {
76
+ const adapter = getWebsocketAdapter(url, {});
77
+ expect(adapter).toBeInstanceOf(WebSocket);
78
+ });
79
+ it("should initialize EventSource", () => {
80
+ const adapter = getServerSentEventsAdapter(url, {});
81
+ expect(adapter).toBeInstanceOf(EventSource);
82
+ });
83
+ });
84
+ });
@@ -0,0 +1,32 @@
1
+ import { createWebsocketMockingServer } from "@hyper-fetch/testing";
2
+
3
+ import { EmitterInstance } from "emitter";
4
+ import { interceptEmitter, interceptListener, Socket } from "socket";
5
+
6
+ describe("Socket [ Utils ]", () => {
7
+ const { url, startServer, stopServer } = createWebsocketMockingServer();
8
+ beforeEach(() => {
9
+ jest.resetAllMocks();
10
+ startServer();
11
+ });
12
+
13
+ afterEach(() => {
14
+ stopServer();
15
+ });
16
+
17
+ it("should throw on invalid listener interceptor", async () => {
18
+ const socket = new Socket({ url });
19
+
20
+ socket.onMessage(() => null);
21
+ expect(() =>
22
+ interceptListener(socket.unstable_onMessageCallbacks, { data: {}, extra: {} } as any, socket),
23
+ ).toThrow();
24
+ });
25
+
26
+ it("should throw on invalid listener interceptor", async () => {
27
+ const socket = new Socket({ url });
28
+
29
+ socket.onSend(() => null as any);
30
+ expect(() => interceptEmitter(socket.unstable_onSendCallbacks, {} as EmitterInstance)).toThrow();
31
+ });
32
+ });
@@ -0,0 +1,2 @@
1
+ /* eslint-disable @typescript-eslint/naming-convention */
2
+ import "jest-extended";
@@ -0,0 +1,7 @@
1
+ /* eslint-disable @typescript-eslint/no-namespace */
2
+ import EventSource from "eventsourcemock";
3
+
4
+ Object.defineProperty(window, "EventSource", {
5
+ value: EventSource,
6
+ writable: true,
7
+ });
@@ -0,0 +1,13 @@
1
+ {
2
+ "compilerOptions": {
3
+ "strict": true,
4
+ "noEmit": true,
5
+ "baseUrl": "../src",
6
+ "moduleResolution": "node",
7
+ "esModuleInterop": true,
8
+ "allowSyntheticDefaultImports": true,
9
+ "paths": {
10
+ "@hyper-fetch/sockets": ["../src"]
11
+ }
12
+ }
13
+ }
@@ -0,0 +1,8 @@
1
+ import { SocketInstance } from "socket";
2
+ import { WebsocketAdapter } from "adapter";
3
+
4
+ export const createAdapter = <T extends SocketInstance>(socket: T, options?: T["options"]["adapterOptions"]) => {
5
+ // eslint-disable-next-line no-param-reassign
6
+ socket.options.adapterOptions = options;
7
+ return WebsocketAdapter(socket);
8
+ };
@@ -0,0 +1,15 @@
1
+ import { getUniqueRequestId } from "@hyper-fetch/core";
2
+
3
+ import { SocketInstance } from "socket";
4
+ import { EmitterOptionsType } from "emitter";
5
+
6
+ export const createEmitter = <PayloadType = any>(
7
+ socket: SocketInstance,
8
+ options?: Partial<EmitterOptionsType<any, any>>,
9
+ ) => {
10
+ const randomKey = getUniqueRequestId({ queryKey: "some-event-emitter" });
11
+ return socket.createEmitter<PayloadType>()({
12
+ topic: randomKey,
13
+ ...options,
14
+ });
15
+ };
@@ -0,0 +1,13 @@
1
+ import { getUniqueRequestId } from "@hyper-fetch/core";
2
+
3
+ import { SocketInstance } from "socket";
4
+ import { ListenerOptionsType } from "listener";
5
+ import { SocketAdapterInstance } from "adapter";
6
+
7
+ export const createListener = <ResponseType = any>(
8
+ socket: SocketInstance,
9
+ options?: Partial<ListenerOptionsType<any, SocketAdapterInstance>>,
10
+ ) => {
11
+ const randomKey = getUniqueRequestId({ queryKey: "some-event-listener" }) as string;
12
+ return socket.createListener<ResponseType>()({ topic: randomKey, ...options });
13
+ };
@@ -0,0 +1,9 @@
1
+ import { Socket, SocketOptionsType } from "socket";
2
+ import { SocketAdapterInstance } from "adapter";
3
+ import { WebsocketAdapterType } from "adapter-websockets/websocket-adapter";
4
+
5
+ export const createSocket = <T extends SocketAdapterInstance = WebsocketAdapterType>(
6
+ config?: Partial<SocketOptionsType<T>>,
7
+ ) => {
8
+ return new Socket<T>({ url: "ws://localhost:1234", ...config });
9
+ };
package/jest.config.ts ADDED
@@ -0,0 +1,6 @@
1
+ import type { Config } from "@jest/types";
2
+
3
+ import { getJestConfig } from "../../jest.config";
4
+
5
+ const config: Config.InitialOptions = getJestConfig();
6
+ export default config;