@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,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
|
+
});
|