test: fix and reenable tests (#1042)

This PR:
- fixes broken tests
- coverts them all to [Jest](https://jestjs.io)
- runs CI on every push and pull request

.github/workflows/test.yml

@@ -0,0 +1,35 @@
+# This workflow will do a clean installation of node dependencies, cache/restore them, build the source code and run tests across different versions of node
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-nodejs
+
+name: Node.js CI
+
+on:
+  push:
+    branches: ["master"]
+  pull_request:
+    branches: ["master"]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [14.x, 16.x, 18.x]
+        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
+
+    steps:
+      - uses: actions/checkout@v3
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v3
+        with:
+          node-version: ${{ matrix.node-version }}
+          cache: "npm"
+      - run: npm ci
+      - run: npm run build
+      # - run: npm run lint
+      - run: npm run coverage
+      - name: Publish code coverage to CodeClimate
+        uses: paambaati/codeclimate-action@v3.2.0
+        env:
+          CC_TEST_REPORTER_ID: ${{secrets.CC_TEST_REPORTER_ID}}

.gitignore

@@ -1,4 +1,5 @@
 lib-cov
+coverage
 *.seed
 *.log
 *.csv

test/logger.ts → __test__/logger.spec.ts

@@ -1,18 +1,18 @@
-import { expect } from "chai";
 import Logger, { LogLevel } from "../lib/logger";
+import { expect, beforeAll, afterAll, describe, it } from "@jest/globals";
 
-describe("Logger", function () {
+describe("Logger", () => {
 	let oldLoggerPrint;
-	before(() => {
+	beforeAll(() => {
 		//@ts-ignore
 		oldLoggerPrint = Logger._print;
 	});
 
-	it("should be disabled by default", function () {
-		expect(Logger.logLevel).to.eq(LogLevel.Disabled);
+	it("should be disabled by default", () => {
+		expect(Logger.logLevel).toBe(LogLevel.Disabled);
 	});
 
-	it("should be accept new log level", function () {
+	it("should be accept new log level", () => {
 		const checkedLevels = [];
 
 		Logger.setLogFunction((logLevel) => {
@@ -21,16 +21,16 @@ describe("Logger", function () {
 
 		Logger.logLevel = LogLevel.Warnings;
 
-		expect(Logger.logLevel).to.eq(LogLevel.Warnings);
+		expect(Logger.logLevel).toBe(LogLevel.Warnings);
 
 		Logger.log("");
 		Logger.warn("");
 		Logger.error("");
 
-		expect(checkedLevels).to.deep.eq([LogLevel.Warnings, LogLevel.Errors]);
+		expect(checkedLevels).toEqual([LogLevel.Warnings, LogLevel.Errors]);
 	});
 
-	it("should accept new log function", function () {
+	it("should accept new log function", () => {
 		Logger.logLevel = LogLevel.All;
 
 		const checkedLevels = [];
@@ -39,21 +39,21 @@ describe("Logger", function () {
 		Logger.setLogFunction((logLevel, ...args) => {
 			checkedLevels.push(logLevel);
 
-			expect(args[0]).to.eq(testMessage);
+			expect(args[0]).toBe(testMessage);
 		});
 
 		Logger.log(testMessage);
 		Logger.warn(testMessage);
 		Logger.error(testMessage);
 
-		expect(checkedLevels).to.deep.eq([
+		expect(checkedLevels).toEqual([
 			LogLevel.All,
 			LogLevel.Warnings,
 			LogLevel.Errors,
 		]);
 	});
 
-	after(() => {
+	afterAll(() => {
 		Logger.setLogFunction(oldLoggerPrint);
 	});
 });

__test__/peer.spec.ts

@@ -0,0 +1,222 @@
+import "./setup";
+import { Peer } from "../lib/peer";
+import { Server } from "mock-socket";
+import { ConnectionType, PeerErrorType, ServerMessageType } from "../lib/enums";
+import { expect, beforeAll, afterAll, describe, it } from "@jest/globals";
+
+const createMockServer = (): Server => {
+	const fakeURL = "ws://localhost:8080/peerjs?key=peerjs&id=1&token=testToken";
+	const mockServer = new Server(fakeURL);
+
+	mockServer.on("connection", (socket) => {
+		//@ts-ignore
+		socket.on("message", (data) => {
+			socket.send("test message from mock server");
+		});
+
+		socket.send(JSON.stringify({ type: ServerMessageType.Open }));
+	});
+
+	return mockServer;
+};
+describe("Peer", () => {
+	describe("after construct without parameters", () => {
+		it("shouldn't contains any connection", () => {
+			const peer = new Peer();
+
+			expect(peer.open).toBe(false);
+			expect(peer.connections).toEqual({});
+			expect(peer.id).toBeNull();
+			expect(peer.disconnected).toBe(false);
+			expect(peer.destroyed).toBe(false);
+
+			peer.destroy();
+		});
+	});
+
+	describe("after construct with parameters", () => {
+		it("should contains id and key", () => {
+			const peer = new Peer("1", { key: "anotherKey" });
+
+			expect(peer.id).toBe("1");
+			expect(peer.options.key).toBe("anotherKey");
+
+			peer.destroy();
+		});
+	});
+
+	describe("after call to peer #2", () => {
+		let mockServer;
+
+		beforeAll(() => {
+			mockServer = createMockServer();
+		});
+
+		it("Peer#1 should has id #1", (done) => {
+			const peer1 = new Peer("1", { port: 8080, host: "localhost" });
+			expect(peer1.open).toBe(false);
+
+			const mediaOptions = {
+				metadata: { var: "123" },
+				constraints: {
+					mandatory: {
+						OfferToReceiveAudio: true,
+						OfferToReceiveVideo: true,
+					},
+				},
+			};
+
+			const track = new MediaStreamTrack();
+			const mediaStream = new MediaStream([track]);
+
+			const mediaConnection = peer1.call("2", mediaStream, { ...mediaOptions });
+
+			expect(typeof mediaConnection.connectionId).toBe("string");
+			expect(mediaConnection.type).toBe(ConnectionType.Media);
+			expect(mediaConnection.peer).toBe("2");
+			expect(mediaConnection.options).toEqual(
+				// expect.arrayContaining([mediaOptions]),mediaOptions
+				expect.objectContaining(mediaOptions),
+			);
+			expect(mediaConnection.metadata).toEqual(mediaOptions.metadata);
+			expect(mediaConnection.peerConnection.getSenders()[0].track.id).toBe(
+				track.id,
+			);
+
+			peer1.once("open", (id) => {
+				expect(id).toBe("1");
+				//@ts-ignore
+				expect(peer1._lastServerId).toBe("1");
+				expect(peer1.disconnected).toBe(false);
+				expect(peer1.destroyed).toBe(false);
+				expect(peer1.open).toBe(true);
+
+				peer1.destroy();
+
+				expect(peer1.disconnected).toBe(true);
+				expect(peer1.destroyed).toBe(true);
+				expect(peer1.open).toBe(false);
+				expect(peer1.connections).toEqual({});
+
+				done();
+			});
+		});
+
+		afterAll(() => {
+			mockServer.stop();
+		});
+	});
+
+	describe("reconnect", () => {
+		let mockServer;
+
+		beforeAll(() => {
+			mockServer = createMockServer();
+		});
+
+		it("connect to server => disconnect => reconnect => destroy", (done) => {
+			const peer1 = new Peer("1", { port: 8080, host: "localhost" });
+
+			peer1.once("open", () => {
+				expect(peer1.open).toBe(true);
+
+				peer1.once("disconnected", () => {
+					expect(peer1.disconnected).toBe(true);
+					expect(peer1.destroyed).toBe(false);
+					expect(peer1.open).toBe(false);
+
+					peer1.once("open", (id) => {
+						expect(id).toBe("1");
+						expect(peer1.disconnected).toBe(false);
+						expect(peer1.destroyed).toBe(false);
+						expect(peer1.open).toBe(true);
+
+						peer1.once("disconnected", () => {
+							expect(peer1.disconnected).toBe(true);
+							expect(peer1.destroyed).toBe(false);
+							expect(peer1.open).toBe(false);
+
+							peer1.once("close", () => {
+								expect(peer1.disconnected).toBe(true);
+								expect(peer1.destroyed).toBe(true);
+								expect(peer1.open).toBe(false);
+
+								done();
+							});
+						});
+
+						peer1.destroy();
+					});
+
+					peer1.reconnect();
+				});
+
+				peer1.disconnect();
+			});
+		});
+
+		it("disconnect => reconnect => destroy", (done) => {
+			mockServer.stop();
+
+			const peer1 = new Peer("1", { port: 8080, host: "localhost" });
+
+			peer1.once("disconnected", (id) => {
+				expect(id).toBe("1");
+				expect(peer1.disconnected).toBe(true);
+				expect(peer1.destroyed).toBe(false);
+				expect(peer1.open).toBe(false);
+
+				peer1.once("open", (id) => {
+					expect(id).toBe("1");
+					expect(peer1.disconnected).toBe(false);
+					expect(peer1.destroyed).toBe(false);
+					expect(peer1.open).toBe(true);
+
+					peer1.once("disconnected", () => {
+						expect(peer1.disconnected).toBe(true);
+						expect(peer1.destroyed).toBe(false);
+						expect(peer1.open).toBe(false);
+
+						peer1.once("close", () => {
+							expect(peer1.disconnected).toBe(true);
+							expect(peer1.destroyed).toBe(true);
+							expect(peer1.open).toBe(false);
+
+							done();
+						});
+					});
+
+					peer1.destroy();
+				});
+
+				mockServer = createMockServer();
+
+				peer1.reconnect();
+			});
+		});
+
+		it("destroy peer if no id and no connection", (done) => {
+			mockServer.stop();
+
+			const peer1 = new Peer({ port: 8080, host: "localhost" });
+
+			peer1.once("error", (error) => {
+				expect(error.type).toBe(PeerErrorType.ServerError);
+
+				peer1.once("close", () => {
+					expect(peer1.disconnected).toBe(true);
+					expect(peer1.destroyed).toBe(true);
+					expect(peer1.open).toBe(false);
+
+					done();
+				});
+
+				mockServer = createMockServer();
+			});
+		});
+
+		afterAll(() => {
+			mockServer.stop();
+		});
+	});
+});

__test__/util.spec.ts

@@ -0,0 +1,11 @@
+import "./setup";
+import { util } from "../lib/util";
+import { expect, describe, it } from "@jest/globals";
+
+describe("util", () => {
+	describe("#chunkedMTU", () => {
+		it("should be 16300", () => {
+			expect(util.chunkedMTU).toBe(16300);
+		});
+	});
+});

jest.config.cjs

@@ -0,0 +1,7 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+	testEnvironment: "jsdom",
+	transform: {
+		"^.+\\.(t|j)sx?$": ["@swc/jest"],
+	},
+};

lib/util.ts

@@ -1,6 +1,4 @@
-// Types aren’t accurate
-//@ts-ignore
-import BinaryPack from "peerjs-js-binarypack";
+import * as BinaryPack from "peerjs-js-binarypack";
 import { Supports } from "./supports";
 
 export interface UtilSupportsObj {

package.json

@@ -155,7 +155,9 @@
 		"watch": "parcel watch",
 		"build": "rm -rf dist && parcel build",
 		"prepublishOnly": "npm run build",
-		"test": "mocha -r ts-node/register -r jsdom-global/register test/**/*.ts",
+		"test": "jest",
+		"test:watch": "jest --watch",
+		"coverage": "jest --coverage --collectCoverageFrom=\"./lib/**\"",
 		"format": "prettier --write .",
 		"semantic-release": "semantic-release"
 	},
@@ -166,19 +168,16 @@
 		"@parcel/transformer-typescript-types": "^2.8.1",
 		"@semantic-release/changelog": "^6.0.1",
 		"@semantic-release/git": "^10.0.1",
-		"@types/chai": "^4.3.0",
-		"@types/mocha": "^9.1.0",
+		"@swc/core": "^1.3.27",
+		"@swc/jest": "^0.2.24",
 		"@types/node": "^17.0.18",
-		"chai": "^4.3.6",
-		"jsdom": "^19.0.0",
-		"jsdom-global": "^3.0.2",
-		"mocha": "^9.2.0",
-		"mock-socket": "8.1.1",
+		"jest": "^29.3.1",
+		"jest-environment-jsdom": "^29.3.1",
+		"mock-socket": "^9.0.0",
 		"parcel": "^2.8.1",
 		"parcel-transformer-tsc-sourcemaps": "^1.0.2",
 		"prettier": "^2.6.2",
 		"semantic-release": "^19.0.2",
-		"ts-node": "^10.5.0",
 		"typescript": "^4.5.5"
 	},
 	"dependencies": {

test/peer.ts

@@ -1,219 +0,0 @@
-import "./setup";
-import { expect } from "chai";
-import { Peer } from "../lib/peer";
-import { Server } from "mock-socket";
-import { ConnectionType, ServerMessageType } from "../lib/enums";
-
-const createMockServer = (): Server => {
-	const fakeURL = "ws://localhost:8080/peerjs?key=peerjs&id=1&token=testToken";
-	const mockServer = new Server(fakeURL);
-
-	mockServer.on("connection", (socket) => {
-		//@ts-ignore
-		socket.on("message", (data) => {
-			socket.send("test message from mock server");
-		});
-
-		socket.send(JSON.stringify({ type: ServerMessageType.Open }));
-	});
-
-	return mockServer;
-};
-describe("Peer", function () {
-	describe("after construct without parameters", function () {
-		it("shouldn't contains any connection", function () {
-			const peer = new Peer();
-
-			expect(peer.open).to.be.false;
-			expect(peer.connections).to.be.empty;
-			expect(peer.id).to.be.null;
-			expect(peer.disconnected).to.be.false;
-			expect(peer.destroyed).to.be.false;
-
-			peer.destroy();
-		});
-	});
-
-	describe("after construct with parameters", function () {
-		it("should contains id and key", function () {
-			const peer = new Peer("1", { key: "anotherKey" });
-
-			expect(peer.id).to.eq("1");
-			expect(peer.options.key).to.eq("anotherKey");
-
-			peer.destroy();
-		});
-	});
-
-	describe("after call to peer #2", function () {
-		let mockServer;
-
-		before(function () {
-			mockServer = createMockServer();
-		});
-
-		it("Peer#1 should has id #1", function (done) {
-			const peer1 = new Peer("1", { port: 8080, host: "localhost" });
-			expect(peer1.open).to.be.false;
-
-			const mediaOptions = {
-				metadata: { var: "123" },
-				constraints: {
-					mandatory: {
-						OfferToReceiveAudio: true,
-						OfferToReceiveVideo: true,
-					},
-				},
-			};
-
-			const track = new MediaStreamTrack();
-			const mediaStream = new MediaStream([track]);
-
-			const mediaConnection = peer1.call("2", mediaStream, { ...mediaOptions });
-
-			expect(mediaConnection.connectionId).to.be.a("string");
-			expect(mediaConnection.type).to.eq(ConnectionType.Media);
-			expect(mediaConnection.peer).to.eq("2");
-			expect(mediaConnection.options).to.include(mediaOptions);
-			expect(mediaConnection.metadata).to.deep.eq(mediaOptions.metadata);
-			expect(mediaConnection.peerConnection.getSenders()[0].track.id).to.eq(
-				track.id,
-			);
-
-			peer1.once("open", (id) => {
-				expect(id).to.be.eq("1");
-				//@ts-ignore
-				expect(peer1._lastServerId).to.be.eq("1");
-				expect(peer1.disconnected).to.be.false;
-				expect(peer1.destroyed).to.be.false;
-				expect(peer1.open).to.be.true;
-
-				peer1.destroy();
-
-				expect(peer1.disconnected).to.be.true;
-				expect(peer1.destroyed).to.be.true;
-				expect(peer1.open).to.be.false;
-				expect(peer1.connections).to.be.empty;
-
-				done();
-			});
-		});
-
-		after(function () {
-			mockServer.stop();
-		});
-	});
-
-	describe("reconnect", function () {
-		let mockServer;
-
-		before(function () {
-			mockServer = createMockServer();
-		});
-
-		it("connect to server => disconnect => reconnect => destroy", function (done) {
-			const peer1 = new Peer("1", { port: 8080, host: "localhost" });
-
-			peer1.once("open", () => {
-				expect(peer1.open).to.be.true;
-
-				peer1.once("disconnected", () => {
-					expect(peer1.disconnected).to.be.true;
-					expect(peer1.destroyed).to.be.false;
-					expect(peer1.open).to.be.false;
-
-					peer1.once("open", (id) => {
-						expect(id).to.be.eq("1");
-						expect(peer1.disconnected).to.be.false;
-						expect(peer1.destroyed).to.be.false;
-						expect(peer1.open).to.be.true;
-
-						peer1.once("disconnected", () => {
-							expect(peer1.disconnected).to.be.true;
-							expect(peer1.destroyed).to.be.false;
-							expect(peer1.open).to.be.false;
-
-							peer1.once("close", () => {
-								expect(peer1.disconnected).to.be.true;
-								expect(peer1.destroyed).to.be.true;
-								expect(peer1.open).to.be.false;
-
-								done();
-							});
-						});
-
-						peer1.destroy();
-					});
-
-					peer1.reconnect();
-				});
-
-				peer1.disconnect();
-			});
-		});
-
-		it("disconnect => reconnect => destroy", function (done) {
-			mockServer.stop();
-
-			const peer1 = new Peer("1", { port: 8080, host: "localhost" });
-
-			peer1.once("disconnected", (id) => {
-				expect(id).to.be.eq("1");
-				expect(peer1.disconnected).to.be.true;
-				expect(peer1.destroyed).to.be.false;
-				expect(peer1.open).to.be.false;
-
-				peer1.once("open", (id) => {
-					expect(id).to.be.eq("1");
-					expect(peer1.disconnected).to.be.false;
-					expect(peer1.destroyed).to.be.false;
-					expect(peer1.open).to.be.true;
-
-					peer1.once("disconnected", () => {
-						expect(peer1.disconnected).to.be.true;
-						expect(peer1.destroyed).to.be.false;
-						expect(peer1.open).to.be.false;
-
-						peer1.once("close", () => {
-							expect(peer1.disconnected).to.be.true;
-							expect(peer1.destroyed).to.be.true;
-							expect(peer1.open).to.be.false;
-
-							done();
-						});
-					});
-
-					peer1.destroy();
-				});
-
-				mockServer = createMockServer();
-
-				peer1.reconnect();
-			});
-		});
-
-		it("destroy peer if no id and no connection", function (done) {
-			mockServer.stop();
-
-			const peer1 = new Peer({ port: 8080, host: "localhost" });
-
-			peer1.once("error", (_error) => {
-				// expect(error.type).to.be.eq(PeerErrorType.ServerError);
-
-				peer1.once("close", () => {
-					expect(peer1.disconnected).to.be.true;
-					expect(peer1.destroyed).to.be.true;
-					expect(peer1.open).to.be.false;
-
-					done();
-				});
-
-				mockServer = createMockServer();
-			});
-		});
-
-		after(function () {
-			mockServer.stop();
-		});
-	});
-});

test/util.ts

@@ -1,11 +0,0 @@
-import "./setup";
-import { expect } from "chai";
-import { util } from "../lib/util";
-
-describe("util", function () {
-	describe("#chunkedMTU", function () {
-		it("should be 16300", function () {
-			expect(util.chunkedMTU).to.eq(16300);
-		});
-	});
-});