File size: 2,384 Bytes
e3cb794
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
a18eb38
e3cb794
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
import { expect } from 'chai';
import { HapticLinkServer, User, Context } from '../../src/socket/hapticLinkServer';
import { WebSocketInterface } from '../../src/socket/WebSocketAdapter';
import { z } from 'zod';

export class WebSocketWrapper implements WebSocketInterface {
  sendData: string | Buffer = ""
  state: 0 | 1 | 2 | 3 = 1;

  constructor() { }

  send(data: string | Buffer) {
    this.sendData = data
  }

  readyState() {
    return this.state;
  }

}

describe("Haptic Link Server", function() {
  let server: HapticLinkServer = new HapticLinkServer();
  const ws = new WebSocketWrapper();
  const user: User = new User(ws);

  before((done) => {
    done();
  })


  after(() => {

  })

  it("should initialize", (done) => {
    if (!server.users || server.users.size != 0) {
      return done("users map not initialized correctly")
    }

    if (!server.routes) {
      return done("routes map not initialized correctly")
    }

    if (!server.rooms) {
      return done("rooms map not initialized correctly")
    }

    done();
  })

  it("should add user", (done) => {
    server.users.set(ws, user);
    server.users.set(ws, user);

    expect(server.users.size).to.equal(1, "user not added");
    done()
  })

  it("should remove user", (done) => {
    let removed = server.users.delete(ws);

    expect(server.users.size).to.equal(0, "user not removed");
    expect(removed).to.equal(true, "user not removed");
    done()
  })

  it("should add route", (done) => {

    interface TestConnectionPayload { }
    const TestConnnectionSchema = z.object({})

    function TestConnectionHandler(_ctx: Context<TestConnectionPayload>) {
      return;
    }

    server.addRoute("test_add_route", TestConnnectionSchema, TestConnectionHandler);

    const r = server.routes["test_add_route"];
    if (!r) {
      done("failed to add route")
    }

    done()
  })

  it("should handle route", (done) => {
    interface TestConnectionPayload { }
    const TestConnnectionSchema = z.object({})

    let executed = false;

    function TestConnectionHandler(_ctx: Context<TestConnectionPayload>) {
      executed = true;
      return;
    }

    server.addRoute("test_route", TestConnnectionSchema, TestConnectionHandler);
    server.handleRoute(ws, JSON.stringify({ route: "test_route" }))

    expect(executed).to.equal(true, "route not handled");
    done();
  })
})