Added unit/mock testing

server/src/socket/routes.ts

@@ -1,7 +1,7 @@
 import { HapticLinkServer } from "./hapticLinkServer";
 import { JoinRoomHandler, JoinRoomSchema } from "./routes/join_room";
 import { LeaveRoomHandler, LeaveRoomSchema } from "./routes/leave_room";
-import { SendVibrationHandler, SendVibrationSchema } from "./routes/send_vibration";
+import { SendVibrationHandler, SendVibrationSchema } from "./routes/send_touch";
 import { SetUsernameHandler, SetUsernameSchema } from "./routes/set_username";
 import { TestConnnectionSchema, TestConnectionHandler } from "./routes/test_connection";
 

server/test/helpers.spec.ts

@@ -1,7 +1,7 @@
 import { expect } from 'chai';
 import { generateSessionToken } from '../src/helpers';
 
-describe('generateSessionToken', () => {
+describe('Helpers', () => {
   it('should generate a token of a correct length', () => {
     const length = 16; // Specify the length of the token to generate
     const token = generateSessionToken(length);

server/test/index.spec.ts

@@ -61,7 +61,7 @@ describe('WebSocket Server', function() {
 
   });
 
-  it('server should start, listen, and respond to test_connection', (done) => {
+  it('should start, listen, and respond to test_connection', (done) => {
     // Listen for messages from the server
     wsClient.on('message', (data: string) => {
       expect(JSON.parse(data).message).to.equal("test_connection_response");

server/test/socket/hapticLinkServer.spec.ts

@@ -33,7 +33,7 @@ describe("Haptic Link Server", function() {
 
   })
 
-  it("hapticLinkServer should initialize", (done) => {
+  it("should initialize", (done) => {
     if (!server.users || server.users.size != 0) {
       return done("users map not initialized correctly")
     }

server/test/socket/room.spec.ts

@@ -1,10 +1,9 @@
 import { expect } from "chai";
-import { HapticLinkServer, User } from "../../src/socket/hapticLinkServer";
+import { User } from "../../src/socket/hapticLinkServer";
 import { Room } from "../../src/socket/room";
 import {WebSocketWrapper} from "./hapticLinkServer.spec";
 
 describe("Rooms", function() {
-  let server: HapticLinkServer = new HapticLinkServer();
   const ws1 = new WebSocketWrapper();
   const ws2 = new WebSocketWrapper();
   const user1: User = new User(ws1);

server/test/socket/router.spec.ts

@@ -0,0 +1,37 @@
+import { readdirSync } from "fs";
+import { HapticLinkServer } from "../../src/socket/hapticLinkServer"
+import { registerRoutes } from "../../src/socket/routes";
+import { expect } from 'chai';
+import { resolve } from "path";
+
+describe("Router", () => {
+  let server: HapticLinkServer = new HapticLinkServer();
+
+  beforeEach(() => {
+    server = new HapticLinkServer();
+  })
+
+  it("should add routes", (done) => {
+    registerRoutes(server);
+
+    const files = readdirSync(resolve("src/socket/routes"));
+    const routes: string[] = [];
+    files.forEach(file => {
+      if (file.startsWith("_")) return;
+      routes.push(file.replace(".ts", ""));
+    });
+
+    const registeredRoutes = Object.keys(server.routes);
+    const missingRoutes: string[] = []
+
+    routes.forEach(route => {
+      if (!registeredRoutes.includes(route)) {
+        missingRoutes.push(route)
+      }
+    })
+
+    expect(missingRoutes.length).to.equal(0, "routes not registered: " + missingRoutes);
+    done();
+  })
+
+})

server/test/socket/routes/join_room.spec.ts

@@ -0,0 +1,61 @@
+import { expect } from "chai";
+import { Context, HapticLinkServer, User } from "../../../src/socket/hapticLinkServer";
+import { JoinRoomHandler, JoinRoomPayload } from "../../../src/socket/routes/join_room";
+import { WebSocketWrapper } from "../hapticLinkServer.spec";
+
+describe("Join Room", () => {
+  let server: HapticLinkServer;
+  let ws: WebSocketWrapper;
+  let user: User;
+  let ws2: WebSocketWrapper;
+  let user2: User;
+  let ctx: Context<JoinRoomPayload>;
+
+  beforeEach(() => {
+    server = new HapticLinkServer();
+    ws = new WebSocketWrapper();
+    user = new User(ws);
+    ws2 = new WebSocketWrapper();
+    user2 = new User(ws2);
+    ctx = {
+      ws: ws,
+      user: user,
+      payload: { username: "test" },
+      server: server,
+    };
+  });
+
+  function testJoinRoom(expectedUserCount: number) {
+    JoinRoomHandler(ctx);
+    const resData = (ws.sendData as string);
+    const res = JSON.parse(resData);
+    ws.sendData = "";
+    if (!ctx.payload.roomId) {
+      ctx.payload.roomId = res.roomId; // Store room ID if not set (for new rooms)
+    }
+    expect(res.message).to.equal("room_update", "room update not broadcasted");
+    expect(res.users.length).to.equal(expectedUserCount, "user quantity mismatch");
+    expect(server.rooms[res.roomId].users.length).to.equal(expectedUserCount, "server user quantity mismatch");
+  }
+
+  it("should join a newly created room", () => {
+    testJoinRoom(1);
+    expect(ctx.payload.roomId!).to.satisfy((id: string) => id.length > 3, "room id not generated");
+    expect(user.username).to.equal("test", "didn't set username");
+  });
+
+  it("should join existing room", () => {
+    testJoinRoom(1); // Initial user joins and creates room
+
+    // Set up second user to join the same room
+    ctx.payload.username = "test2";
+    ctx.user = user2;
+    ctx.ws = ws2;
+
+    testJoinRoom(2); // Second user joins the existing room
+
+    // Attempt to join the same user again and test if user size remains unchanged
+    JoinRoomHandler(ctx);
+    expect(server.rooms[ctx.payload.roomId!].users.length).to.equal(2, "user joined twice");
+  });
+});

server/test/socket/routes/leave_room.spec.ts

@@ -0,0 +1,52 @@
+import { expect } from "chai";
+import { Context, HapticLinkServer, User } from "../../../src/socket/hapticLinkServer";
+import { JoinRoomHandler, JoinRoomPayload } from "../../../src/socket/routes/join_room";
+import { WebSocketWrapper } from "../hapticLinkServer.spec";
+import { LeaveRoomHandler, LeaveRoomPayload } from "../../../src/socket/routes/leave_room";
+
+describe("Leave Room", () => {
+  let server: HapticLinkServer;
+  let ws: WebSocketWrapper;
+  let user: User;
+  let ws2: WebSocketWrapper;
+  let user2: User;
+  let ctx: Context<JoinRoomPayload>;
+  let ctx2: Context<LeaveRoomPayload>;
+
+  beforeEach(() => {
+    server = new HapticLinkServer();
+    ws = new WebSocketWrapper();
+    user = new User(ws);
+    ws2 = new WebSocketWrapper();
+    user2 = new User(ws2);
+    ctx = {
+      ws: ws,
+      user: user,
+      payload: { username: "test" },
+      server: server,
+    };
+    ctx2 = {
+      ws: ws,
+      user: user,
+      payload: { roomId: "" },
+      server: server,
+    };
+  });
+
+  function testJoinRoom() {
+    JoinRoomHandler(ctx);
+    const resData = (ws.sendData as string);
+    const res = JSON.parse(resData);
+    ws.sendData = "";
+    if (!ctx.payload.roomId) {
+      ctx.payload.roomId = res.roomId; // Store room ID if not set (for new rooms)
+    }
+  }
+
+  it("should leave room", () => {
+    testJoinRoom();
+    ctx2.payload.roomId = ctx.payload.roomId!;
+    LeaveRoomHandler(ctx2)
+    expect(server.rooms[ctx2.payload.roomId].users.length).to.equal(0, "user wasn't removed from room");
+  });
+});

server/test/socket/routes/send_touch.spec.ts

@@ -0,0 +1,75 @@
+
+import { expect } from "chai";
+import { Context, HapticLinkServer, User } from "../../../src/socket/hapticLinkServer";
+import { JoinRoomHandler, JoinRoomPayload } from "../../../src/socket/routes/join_room";
+import { WebSocketWrapper } from "../hapticLinkServer.spec";
+import { SendVibrationHandler, SendVibrationPayload } from "../../../src/socket/routes/send_touch";
+
+describe("Send Vibration", () => {
+  let server: HapticLinkServer;
+  let ws: WebSocketWrapper;
+  let user: User;
+  let ws2: WebSocketWrapper;
+  let user2: User;
+  let ctx: Context<JoinRoomPayload>;
+  let ctx2: Context<JoinRoomPayload>;
+  let ctx3: Context<SendVibrationPayload>;
+
+  beforeEach(() => {
+    server = new HapticLinkServer();
+    ws = new WebSocketWrapper();
+    user = new User(ws);
+    ws2 = new WebSocketWrapper();
+    user2 = new User(ws2);
+    ctx = {
+      ws: ws,
+      user: user,
+      payload: { username: "test", roomId: "testRoom" },
+      server: server,
+    };
+    ctx2 = {
+      ws: ws2,
+      user: user2,
+      payload: { username: "test2", roomId: "testRoom" },
+      server: server,
+    };
+
+
+    ctx3 = {
+      ws: ws,
+      user: user,
+      server: server,
+      payload: {
+        id: 1,
+        type: "enabled",
+        position: {
+          x: 3,
+          y: 10,
+        },
+        color: "#FFF",
+        intensity: 1,
+      }
+    }
+  });
+
+  it("should broadcast vibration", () => {
+    JoinRoomHandler(ctx)
+    JoinRoomHandler(ctx2)
+    ws.sendData = "";
+    ws2.sendData = "";
+    SendVibrationHandler(ctx3);
+
+    const res = JSON.parse(ws2.sendData as string)
+
+    expect(ws.sendData).to.equal(ws2.sendData, "vibration wasn't broadcasted correctly");
+    expect(res.message).to.equal("receive_touch", "invalid response");
+    expect(res.id).to.equal(user.id + "_" + "1", "invalid touch id");
+    expect(res.type).to.equal("enabled", "invalid touch type");
+    expect(res.user.username).to.equal("test", "wrong username");
+    expect(res.user.id).to.equal(user.id, "wrong user id");
+    expect(res.position.x).to.equal(3, "wrong x position");
+    expect(res.position.y).to.equal(10, "wrong y position");
+    expect(res.color).to.equal("#FFF", "wrong color");
+    expect(res.intensity).to.equal(1, "wrong intensity");
+  });
+});

server/test/socket/routes/set_username.spec.ts

@@ -0,0 +1,30 @@
+import { expect } from "chai";
+import { Context, HapticLinkServer, User } from "../../../src/socket/hapticLinkServer";
+import { SetUsernameHandler, SetUsernamePayload } from "../../../src/socket/routes/set_username";
+import { WebSocketWrapper } from "../hapticLinkServer.spec";
+
+describe("Set Username", () => {
+  let server: HapticLinkServer;
+  let ws: WebSocketWrapper;
+  let user: User;
+  let ctx: Context<SetUsernamePayload>;
+
+  beforeEach(() => {
+    server = new HapticLinkServer();
+    ws = new WebSocketWrapper();
+    user = new User(ws);
+    user.username = "old username"
+    ctx = {
+      ws: ws,
+      user: user,
+      payload: { username: "new username" },
+      server: server,
+    };
+  });
+
+  it("should change username", (done) => {
+    SetUsernameHandler(ctx);
+    expect(user.username).to.equal("new username", "name wasn't changed correctly")
+    done();
+  })
+})

server/test/socket/routes/test_connection.spec.ts

@@ -0,0 +1,28 @@
+import { expect } from "chai";
+import { Context, HapticLinkServer, User } from "../../../src/socket/hapticLinkServer"
+import { TestConnectionHandler, TestConnectionPayload } from "../../../src/socket/routes/test_connection"
+import { WebSocketWrapper } from "../hapticLinkServer.spec";
+
+
+describe("Test Connection", () => {
+  let server: HapticLinkServer = new HapticLinkServer();
+  const ws = new WebSocketWrapper();
+  const user = new User(ws);
+  user.username = "test"
+  let ctx: Context<TestConnectionPayload> = {
+    ws: ws,
+    user: user,
+    payload: {
+      route: "test_connection",
+    },
+    server: server,
+  }
+
+  it("should return connection response with user", (done) => {
+    TestConnectionHandler(ctx);
+    const res = JSON.parse(ws.sendData as string);
+    expect(res.message).to.equal("test_connection_response", "didn't return message")
+    expect(res.username).to.equal("test", "didn't return message")
+    done();
+  })
+})