@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.
- 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 +263 -0
- package/__tests__/features/adapter/adapter.websocket.heartbeat.spec.ts +62 -0
- package/__tests__/features/adapter/adapter.websocket.spec.ts +180 -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 +84 -0
- package/__tests__/features/socket/socket.utils.spec.ts +32 -0
- package/__tests__/global.d.ts +2 -0
- package/__tests__/jest.setup.ts +7 -0
- package/__tests__/tsconfig.json +13 -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 +9 -0
- package/jest.config.ts +6 -0
- package/package.json +1 -1
- package/project.json +4 -0
|
@@ -0,0 +1,80 @@
|
|
|
1
|
+
import { SocketAdapter } from "adapter";
|
|
2
|
+
import { createSocket } from "../../utils/socket.utils";
|
|
3
|
+
|
|
4
|
+
describe("Socket Adapter [ Base ]", () => {
|
|
5
|
+
let socket = createSocket({ adapterOptions: { autoConnect: false } });
|
|
6
|
+
|
|
7
|
+
beforeEach(() => {
|
|
8
|
+
socket = createSocket({ adapterOptions: { autoConnect: false } });
|
|
9
|
+
jest.resetAllMocks();
|
|
10
|
+
});
|
|
11
|
+
|
|
12
|
+
it("should initialize with default values", () => {
|
|
13
|
+
expect(socket.adapter.connected).toBe(false);
|
|
14
|
+
expect(socket.adapter.connecting).toBe(false);
|
|
15
|
+
expect(socket.adapter.reconnectionAttempts).toBe(0);
|
|
16
|
+
expect(socket.adapter.forceClosed).toBe(false);
|
|
17
|
+
});
|
|
18
|
+
|
|
19
|
+
it("should update connection states", () => {
|
|
20
|
+
socket.adapter.setConnected(true);
|
|
21
|
+
expect(socket.adapter.connected).toBe(true);
|
|
22
|
+
|
|
23
|
+
socket.adapter.setConnecting(true);
|
|
24
|
+
expect(socket.adapter.connecting).toBe(true);
|
|
25
|
+
|
|
26
|
+
socket.adapter.setReconnectionAttempts(3);
|
|
27
|
+
expect(socket.adapter.reconnectionAttempts).toBe(3);
|
|
28
|
+
|
|
29
|
+
socket.adapter.setForceClosed(true);
|
|
30
|
+
expect(socket.adapter.forceClosed).toBe(true);
|
|
31
|
+
});
|
|
32
|
+
|
|
33
|
+
it("should initialize with provided default values", () => {
|
|
34
|
+
const socketWithDefaults = new SocketAdapter({
|
|
35
|
+
name: "test",
|
|
36
|
+
defaultConnected: true,
|
|
37
|
+
defaultConnecting: true,
|
|
38
|
+
defaultReconnectionAttempts: 5,
|
|
39
|
+
defaultForceClosed: true,
|
|
40
|
+
});
|
|
41
|
+
|
|
42
|
+
expect(socketWithDefaults.connected).toBe(true);
|
|
43
|
+
expect(socketWithDefaults.connecting).toBe(true);
|
|
44
|
+
expect(socketWithDefaults.reconnectionAttempts).toBe(5);
|
|
45
|
+
expect(socketWithDefaults.forceClosed).toBe(true);
|
|
46
|
+
});
|
|
47
|
+
|
|
48
|
+
it("should set and get default options correctly", () => {
|
|
49
|
+
const adapter = new SocketAdapter<any, any, any, any, any, any>({ name: "test" });
|
|
50
|
+
|
|
51
|
+
const extra = { customField: "value" };
|
|
52
|
+
adapter.setDefaultExtra(extra);
|
|
53
|
+
expect(adapter.defaultExtra).toEqual(extra);
|
|
54
|
+
|
|
55
|
+
const adapterOptions = { timeout: 5000 };
|
|
56
|
+
adapter.setOptions(adapterOptions);
|
|
57
|
+
expect(adapter.adapterOptions).toEqual(adapterOptions);
|
|
58
|
+
|
|
59
|
+
const listenerOptions = { once: true };
|
|
60
|
+
adapter.setDefaultListenerOptions(listenerOptions);
|
|
61
|
+
expect(adapter.listenerOptions).toEqual(listenerOptions);
|
|
62
|
+
|
|
63
|
+
const emitterOptions = { async: true };
|
|
64
|
+
adapter.setDefaultEmitterOptions(emitterOptions);
|
|
65
|
+
expect(adapter.emitterOptions).toEqual(emitterOptions);
|
|
66
|
+
});
|
|
67
|
+
|
|
68
|
+
it("should set query params mapper config", () => {
|
|
69
|
+
const adapter = new SocketAdapter<any, any, any, any, any, any>({ name: "test" });
|
|
70
|
+
|
|
71
|
+
const queryParamsConfig = {
|
|
72
|
+
transform: true,
|
|
73
|
+
includeTimestamp: true,
|
|
74
|
+
};
|
|
75
|
+
|
|
76
|
+
adapter.setQueryParamsMapperConfig(queryParamsConfig);
|
|
77
|
+
// Using any here since unstable_queryParamsMapperConfig is an internal property
|
|
78
|
+
expect((adapter as any).unstable_queryParamsMapperConfig).toEqual(queryParamsConfig);
|
|
79
|
+
});
|
|
80
|
+
});
|
|
@@ -0,0 +1,81 @@
|
|
|
1
|
+
import { createSocket } from "../../utils/socket.utils";
|
|
2
|
+
import { getAdapterBindings } from "adapter";
|
|
3
|
+
|
|
4
|
+
describe("Socket Adapter [ Bindings ]", () => {
|
|
5
|
+
let socket = createSocket({ adapterOptions: { autoConnect: false } });
|
|
6
|
+
|
|
7
|
+
beforeEach(() => {
|
|
8
|
+
socket = createSocket({ adapterOptions: { autoConnect: false } });
|
|
9
|
+
jest.resetAllMocks();
|
|
10
|
+
});
|
|
11
|
+
|
|
12
|
+
it("should allow remove listener without unmount callback", async () => {
|
|
13
|
+
const {
|
|
14
|
+
adapter: { listeners, removeListener },
|
|
15
|
+
} = getAdapterBindings(socket);
|
|
16
|
+
|
|
17
|
+
const callback = () => null;
|
|
18
|
+
listeners.set("test", new Map().set(callback, null));
|
|
19
|
+
|
|
20
|
+
expect(() => removeListener({ topic: "test", callback })).not.toThrow();
|
|
21
|
+
});
|
|
22
|
+
|
|
23
|
+
it("should emit error event when emitter encounters an error", () => {
|
|
24
|
+
const { onEmitError } = getAdapterBindings(socket);
|
|
25
|
+
|
|
26
|
+
const mockError = new Error("Test error");
|
|
27
|
+
const mockEmitter = socket.createEmitter()({ topic: "test" });
|
|
28
|
+
|
|
29
|
+
const spy = jest.fn();
|
|
30
|
+
socket.events.onEmitterError(spy);
|
|
31
|
+
|
|
32
|
+
onEmitError({
|
|
33
|
+
emitter: mockEmitter,
|
|
34
|
+
error: mockError,
|
|
35
|
+
});
|
|
36
|
+
|
|
37
|
+
expect(spy).toHaveBeenCalledWith({
|
|
38
|
+
error: mockError,
|
|
39
|
+
emitter: mockEmitter,
|
|
40
|
+
});
|
|
41
|
+
});
|
|
42
|
+
|
|
43
|
+
it("should not emit error event when adapter is connecting", async () => {
|
|
44
|
+
// Simulate connecting state
|
|
45
|
+
socket.adapter.setConnected(false);
|
|
46
|
+
socket.adapter.setConnecting(true);
|
|
47
|
+
|
|
48
|
+
const { onEmit } = getAdapterBindings(socket);
|
|
49
|
+
|
|
50
|
+
const emitter = socket.createEmitter()({ topic: "test" });
|
|
51
|
+
|
|
52
|
+
const result = await onEmit({ emitter });
|
|
53
|
+
|
|
54
|
+
expect(result).toBeNull();
|
|
55
|
+
});
|
|
56
|
+
|
|
57
|
+
it("should call adapter's removeListener with correct parameters", () => {
|
|
58
|
+
const { onListen } = getAdapterBindings(socket);
|
|
59
|
+
|
|
60
|
+
const removeListener = onListen({
|
|
61
|
+
listener: socket.createListener()({ topic: "test" }),
|
|
62
|
+
callback: () => null,
|
|
63
|
+
});
|
|
64
|
+
|
|
65
|
+
expect(socket.adapter.listeners.get("test")?.size).toBe(1);
|
|
66
|
+
|
|
67
|
+
removeListener();
|
|
68
|
+
|
|
69
|
+
expect(socket.adapter.listeners.get("test")?.size).toBe(0);
|
|
70
|
+
});
|
|
71
|
+
|
|
72
|
+
it("should get query params from adapter", () => {
|
|
73
|
+
const { getQueryParams } = getAdapterBindings(socket);
|
|
74
|
+
|
|
75
|
+
socket.adapter.queryParams = {
|
|
76
|
+
test: 123,
|
|
77
|
+
};
|
|
78
|
+
|
|
79
|
+
expect(getQueryParams()).toBe("?test=123");
|
|
80
|
+
});
|
|
81
|
+
});
|
|
@@ -0,0 +1,70 @@
|
|
|
1
|
+
import { waitFor } from "@testing-library/dom";
|
|
2
|
+
import { createWebsocketMockingServer, sleep, waitForConnection } from "@hyper-fetch/testing";
|
|
3
|
+
|
|
4
|
+
import { createSocket } from "../../utils/socket.utils";
|
|
5
|
+
import { Socket } from "socket";
|
|
6
|
+
|
|
7
|
+
const socketOptions: Parameters<typeof createSocket>[0] = {
|
|
8
|
+
reconnectTime: 10,
|
|
9
|
+
};
|
|
10
|
+
|
|
11
|
+
describe("Socket Adapter [ Connection ]", () => {
|
|
12
|
+
const { url, startServer, stopServer } = createWebsocketMockingServer();
|
|
13
|
+
let socket: ReturnType<typeof createSocket>;
|
|
14
|
+
|
|
15
|
+
beforeEach(async () => {
|
|
16
|
+
jest.resetAllMocks();
|
|
17
|
+
startServer();
|
|
18
|
+
socket = createSocket(socketOptions);
|
|
19
|
+
});
|
|
20
|
+
|
|
21
|
+
afterAll(() => {
|
|
22
|
+
stopServer();
|
|
23
|
+
});
|
|
24
|
+
|
|
25
|
+
it("should auto connect", async () => {
|
|
26
|
+
const spy = jest.fn();
|
|
27
|
+
socket.events.onConnected(spy);
|
|
28
|
+
await waitFor(() => {
|
|
29
|
+
expect(spy).toHaveBeenCalledTimes(1);
|
|
30
|
+
expect(socket.adapter.connected).toBe(true);
|
|
31
|
+
});
|
|
32
|
+
});
|
|
33
|
+
|
|
34
|
+
it("should prevent initial connection", async () => {
|
|
35
|
+
const spy = jest.fn();
|
|
36
|
+
const newSocket = new Socket({ url, adapterOptions: { autoConnect: false } });
|
|
37
|
+
newSocket.events.onConnected(spy);
|
|
38
|
+
await sleep(20);
|
|
39
|
+
expect(spy).toHaveBeenCalledTimes(0);
|
|
40
|
+
});
|
|
41
|
+
|
|
42
|
+
it("should reconnect when going online", async () => {
|
|
43
|
+
const spy = jest.fn();
|
|
44
|
+
await waitForConnection(socket);
|
|
45
|
+
socket.appManager.setOnline(false);
|
|
46
|
+
socket.onDisconnected(() => {
|
|
47
|
+
socket.adapter.connected = false;
|
|
48
|
+
socket.events.onConnected(spy);
|
|
49
|
+
socket.appManager.setOnline(true);
|
|
50
|
+
});
|
|
51
|
+
await socket.disconnect();
|
|
52
|
+
await waitFor(() => {
|
|
53
|
+
expect(spy).toHaveBeenCalledTimes(1);
|
|
54
|
+
});
|
|
55
|
+
});
|
|
56
|
+
|
|
57
|
+
it("should reconnect when connection attempt takes too long", async () => {
|
|
58
|
+
const spy = jest.fn();
|
|
59
|
+
const newUrl = "ws://test";
|
|
60
|
+
socket = createSocket({ url: newUrl, reconnectTime: 1 });
|
|
61
|
+
socket.events.onReconnecting(spy);
|
|
62
|
+
await socket.adapter.connect();
|
|
63
|
+
|
|
64
|
+
await waitFor(() => {
|
|
65
|
+
return !!socket.adapter.reconnectionAttempts;
|
|
66
|
+
});
|
|
67
|
+
|
|
68
|
+
expect(spy).toHaveBeenCalledTimes(1);
|
|
69
|
+
});
|
|
70
|
+
});
|
|
@@ -0,0 +1,127 @@
|
|
|
1
|
+
import { getSocketError } from "utils";
|
|
2
|
+
|
|
3
|
+
describe("Adapter [ Error ]", () => {
|
|
4
|
+
describe("WebSocket close codes", () => {
|
|
5
|
+
it("should handle normal closure (1000)", () => {
|
|
6
|
+
const event = new CloseEvent("close", { code: 1000 });
|
|
7
|
+
expect(getSocketError(event)).toBe(
|
|
8
|
+
"Normal closure, meaning that the purpose for which the connection was established has been fulfilled.",
|
|
9
|
+
);
|
|
10
|
+
});
|
|
11
|
+
|
|
12
|
+
it("should handle going away (1001)", () => {
|
|
13
|
+
const event = new CloseEvent("close", { code: 1001 });
|
|
14
|
+
expect(getSocketError(event)).toBe(
|
|
15
|
+
'An endpoint is "going away", such as a server going down or a browser having navigated away from a page.',
|
|
16
|
+
);
|
|
17
|
+
});
|
|
18
|
+
|
|
19
|
+
it("should handle protocol error (1002)", () => {
|
|
20
|
+
const event = new CloseEvent("close", { code: 1002 });
|
|
21
|
+
expect(getSocketError(event)).toBe("An endpoint is terminating the connection due to a protocol error");
|
|
22
|
+
});
|
|
23
|
+
|
|
24
|
+
it("should handle unsupported data (1003)", () => {
|
|
25
|
+
const event = new CloseEvent("close", { code: 1003 });
|
|
26
|
+
expect(getSocketError(event)).toBe(
|
|
27
|
+
"An endpoint is terminating the connection because it has received a type of data it cannot accept (e.g., an endpoint that understands only text data MAY send this if it receives a binary message).",
|
|
28
|
+
);
|
|
29
|
+
});
|
|
30
|
+
|
|
31
|
+
it("should handle reserved code (1004)", () => {
|
|
32
|
+
const event = new CloseEvent("close", { code: 1004 });
|
|
33
|
+
expect(getSocketError(event)).toBe("Reserved. The specific meaning might be defined in the future.");
|
|
34
|
+
});
|
|
35
|
+
|
|
36
|
+
it("should handle no status code (1005)", () => {
|
|
37
|
+
const event = new CloseEvent("close", { code: 1005 });
|
|
38
|
+
expect(getSocketError(event)).toBe("No status code was actually present.");
|
|
39
|
+
});
|
|
40
|
+
|
|
41
|
+
it("should handle abnormal closure (1006)", () => {
|
|
42
|
+
const event = new CloseEvent("close", { code: 1006 });
|
|
43
|
+
expect(getSocketError(event)).toBe(
|
|
44
|
+
"The connection was closed abnormally, e.g., without sending or receiving a Close control frame",
|
|
45
|
+
);
|
|
46
|
+
});
|
|
47
|
+
|
|
48
|
+
it("should handle invalid frame payload data (1007)", () => {
|
|
49
|
+
const event = new CloseEvent("close", { code: 1007 });
|
|
50
|
+
expect(getSocketError(event)).toBe(
|
|
51
|
+
"An endpoint is terminating the connection because it has received data within a message that was not consistent with the type of the message (e.g., non-UTF-8 [https://www.rfc-editor.org/rfc/rfc3629] data within a text message).",
|
|
52
|
+
);
|
|
53
|
+
});
|
|
54
|
+
|
|
55
|
+
it("should handle policy violation (1008)", () => {
|
|
56
|
+
const event = new CloseEvent("close", { code: 1008 });
|
|
57
|
+
expect(getSocketError(event)).toBe(
|
|
58
|
+
'An endpoint is terminating the connection because it has received a message that "violates its policy". This reason is given either if there is no other sutible reason, or if there is a need to hide specific details about the policy.',
|
|
59
|
+
);
|
|
60
|
+
});
|
|
61
|
+
|
|
62
|
+
it("should handle message too big (1009)", () => {
|
|
63
|
+
const event = new CloseEvent("close", { code: 1009 });
|
|
64
|
+
expect(getSocketError(event)).toBe(
|
|
65
|
+
"An endpoint is terminating the connection because it has received a message that is too big for it to process.",
|
|
66
|
+
);
|
|
67
|
+
});
|
|
68
|
+
|
|
69
|
+
it("should handle missing extension (1010)", () => {
|
|
70
|
+
const event = new CloseEvent("close", { code: 1010, reason: "compression" });
|
|
71
|
+
expect(getSocketError(event)).toBe(
|
|
72
|
+
"An endpoint (client) is terminating the connection because it has expected the server to negotiate one or more extension, but the server didn't return them in the response message of the WebSocket handshake. <br /> Specifically, the extensions that are needed are: compression",
|
|
73
|
+
);
|
|
74
|
+
});
|
|
75
|
+
|
|
76
|
+
it("should handle missing extension with unknown reason (1010)", () => {
|
|
77
|
+
const event = new CloseEvent("close", { code: 1010 });
|
|
78
|
+
expect(getSocketError(event)).toBe(
|
|
79
|
+
"An endpoint (client) is terminating the connection because it has expected the server to negotiate one or more extension, but the server didn't return them in the response message of the WebSocket handshake. <br /> Specifically, the extensions that are needed are: Unknown reason",
|
|
80
|
+
);
|
|
81
|
+
const event2 = new CloseEvent("close", { code: 1010, reason: "Some reason" });
|
|
82
|
+
expect(getSocketError(event2)).toBe(
|
|
83
|
+
"An endpoint (client) is terminating the connection because it has expected the server to negotiate one or more extension, but the server didn't return them in the response message of the WebSocket handshake. <br /> Specifically, the extensions that are needed are: Some reason",
|
|
84
|
+
);
|
|
85
|
+
const event3 = new Event("close");
|
|
86
|
+
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
|
|
87
|
+
// @ts-ignore
|
|
88
|
+
event3.code = 1010;
|
|
89
|
+
expect(getSocketError(event3)).toBe(
|
|
90
|
+
"An endpoint (client) is terminating the connection because it has expected the server to negotiate one or more extension, but the server didn't return them in the response message of the WebSocket handshake. <br /> Specifically, the extensions that are needed are: Unknown reason",
|
|
91
|
+
);
|
|
92
|
+
});
|
|
93
|
+
|
|
94
|
+
it("should handle internal error (1011)", () => {
|
|
95
|
+
const event = new CloseEvent("close", { code: 1011 });
|
|
96
|
+
expect(getSocketError(event)).toBe(
|
|
97
|
+
"A server is terminating the connection because it encountered an unexpected condition that prevented it from fulfilling the request.",
|
|
98
|
+
);
|
|
99
|
+
});
|
|
100
|
+
|
|
101
|
+
it("should handle TLS handshake failure (1015)", () => {
|
|
102
|
+
const event = new CloseEvent("close", { code: 1015 });
|
|
103
|
+
expect(getSocketError(event)).toBe(
|
|
104
|
+
"The connection was closed due to a failure to perform a TLS handshake (e.g., the server certificate can't be verified).",
|
|
105
|
+
);
|
|
106
|
+
});
|
|
107
|
+
|
|
108
|
+
it("should handle unknown close codes", () => {
|
|
109
|
+
const event = new CloseEvent("close", { code: 9999 });
|
|
110
|
+
expect(getSocketError(event)).toBe("Unknown reason");
|
|
111
|
+
});
|
|
112
|
+
});
|
|
113
|
+
|
|
114
|
+
describe("MessageEvent handling", () => {
|
|
115
|
+
it("should handle MessageEvent with data", () => {
|
|
116
|
+
const event = new MessageEvent("message", { data: { error: "test error" } });
|
|
117
|
+
expect(getSocketError(event)).toBe('{"error":"test error"}');
|
|
118
|
+
});
|
|
119
|
+
});
|
|
120
|
+
|
|
121
|
+
describe("Generic Event handling", () => {
|
|
122
|
+
it("should handle generic events", () => {
|
|
123
|
+
const event = new Event("error");
|
|
124
|
+
expect(getSocketError(event)).toBe("There was an socket error");
|
|
125
|
+
});
|
|
126
|
+
});
|
|
127
|
+
});
|
|
@@ -0,0 +1,67 @@
|
|
|
1
|
+
import { waitFor } from "@testing-library/dom";
|
|
2
|
+
import { createSseMockingServer, sleep } from "@hyper-fetch/testing";
|
|
3
|
+
|
|
4
|
+
import { createSocket } from "../../utils/socket.utils";
|
|
5
|
+
import { ServerSentEventsAdapter } from "adapter-sse";
|
|
6
|
+
|
|
7
|
+
const socketOptions: Parameters<typeof createSocket>[0] = {
|
|
8
|
+
reconnectTime: 10,
|
|
9
|
+
adapter: ServerSentEventsAdapter,
|
|
10
|
+
};
|
|
11
|
+
const { startServer } = createSseMockingServer();
|
|
12
|
+
|
|
13
|
+
describe("Socket SSE [ Connection ]", () => {
|
|
14
|
+
let socket: ReturnType<typeof createSocket>;
|
|
15
|
+
|
|
16
|
+
beforeEach(async () => {
|
|
17
|
+
socket?.emitter.removeAllListeners();
|
|
18
|
+
socket = createSocket(socketOptions);
|
|
19
|
+
jest.resetAllMocks();
|
|
20
|
+
});
|
|
21
|
+
|
|
22
|
+
it("should auto connect", async () => {
|
|
23
|
+
const spy = jest.fn();
|
|
24
|
+
socket.events.onConnected(spy);
|
|
25
|
+
|
|
26
|
+
startServer();
|
|
27
|
+
await waitFor(() => {
|
|
28
|
+
expect(spy).toHaveBeenCalledTimes(1);
|
|
29
|
+
});
|
|
30
|
+
});
|
|
31
|
+
|
|
32
|
+
it("should prevent initial connection", async () => {
|
|
33
|
+
const spy = jest.fn();
|
|
34
|
+
socket = createSocket({ adapterOptions: { autoConnect: false } });
|
|
35
|
+
socket.events.onConnected(spy);
|
|
36
|
+
startServer();
|
|
37
|
+
await waitFor(() => {
|
|
38
|
+
expect(spy).toHaveBeenCalledTimes(0);
|
|
39
|
+
});
|
|
40
|
+
});
|
|
41
|
+
|
|
42
|
+
it("should reconnect when connection attempt takes too long", async () => {
|
|
43
|
+
const spy = jest.fn();
|
|
44
|
+
const spy2 = jest.fn();
|
|
45
|
+
const spy3 = jest.fn();
|
|
46
|
+
const url = "ws://localhost:2345";
|
|
47
|
+
const { startServer: startNewServer } = createSseMockingServer(url);
|
|
48
|
+
const newSocket = createSocket({
|
|
49
|
+
...socketOptions,
|
|
50
|
+
url,
|
|
51
|
+
reconnectTime: 30,
|
|
52
|
+
adapterOptions: { autoConnect: false },
|
|
53
|
+
});
|
|
54
|
+
newSocket.events.onReconnecting(spy);
|
|
55
|
+
newSocket.events.onConnected(spy2);
|
|
56
|
+
newSocket.events.onConnecting(spy3);
|
|
57
|
+
newSocket.adapter.connect();
|
|
58
|
+
await sleep(40);
|
|
59
|
+
startNewServer();
|
|
60
|
+
|
|
61
|
+
await waitFor(() => {
|
|
62
|
+
expect(spy3).toHaveBeenCalledTimes(3);
|
|
63
|
+
expect(spy).toHaveBeenCalledTimes(1);
|
|
64
|
+
expect(spy2).toHaveBeenCalledTimes(1);
|
|
65
|
+
});
|
|
66
|
+
});
|
|
67
|
+
});
|
|
@@ -0,0 +1,263 @@
|
|
|
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 { ServerSentEventsAdapter, ServerSentEventsAdapterType } from "adapter-sse/sse-adapter";
|
|
7
|
+
|
|
8
|
+
const socketOptions: Parameters<typeof createSocket>[0] = {
|
|
9
|
+
adapter: ServerSentEventsAdapter,
|
|
10
|
+
adapterOptions: { eventSourceInit: { withCredentials: true } },
|
|
11
|
+
};
|
|
12
|
+
|
|
13
|
+
describe("Socket Adapter [ SSE ]", () => {
|
|
14
|
+
const { startServer, emitError } = createSseMockingServer();
|
|
15
|
+
let socket = createSocket<ServerSentEventsAdapterType>(socketOptions);
|
|
16
|
+
let originalEventSource: typeof EventSource;
|
|
17
|
+
|
|
18
|
+
beforeEach(async () => {
|
|
19
|
+
socket = createSocket<ServerSentEventsAdapterType>(socketOptions);
|
|
20
|
+
originalEventSource = window.EventSource;
|
|
21
|
+
jest.resetAllMocks();
|
|
22
|
+
});
|
|
23
|
+
|
|
24
|
+
afterEach(() => {
|
|
25
|
+
window.EventSource = originalEventSource;
|
|
26
|
+
});
|
|
27
|
+
|
|
28
|
+
it("should emit event on disconnect", async () => {
|
|
29
|
+
startServer();
|
|
30
|
+
|
|
31
|
+
const spy = jest.fn();
|
|
32
|
+
socket.onDisconnected(spy);
|
|
33
|
+
expect(socket.adapter.connected).toBe(true);
|
|
34
|
+
socket.adapter.disconnect();
|
|
35
|
+
await waitFor(() => {
|
|
36
|
+
expect(spy).toHaveBeenCalledTimes(1);
|
|
37
|
+
});
|
|
38
|
+
});
|
|
39
|
+
|
|
40
|
+
it("should throw error when emitting", async () => {
|
|
41
|
+
startServer();
|
|
42
|
+
|
|
43
|
+
expect(() => socket.adapter.emit({} as any, {})).rejects.toThrow();
|
|
44
|
+
});
|
|
45
|
+
|
|
46
|
+
it("should reconnect when going online", async () => {
|
|
47
|
+
const spy = jest.fn();
|
|
48
|
+
socket.events.onConnected(spy);
|
|
49
|
+
|
|
50
|
+
startServer();
|
|
51
|
+
|
|
52
|
+
// Wait for initial connection
|
|
53
|
+
await waitFor(() => {
|
|
54
|
+
expect(spy).toHaveBeenCalledTimes(1);
|
|
55
|
+
});
|
|
56
|
+
|
|
57
|
+
// Simulate going offline and disconnecting
|
|
58
|
+
socket.appManager.setOnline(false);
|
|
59
|
+
socket.adapter.disconnect();
|
|
60
|
+
|
|
61
|
+
// Wait for disconnect to complete
|
|
62
|
+
await waitFor(() => {
|
|
63
|
+
expect(socket.adapter.connected).toBe(false);
|
|
64
|
+
});
|
|
65
|
+
|
|
66
|
+
// Simulate going back online
|
|
67
|
+
socket.appManager.setOnline(true);
|
|
68
|
+
startServer();
|
|
69
|
+
|
|
70
|
+
// Should reconnect automatically
|
|
71
|
+
await waitFor(() => {
|
|
72
|
+
expect(spy).toHaveBeenCalledTimes(2);
|
|
73
|
+
expect(socket.adapter.connected).toBe(true);
|
|
74
|
+
});
|
|
75
|
+
});
|
|
76
|
+
|
|
77
|
+
it("should not reconnect when connection is open", async () => {
|
|
78
|
+
const spy = jest.fn();
|
|
79
|
+
|
|
80
|
+
socket.events.onConnected(spy);
|
|
81
|
+
|
|
82
|
+
startServer();
|
|
83
|
+
|
|
84
|
+
await waitFor(() => {
|
|
85
|
+
expect(spy).toHaveBeenCalledTimes(1);
|
|
86
|
+
});
|
|
87
|
+
|
|
88
|
+
socket.appManager.setOnline(true);
|
|
89
|
+
startServer();
|
|
90
|
+
|
|
91
|
+
await waitFor(() => {
|
|
92
|
+
expect(spy).toHaveBeenCalledTimes(2);
|
|
93
|
+
});
|
|
94
|
+
});
|
|
95
|
+
|
|
96
|
+
it("should not connect again when connection is open", async () => {
|
|
97
|
+
const spy = jest.fn();
|
|
98
|
+
|
|
99
|
+
socket.events.onConnected(spy);
|
|
100
|
+
startServer();
|
|
101
|
+
socket.adapter.connect();
|
|
102
|
+
|
|
103
|
+
await waitFor(() => {
|
|
104
|
+
expect(spy).toHaveBeenCalledTimes(1);
|
|
105
|
+
});
|
|
106
|
+
|
|
107
|
+
await socket.adapter.connect();
|
|
108
|
+
|
|
109
|
+
await waitFor(() => {
|
|
110
|
+
expect(spy).toHaveBeenCalledTimes(1);
|
|
111
|
+
});
|
|
112
|
+
});
|
|
113
|
+
|
|
114
|
+
it("should emit and receive error event", async () => {
|
|
115
|
+
const spy = jest.fn();
|
|
116
|
+
socket.events.onError(spy);
|
|
117
|
+
emitError({
|
|
118
|
+
code: 1000,
|
|
119
|
+
reason: "Test error",
|
|
120
|
+
wasClean: false,
|
|
121
|
+
});
|
|
122
|
+
|
|
123
|
+
await waitFor(() => {
|
|
124
|
+
expect(spy).toHaveBeenCalledTimes(1);
|
|
125
|
+
expect(spy).toHaveBeenCalledWith({
|
|
126
|
+
error: new Error(
|
|
127
|
+
"Normal closure, meaning that the purpose for which the connection was established has been fulfilled.",
|
|
128
|
+
),
|
|
129
|
+
});
|
|
130
|
+
});
|
|
131
|
+
});
|
|
132
|
+
|
|
133
|
+
it("should handle missing EventSource gracefully", async () => {
|
|
134
|
+
const eventSource = window.EventSource;
|
|
135
|
+
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
|
|
136
|
+
// @ts-ignore-error
|
|
137
|
+
window.EventSource = undefined;
|
|
138
|
+
|
|
139
|
+
const spy = jest.fn();
|
|
140
|
+
const newSocket = createSocket<ServerSentEventsAdapterType>(socketOptions);
|
|
141
|
+
newSocket.events.onConnected(spy);
|
|
142
|
+
|
|
143
|
+
const promise = await newSocket.adapter.connect();
|
|
144
|
+
|
|
145
|
+
expect(promise).toBe(false);
|
|
146
|
+
|
|
147
|
+
await waitFor(() => {
|
|
148
|
+
expect(spy).not.toHaveBeenCalled();
|
|
149
|
+
expect(newSocket.adapter.connected).toBe(false);
|
|
150
|
+
});
|
|
151
|
+
|
|
152
|
+
window.EventSource = eventSource;
|
|
153
|
+
});
|
|
154
|
+
|
|
155
|
+
it("should handle disconnect before connection is established gracefully", async () => {
|
|
156
|
+
const spy = jest.fn();
|
|
157
|
+
const newSocket = createSocket<ServerSentEventsAdapterType>({
|
|
158
|
+
adapter: ServerSentEventsAdapter(),
|
|
159
|
+
adapterOptions: {
|
|
160
|
+
autoConnect: false,
|
|
161
|
+
},
|
|
162
|
+
});
|
|
163
|
+
newSocket.events.onConnected(spy);
|
|
164
|
+
|
|
165
|
+
await expect(newSocket.adapter.disconnect()).resolves.toBe(true);
|
|
166
|
+
});
|
|
167
|
+
|
|
168
|
+
it("should resolve immediately when EventSource is already in OPEN state", async () => {
|
|
169
|
+
class OpenEventSource extends EventSource {
|
|
170
|
+
constructor(url: string, eventSourceInitDict?: EventSourceInit) {
|
|
171
|
+
super(url, eventSourceInitDict);
|
|
172
|
+
Object.defineProperty(this, "readyState", {
|
|
173
|
+
get: () => EventSource.OPEN,
|
|
174
|
+
});
|
|
175
|
+
}
|
|
176
|
+
}
|
|
177
|
+
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
|
|
178
|
+
// @ts-ignore-error
|
|
179
|
+
window.EventSource = OpenEventSource;
|
|
180
|
+
|
|
181
|
+
const newSocket = createSocket<ServerSentEventsAdapterType>({
|
|
182
|
+
...socketOptions,
|
|
183
|
+
adapterOptions: { autoConnect: false },
|
|
184
|
+
});
|
|
185
|
+
|
|
186
|
+
const result = await newSocket.adapter.connect();
|
|
187
|
+
|
|
188
|
+
expect(result).toBe(true);
|
|
189
|
+
expect(newSocket.adapter.connected).toBe(true);
|
|
190
|
+
expect(newSocket.adapter.connecting).toBe(false);
|
|
191
|
+
});
|
|
192
|
+
|
|
193
|
+
it("should resolve immediately when EventSource is already in CLOSED state", async () => {
|
|
194
|
+
class OpenEventSource extends EventSource {
|
|
195
|
+
constructor(url: string, eventSourceInitDict?: EventSourceInit) {
|
|
196
|
+
super(url, eventSourceInitDict);
|
|
197
|
+
Object.defineProperty(this, "readyState", {
|
|
198
|
+
get: () => EventSource.CLOSED,
|
|
199
|
+
set: () => {},
|
|
200
|
+
});
|
|
201
|
+
}
|
|
202
|
+
}
|
|
203
|
+
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
|
|
204
|
+
// @ts-ignore-error
|
|
205
|
+
window.EventSource = OpenEventSource;
|
|
206
|
+
|
|
207
|
+
const newSocket = createSocket<ServerSentEventsAdapterType>(socketOptions);
|
|
208
|
+
|
|
209
|
+
const result = await newSocket.adapter.disconnect();
|
|
210
|
+
|
|
211
|
+
expect(result).toBe(true);
|
|
212
|
+
expect(newSocket.adapter.connected).toBe(false);
|
|
213
|
+
expect(newSocket.adapter.connecting).toBe(false);
|
|
214
|
+
});
|
|
215
|
+
|
|
216
|
+
it("should respect autoConnect setting when going online", async () => {
|
|
217
|
+
const spy = jest.fn();
|
|
218
|
+
const socketWithoutAutoConnect = createSocket<ServerSentEventsAdapterType>({
|
|
219
|
+
adapter: ServerSentEventsAdapter,
|
|
220
|
+
adapterOptions: {
|
|
221
|
+
eventSourceInit: { withCredentials: true },
|
|
222
|
+
autoConnect: false,
|
|
223
|
+
},
|
|
224
|
+
});
|
|
225
|
+
|
|
226
|
+
socketWithoutAutoConnect.events.onConnected(spy);
|
|
227
|
+
startServer();
|
|
228
|
+
|
|
229
|
+
// Simulate offline/online cycle
|
|
230
|
+
socketWithoutAutoConnect.appManager.setOnline(false);
|
|
231
|
+
socketWithoutAutoConnect.adapter.disconnect();
|
|
232
|
+
socketWithoutAutoConnect.appManager.setOnline(true);
|
|
233
|
+
|
|
234
|
+
// Give it some time to potentially reconnect
|
|
235
|
+
await new Promise((resolve) => {
|
|
236
|
+
setTimeout(resolve, 100);
|
|
237
|
+
});
|
|
238
|
+
|
|
239
|
+
expect(spy).not.toHaveBeenCalled();
|
|
240
|
+
expect(socketWithoutAutoConnect.adapter.connected).toBe(false);
|
|
241
|
+
});
|
|
242
|
+
|
|
243
|
+
it("should properly clean up error event listeners on disconnect", async () => {
|
|
244
|
+
const errorSpy = jest.fn();
|
|
245
|
+
socket.events.onError(errorSpy);
|
|
246
|
+
|
|
247
|
+
// Disconnect and verify cleanup
|
|
248
|
+
socket.adapter.disconnect();
|
|
249
|
+
|
|
250
|
+
// Emit error after disconnect
|
|
251
|
+
emitError({
|
|
252
|
+
code: 1000,
|
|
253
|
+
reason: "Test error",
|
|
254
|
+
wasClean: false,
|
|
255
|
+
});
|
|
256
|
+
|
|
257
|
+
// Give time for any potential error events
|
|
258
|
+
await sleep(10);
|
|
259
|
+
|
|
260
|
+
expect(errorSpy).toHaveBeenCalled();
|
|
261
|
+
expect(socket.adapter.connected).toBe(false);
|
|
262
|
+
});
|
|
263
|
+
});
|