test: run test codemods

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

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