Debian Codegraph @

addons/pos_glory_cash/static/tests/socket_io.test.js

raw
1 import { afterEach, beforeEach, describe, expect, test } from "@odoo/hoot";
2 import { waitUntil } from "@odoo/hoot-dom";
3 import { advanceTime, mockWebSocket } from "@odoo/hoot-mock";
4 import { SocketIoService } from "@pos_glory_cash/utils/socket_io";
5
6 const websocketState = {
7 instance: null,
8 closed: true,
9 received: [],
10 };
11
12 const PING_MESSAGE = "2";
13 const PONG_MESSAGE = "3";
14 const OPEN_MESSAGE = '0{"sid":"testSocketId", "pingInterval": 5000}';
15 const CONNECT_MESSAGE = "40";
16 const EVENT_MESSAGE = '42["test message"]';
17 const EVENT_MESSAGE_EMPTY = "42[]";
18 const EVENT_MESSAGE_BAD_FORMAT = '42"not an array"';
19 const BINARY_MESSAGE_DATA = new Blob(["test binary data"]);
20
21 beforeEach(() => {
22 mockWebSocket((ws) => {
23 websocketState.instance = ws;
24 websocketState.closed = false;
25 ws.addEventListener("message", (event) => {
26 websocketState.sent.push(event.data);
27 });
28 ws.addEventListener("close", () => {
29 websocketState.closed = true;
30 });
31 });
32 });
33
34 afterEach(() => {
35 websocketState.instance?.close();
36 websocketState.instance = null;
37 websocketState.sent = [];
38 websocketState.closed = true;
39 });
40
41 describe("when open message is received", () => {
42 test("sets socket ID from the message", async () => {
43 const socketIo = new SocketIoService({});
44 socketIo.connect("mockUrl");
45 await waitUntil(() => websocketState.instance.readyState);
46
47 websocketState.instance.send(OPEN_MESSAGE);
48
49 expect(socketIo.socketId).toBe("testSocketId");
50 });
51
52 test("sends ping request every 5 seconds", async () => {
53 const socketIo = new SocketIoService({ onClose: () => {} });
54 socketIo.connect("mockUrl");
55 await waitUntil(() => websocketState.instance.readyState);
56
57 websocketState.instance.send(OPEN_MESSAGE);
58 await advanceTime(11000);
59
60 expect(websocketState.sent).toHaveLength(2);
61 expect(websocketState.sent[0]).toBe(PING_MESSAGE);
62 expect(websocketState.sent[1]).toBe(PING_MESSAGE);
63 });
64
65 test("closes connection if pong response is not received in 10s after ping", async () => {
66 const socketIo = new SocketIoService({ onClose: () => {} });
67 socketIo.connect("mockUrl");
68 await waitUntil(() => websocketState.instance.readyState);
69
70 websocketState.instance.send(OPEN_MESSAGE);
71 await advanceTime(6000);
72 expect(websocketState.sent).toHaveLength(1);
73 expect(websocketState.sent[0]).toBe(PING_MESSAGE);
74 await advanceTime(10000);
75
76 expect(websocketState.closed).toBe(true);
77 });
78
79 test("keep connection open if pong response is received", async () => {
80 const socketIo = new SocketIoService({});
81 socketIo.connect("mockUrl");
82 await waitUntil(() => websocketState.instance.readyState);
83
84 websocketState.instance.send(OPEN_MESSAGE);
85 await advanceTime(1000);
86 websocketState.instance.send(PONG_MESSAGE);
87 await advanceTime(5000);
88 websocketState.instance.send(PONG_MESSAGE);
89 await advanceTime(5000);
90
91 expect(websocketState.closed).toBe(false);
92 });
93 });
94
95 describe("when connect is called a second time", () => {
96 test("closes current connection and opens new connection", async () => {
97 const socketIo = new SocketIoService({});
98 socketIo.connect("mockUrl");
99 const firstWebsocket = websocketState.instance;
100 await waitUntil(() => firstWebsocket.readyState);
101
102 socketIo.connect("mockUrl2");
103 const secondWebsocket = websocketState.instance;
104 await waitUntil(() => secondWebsocket.readyState);
105
106 expect(firstWebsocket.readyState).toBe(WebSocket.CLOSED);
107 expect(secondWebsocket.readyState).toBe(WebSocket.OPEN);
108 });
109 });
110
111 describe("when connect message is received", () => {
112 test("calls onConnect callback", async () => {
113 let onConnectCalled = false;
114 const socketIo = new SocketIoService({
115 onConnect: () => {
116 onConnectCalled = true;
117 },
118 });
119 socketIo.connect("mockUrl");
120 await waitUntil(() => websocketState.instance.readyState);
121
122 websocketState.instance.send(CONNECT_MESSAGE);
123
124 expect(onConnectCalled).toBe(true);
125 });
126 });
127
128 describe("when event message is received", () => {
129 test("does not call callback and closes websocket if message is empty", async () => {
130 let eventReceived = null;
131 const socketIo = new SocketIoService({
132 onClose: () => {},
133 onEvent: (event) => {
134 eventReceived = event;
135 },
136 });
137 socketIo.connect("mockUrl");
138 await waitUntil(() => websocketState.instance.readyState);
139
140 websocketState.instance.send(EVENT_MESSAGE_EMPTY);
141
142 await waitUntil(() => websocketState.closed);
143 expect(eventReceived).toBe(null);
144 });
145
146 test("does not call callback and closes websocket if message is invalid", async () => {
147 let eventReceived = null;
148 const socketIo = new SocketIoService({
149 onClose: () => {},
150 onEvent: (event) => {
151 eventReceived = event;
152 },
153 });
154 socketIo.connect("mockUrl");
155 await waitUntil(() => websocketState.instance.readyState);
156
157 websocketState.instance.send(EVENT_MESSAGE_BAD_FORMAT);
158
159 await waitUntil(() => websocketState.closed);
160 expect(eventReceived).toBe(null);
161 });
162
163 test("calls onEvent callback if message is valid", async () => {
164 let eventReceived = null;
165 const socketIo = new SocketIoService({
166 onEvent: (event) => {
167 eventReceived = event;
168 },
169 });
170 socketIo.connect("mockUrl");
171 await waitUntil(() => websocketState.instance.readyState);
172
173 websocketState.instance.send(EVENT_MESSAGE);
174
175 expect(eventReceived).toHaveLength(1);
176 expect(eventReceived[0]).toBe("test message");
177 });
178 });
179
180 describe("when binary event message is received", () => {
181 test("calls onBinaryEvent callback", async () => {
182 let eventReceived = null;
183 const socketIo = new SocketIoService({
184 onBinaryEvent: (data) => {
185 eventReceived = data;
186 },
187 });
188 socketIo.connect("mockUrl");
189 await waitUntil(() => websocketState.instance.readyState);
190
191 websocketState.instance.send(BINARY_MESSAGE_DATA);
192
193 expect(eventReceived).toBeInstanceOf(Blob);
194 expect(await eventReceived.text()).toBe("test binary data");
195 });
196 });
197
198 describe("when sending a message", () => {
199 test("the message is sent in the correct format", async () => {
200 const socketIo = new SocketIoService({});
201 socketIo.connect("mockUrl");
202 await waitUntil(() => websocketState.instance.readyState);
203
204 socketIo.sendMessage("test");
205
206 expect(websocketState.sent).toHaveLength(1);
207 expect(websocketState.sent[0]).toBe('42["test"]');
208 });
209 });