server/test/socket/hapticLinkServer.spec.ts

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();
  })
})