1
/*
2
pnpm test ./keepalive.test.ts
3
*/
4

5
import { before, after, connect, wait } from "@cocalc/backend/conat/test/setup";
6
import { delay } from "awaiting";
7

8
beforeAll(before);
9

10
describe("test a server with a short keepalive time", () => {
11
  let client,
12
    server,
13
    cn1,
14
    cn2,
15
    sockets: any[] = [];
16

17
  const keepAlive = 100;
18
  const keepAliveTimeout = 50;
19

20
  it("creates a socket server with very short keepalive", async () => {
21
    cn1 = connect();
22
    server = cn1.socket.listen("keepalive-server.com", {
23
      keepAlive,
24
      keepAliveTimeout,
25
    });
26
    server.on("connection", (socket) => {
27
      sockets.push(socket);
28
    });
29
    expect(server.keepAlive).toBe(keepAlive);
30
    expect(server.keepAliveTimeout).toBe(keepAliveTimeout);
31
    cn2 = connect();
32
    client = cn2.socket.connect("keepalive-server.com", {
33
      keepAlive: 10000,
34
      keepAliveTimeout: 10000,
35
      reconnection: false,
36
    });
37
  });
38

39
  it("waits twice the keepAlive time and observes time was updated and sockets still alive", async () => {
40
    await delay(4 * keepAlive);
41
    expect(sockets[0].state).toBe("ready");
42
    expect(Math.abs(sockets[0].alive.last - Date.now())).toBeLessThan(
43
      1.2 * (keepAlive + keepAliveTimeout),
44
    );
45
  });
46

47
  it("breaks the client side of the socket and observes the server automatically disconnects", async () => {
48
    client.sub.close();
49
    await delay(1.2 * (keepAlive + keepAliveTimeout));
50
    expect(sockets[0].state).toBe("closed");
51
  });
52
});
53

54
describe("test a client with a short keepalive time", () => {
55
  let client,
56
    server,
57
    cn1,
58
    cn2,
59
    sockets: any[] = [];
60

61
  const keepAlive = 100;
62
  const keepAliveTimeout = 50;
63

64
  it("creates a socket server with long keepalive and client with a very short one", async () => {
65
    cn1 = connect();
66
    server = cn1.socket.listen("keepalive-client.com", {
67
      keepAlive: 10000,
68
      keepAliveTimeout: 10000,
69
    });
70
    server.on("connection", (socket) => {
71
      sockets.push(socket);
72
    });
73
    cn2 = connect();
74
    client = cn2.socket.connect("keepalive-client.com", {
75
      keepAlive,
76
      keepAliveTimeout,
77
      reconnection: false,
78
    });
79
    expect(client.keepAlive).toBe(keepAlive);
80
    expect(client.keepAliveTimeout).toBe(keepAliveTimeout);
81
  });
82

83
  it("waits several times the keepAlive time and observes time was updated and sockets still alive", async () => {
84
    await delay(2 * keepAlive);
85
    await wait({
86
      until: () => client.state == "ready",
87
    });
88
    expect(client.state).toBe("ready");
89
    expect(Math.abs(client.alive.last - Date.now())).toBeLessThan(
90
      keepAlive + keepAliveTimeout,
91
    );
92
  });
93

94
  it("breaks the server side of the socket and observes the client automatically disconnects quickly", async () => {
95
    // hack to make server /dev/null any command from client
96
    server.handleCommandFromClient = () => {};
97
    await wait({ until: () => client.state == "disconnected" });
98
    expect(client.state).toBe("disconnected");
99
  });
100
});
101

102
afterAll(after);
103

104