@hyper-fetch/sockets 7.5.2 → 8.0.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/.eslintrc.cjs +12 -0
- package/__tests__/features/adapter/adapter.base.spec.ts +80 -0
- package/__tests__/features/adapter/adapter.bindings.spec.ts +81 -0
- package/__tests__/features/adapter/adapter.connection.spec.ts +70 -0
- package/__tests__/features/adapter/adapter.error.spec.ts +127 -0
- package/__tests__/features/adapter/adapter.sse.connection.spec.ts +67 -0
- package/__tests__/features/adapter/adapter.sse.spec.ts +284 -0
- package/__tests__/features/adapter/adapter.websocket.heartbeat.spec.ts +62 -0
- package/__tests__/features/adapter/adapter.websocket.spec.ts +254 -0
- package/__tests__/features/emitter/emitter.base.spec.ts +63 -0
- package/__tests__/features/emitter/emitter.emit.spec.ts +43 -0
- package/__tests__/features/listener/listener.base.spec.ts +35 -0
- package/__tests__/features/listener/listener.listen.spec.ts +68 -0
- package/__tests__/features/listener/listener.sse.spec.ts +80 -0
- package/__tests__/features/listener/listener.typescript.spec.ts +31 -0
- package/__tests__/features/socket/socket.base.spec.ts +154 -0
- package/__tests__/features/socket/socket.callbacks.spec.ts +90 -0
- package/__tests__/features/socket/socket.events.spec.ts +183 -0
- package/__tests__/features/socket/socket.methods.spec.ts +52 -0
- package/__tests__/features/socket/socket.misc.spec.ts +85 -0
- package/__tests__/features/socket/socket.utils.spec.ts +30 -0
- package/__tests__/tsconfig.json +24 -0
- package/__tests__/utils/client.utils.ts +8 -0
- package/__tests__/utils/emitter.utils.ts +15 -0
- package/__tests__/utils/listener.utils.ts +13 -0
- package/__tests__/utils/socket.utils.ts +10 -0
- package/__tests__/vitest.setup.ts +12 -0
- package/dist/adapter/adapter.bindings.d.ts +40 -0
- package/dist/adapter/adapter.bindings.d.ts.map +1 -0
- package/dist/adapter/adapter.d.ts +75 -0
- package/dist/adapter/adapter.d.ts.map +1 -0
- package/dist/adapter/adapter.types.d.ts +13 -0
- package/dist/adapter/adapter.types.d.ts.map +1 -0
- package/dist/adapter/index.d.ts +8 -0
- package/dist/adapter/index.d.ts.map +1 -0
- package/dist/adapter-sse/index.d.ts +4 -0
- package/dist/adapter-sse/index.d.ts.map +1 -0
- package/dist/adapter-sse/sse-adapter.d.ts +11 -0
- package/dist/adapter-sse/sse-adapter.d.ts.map +1 -0
- package/dist/adapter-sse/sse-adapter.types.d.ts +5 -0
- package/dist/adapter-sse/sse-adapter.types.d.ts.map +1 -0
- package/dist/adapter-sse/sse-adapter.utils.d.ts +26 -0
- package/dist/adapter-sse/sse-adapter.utils.d.ts.map +1 -0
- package/dist/adapter-websockets/index.d.ts +4 -0
- package/dist/adapter-websockets/index.d.ts.map +1 -0
- package/dist/adapter-websockets/websocket-adapter.d.ts +11 -0
- package/dist/adapter-websockets/websocket-adapter.d.ts.map +1 -0
- package/dist/adapter-websockets/websocket-adapter.types.d.ts +9 -0
- package/dist/adapter-websockets/websocket-adapter.types.d.ts.map +1 -0
- package/dist/adapter-websockets/websocket-adapter.utils.d.ts +32 -0
- package/dist/adapter-websockets/websocket-adapter.utils.d.ts.map +1 -0
- package/dist/emitter/emitter.d.ts +28 -0
- package/dist/emitter/emitter.d.ts.map +1 -0
- package/dist/emitter/emitter.types.d.ts +51 -0
- package/dist/emitter/emitter.types.d.ts.map +1 -0
- package/dist/emitter/index.d.ts +3 -0
- package/dist/emitter/index.d.ts.map +1 -0
- package/dist/index.d.ts +9 -682
- package/dist/index.d.ts.map +1 -0
- package/dist/index.mjs +1425 -0
- package/dist/index.mjs.map +1 -0
- package/dist/listener/index.d.ts +3 -0
- package/dist/listener/index.d.ts.map +1 -0
- package/dist/listener/listener.d.ts +18 -0
- package/dist/listener/listener.d.ts.map +1 -0
- package/dist/listener/listener.types.d.ts +37 -0
- package/dist/listener/listener.types.d.ts.map +1 -0
- package/dist/socket/index.d.ts +5 -0
- package/dist/socket/index.d.ts.map +1 -0
- package/dist/socket/socket.d.ts +205 -0
- package/dist/socket/socket.d.ts.map +1 -0
- package/dist/socket/socket.events.d.ts +81 -0
- package/dist/socket/socket.events.d.ts.map +1 -0
- package/dist/socket/socket.types.d.ts +27 -0
- package/dist/socket/socket.types.d.ts.map +1 -0
- package/dist/socket/socket.utils.d.ts +25 -0
- package/dist/socket/socket.utils.d.ts.map +1 -0
- package/dist/types/connect.types.d.ts +4 -0
- package/dist/types/connect.types.d.ts.map +1 -0
- package/dist/types/extract.types.d.ts +30 -0
- package/dist/types/extract.types.d.ts.map +1 -0
- package/dist/types/index.d.ts +4 -0
- package/dist/types/index.d.ts.map +1 -0
- package/dist/types/tuple.types.d.ts +2 -0
- package/dist/types/tuple.types.d.ts.map +1 -0
- package/dist/utils/index.d.ts +4 -0
- package/dist/utils/index.d.ts.map +1 -0
- package/dist/utils/message-event.utils.d.ts +8 -0
- package/dist/utils/message-event.utils.d.ts.map +1 -0
- package/dist/utils/socket.errors.d.ts +2 -0
- package/dist/utils/socket.errors.d.ts.map +1 -0
- package/dist/utils/socket.utils.d.ts +2 -0
- package/dist/utils/socket.utils.d.ts.map +1 -0
- package/package.json +7 -10
- package/project.json +4 -0
- package/src/adapter/adapter.bindings.ts +6 -6
- package/src/adapter/adapter.ts +13 -10
- package/src/adapter/adapter.types.ts +4 -7
- package/src/adapter-sse/sse-adapter.ts +6 -6
- package/src/adapter-sse/sse-adapter.utils.ts +2 -2
- package/src/adapter-websockets/websocket-adapter.ts +7 -7
- package/src/adapter-websockets/websocket-adapter.utils.ts +2 -2
- package/src/emitter/emitter.ts +4 -4
- package/src/emitter/emitter.types.ts +6 -5
- package/src/listener/listener.ts +4 -4
- package/src/listener/listener.types.ts +8 -5
- package/src/socket/socket.events.ts +5 -5
- package/src/socket/socket.ts +12 -10
- package/src/socket/socket.types.ts +4 -4
- package/src/socket/socket.utils.ts +2 -2
- package/src/types/connect.types.ts +2 -2
- package/src/types/extract.types.ts +5 -5
- package/tsconfig.json +1 -1
- package/vite.config.ts +45 -0
- package/.eslintrc.json +0 -11
- package/dist/index.js +0 -1236
- package/dist/index.js.map +0 -7
|
@@ -0,0 +1,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
|
+
vi.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
|
+
vi.resetAllMocks();
|
|
19
|
+
});
|
|
20
|
+
|
|
21
|
+
it("should listen to given event topic", async () => {
|
|
22
|
+
const spy = vi.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 = vi.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 = vi.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
|
+
vi.resetAllMocks();
|
|
25
|
+
});
|
|
26
|
+
|
|
27
|
+
it("should listen to given event topic", async () => {
|
|
28
|
+
const spy = vi.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 = vi.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 = vi.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
|
+
});
|
|
@@ -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
|
+
vi.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 = vi.fn().mockImplementation((res) => res);
|
|
53
|
+
socket.onMessage(spy);
|
|
54
|
+
socket.adapter.listeners.get = vi.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 = vi.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 = vi.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 = vi.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 = vi.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 = vi.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 = vi.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 = vi.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 = vi.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
|
+
vi.resetAllMocks();
|
|
12
|
+
});
|
|
13
|
+
|
|
14
|
+
it("should trigger onConnected callbacks", async () => {
|
|
15
|
+
const spy = vi.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 = vi.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 = vi.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 = vi.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 = vi.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 = vi.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 = vi.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 = vi.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
|
+
vi.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
|
+
vi.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
|
+
});
|