Migrate all tests to built-in Nodejs test runner

This will get rid of the dependency on Mocha and all dependency vulnerabilities

Author: patrickjuchli

package-lock.json

@@ -8,16 +8,16 @@
     "dist/**/*"
   ],
   "scripts": {
-    "prepublishOnly": "npm run clean && npm run lint && tsc && mocha",
+    "prepublishOnly": "npm run clean && npm run lint && tsc && node --test 'test/*Spec.js'",
     "prepare": "tsc",
     "test": "npm run prepublishOnly",
     "clean": "rm -rf dist",
     "lint": "eslint \"./src/**/*.ts\"",
     "lint-fix": "eslint --fix \"./src/**/*.ts\"",
     "dev": "npm run clean && tsc --watch",
-    "tdd": "mocha --watch",
+    "tdd": "node --test --watch 'test/*Spec.js'",
     "buildOnly": "tsc",
-    "test:integration": "npm run buildOnly && mocha 'test/integration/**Spec.js'"
+    "test:integration": "npm run buildOnly && node --test 'test/integration/**Spec.js'"
   },
   "repository": {
     "type": "git",
@@ -41,13 +41,11 @@
   "devDependencies": {
     "@eslint/eslintrc": "3.3.5",
     "@eslint/js": "10.0.1",
-    "@types/mocha": "10.0.10",
     "@types/node": "25.9.1",
     "@typescript-eslint/eslint-plugin": "8.59.4",
     "@typescript-eslint/parser": "8.59.4",
     "eslint": "10.4.0",
     "globals": "17.6.0",
-    "mocha": "11.7.5",
     "testcontainers": "11.14.0",
     "typescript": "6.0.3"
   }

package.json

@@ -1,3 +1,4 @@
+const { describe, it } = require("node:test");
 const assert = require("assert");
 
 describe("Canary", function() {

test/canarySpec.js

@@ -1,3 +1,4 @@
+const { describe, it, beforeEach, afterEach } = require("node:test");
 const assert = require("assert");
 const { Client } = require("../dist");
 const MockFtpServer = require("./MockFtpServer");
@@ -13,124 +14,126 @@ const NO_FEAT_REPLY = `
 `;
 const FILENAME = "file.txt"
 
-describe("Simple commands", function() {
+describe("Simple commands", () => {
 
-    this.beforeEach(() => {
-        this.server = new MockFtpServer()
-        this.client = new Client(1000)
-        return this.client.access({
-            port: this.server.ctrlAddress.port,
+    let server, client;
+
+    beforeEach(() => {
+        server = new MockFtpServer()
+        client = new Client(1000)
+        return client.access({
+            port: server.ctrlAddress.port,
             user: "test",
             password: "test"
         })
     })
 
-    this.afterEach(() => {
-        this.client.close()
-        this.server.close()
+    afterEach(() => {
+        client.close()
+        server.close()
     })
 
     it("can get a file size", () => {
-        this.server.addHandlers({
-            "size": ({arg}) => arg === "file.txt" ? "213 6666" : "400 File not found"  
+        server.addHandlers({
+            "size": ({arg}) => arg === "file.txt" ? "213 6666" : "400 File not found"
         })
-        return this.client.size("file.txt").then(result => {
+        return client.size("file.txt").then(result => {
             assert.strictEqual(result, 6666)
         })
     })
 
     it("can get last modified time", () => {
-        this.server.addHandlers({
+        server.addHandlers({
             "mdtm": ({arg}) => arg === "file.txt" ? "213 19951217032400" : "400 File not found"
         })
-        return this.client.lastMod("file.txt").then(result => {
+        return client.lastMod("file.txt").then(result => {
             assert.deepEqual(result, new Date("1995-12-17T03:24:00+0000"))
-        }) 
+        })
     })
 
     it("can get features", () => {
-        this.server.addHandlers({
+        server.addHandlers({
             "feat": () => FEAT_REPLY
         })
-        return this.client.features().then(result => {
+        return client.features().then(result => {
             assert.deepEqual(result, new Map([["MLST", "size*;create"], ["SIZE", ""]]))
-        })         
+        })
     })
 
     it("can handle no features", () => {
-        this.server.addHandlers({
+        server.addHandlers({
             "feat": () => NO_FEAT_REPLY
         })
-        return this.client.features().then(result => {
+        return client.features().then(result => {
             assert.deepEqual(result, new Map())
-        })         
+        })
     })
 
     it("returns empty feature set when server sends error", () => {
-        this.server.addHandlers({
+        server.addHandlers({
             "test": () => "200 OK"
         })
-        return this.client.send("TEST").then(result => {
+        return client.send("TEST").then(result => {
             assert.deepEqual(result, { code: 200, message: "200 OK" })
-        })         
+        })
     })
 
     it("sending command handles error", () => {
-        this.server.addHandlers({
+        server.addHandlers({
             "test": () => "500 Command unknown"
         })
-        return assert.rejects(() => this.client.send("TEST"), {
+        return assert.rejects(() => client.send("TEST"), {
             name: "FTPError",
             message: "500 Command unknown"
-        })       
+        })
     })
 
     it("can ignore error response ", () => {
-        this.server.addHandlers({
+        server.addHandlers({
             "test": () => "500 Command unknown"
         })
-        return assert.doesNotReject(() => this.client.sendIgnoringError("TEST"))       
+        return assert.doesNotReject(() => client.sendIgnoringError("TEST"))
     })
 
     it("throws if connection error even if ignoring errors has been requested", () => {
-        this.server.addHandlers({
-            "test": () => this.server.ctrlConn.destroy()
+        server.addHandlers({
+            "test": () => server.ctrlConn.destroy()
         })
-        return assert.rejects(() => this.client.send("TEST"), {
+        return assert.rejects(() => client.send("TEST"), {
             name: "Error",
             message: "Server sent FIN packet unexpectedly, closing connection."
-        })       
+        })
     })
 
     it("can rename a file", () => {
-        this.server.addHandlers({
+        server.addHandlers({
             "rnfr": ({arg}) => arg === "old.txt" ? "350 Accepted" : "500 File not found",
             "rnto": ({arg}) => arg === "new.txt" ? "200 Renamed" : "500 File not found",
         })
-        return this.client.rename("old.txt", "new.txt").then(result => {
+        return client.rename("old.txt", "new.txt").then(result => {
             assert.deepEqual(result, { code: 200, message: "200 Renamed" })
         })
     })
-        
+
     it("can handle leading whitespace in a filename", () => {
-        this.server.addHandlers({
+        server.addHandlers({
             "pwd": () => `257 "/this/that"`
         })
-        return this.client.protectWhitespace("  file.txt").then(result => {
+        return client.protectWhitespace("  file.txt").then(result => {
             assert.strictEqual(result, "/this/that/  file.txt")
         })
     })
 
     it("can handle leading whitespace in relative path", () => {
-        this.server.addHandlers({
+        server.addHandlers({
             "pwd": () => `257 "/this/that"`
         })
-        return this.client.protectWhitespace(" a/b").then(result => {
+        return client.protectWhitespace(" a/b").then(result => {
             assert.strictEqual(result, "/this/that/ a/b")
         })
     })
 
-    it("can remove a file")
-    it("can change directory")
-    it("can get the current working directory")
-})
+    it.todo("can remove a file")
+    it.todo("can change directory")
+    it.todo("can get the current working directory")
+})

test/commandSpec.js

@@ -1,32 +1,35 @@
+const { describe, it, beforeEach, afterEach } = require("node:test");
 const assert = require("assert");
 const { Client } = require("../dist");
 const MockFtpServer = require("./MockFtpServer");
 
-describe("Connectivity", function() {
+describe("Connectivity", () => {
 
-    this.beforeEach(() => {
-        this.server = new MockFtpServer()
-        this.client = new Client(50)
+    let server, client;
+
+    beforeEach(() => {
+        server = new MockFtpServer()
+        client = new Client(50)
     })
 
-    this.afterEach(() => {
-        this.client.close()
-        this.server.close()
+    afterEach(() => {
+        client.close()
+        server.close()
     })
 
     it("throws error when sending before connecting", () => {
-        return assert.rejects(() => this.client.send("hi"), {
+        return assert.rejects(() => client.send("hi"), {
             message: "Socket is closed (control socket)"
         })
     })
 
     it("handles closing uninitialized socket", () => {
-        this.client.close()
+        client.close()
     })
 
     it("can access a server", () => {
-        return this.client.access({
-            port: this.server.ctrlAddress.port,
+        return client.access({
+            port: server.ctrlAddress.port,
             user: "test",
             password: "test"
         }).then(result => {
@@ -35,24 +38,24 @@ describe("Connectivity", function() {
     });
 
     it("throws on timeout when accessing a server", () => {
-        return assert.rejects(() => this.client.access({
+        return assert.rejects(() => client.access({
             host: "192.168.0.123"
         }), {
             message: "Timeout (control socket)"
         })
     })
 
     it("throws if connection failed", () => {
-        return assert.rejects(() => this.client.access({
+        return assert.rejects(() => client.access({
             port: 111
         }), {
             code: "ECONNREFUSED"
         })
     })
 
     it("throws if password wrong", () => {
-        return assert.rejects(() => this.client.access({
-            port: this.server.ctrlAddress.port,
+        return assert.rejects(() => client.access({
+            port: server.ctrlAddress.port,
             user: "test",
             password: "WRONGPASSWORD"
         }), {
@@ -62,8 +65,8 @@ describe("Connectivity", function() {
     })
 
     it("throws if user unknown", () => {
-        return assert.rejects(() => this.client.access({
-            port: this.server.ctrlAddress.port,
+        return assert.rejects(() => client.access({
+            port: server.ctrlAddress.port,
             user: "UNKNOWNUSER",
             password: "test"
         }), {
@@ -73,17 +76,17 @@ describe("Connectivity", function() {
     })
 
     it("access executes default set of commands", () => {
-        this.server.handlers = {
+        server.handlers = {
             // Set the minimum required commands, not all default settings need to succeed.
             user: () => "200 OK",
             type: () => "200 OK"
         }
-        return this.client.access({
-            port: this.server.ctrlAddress.port,
+        return client.access({
+            port: server.ctrlAddress.port,
             user: "test",
             password: "test"
         }).then(() => {
-            assert.deepEqual(this.server.receivedCommands, [
+            assert.deepEqual(server.receivedCommands, [
                 "OPTS UTF8 ON",
                 "USER test",
                 "FEAT",
@@ -95,21 +98,21 @@ describe("Connectivity", function() {
     });
 
     it("client reflects closed state correctly", async () => {
-        assert.strictEqual(this.client.closed, true, "before access")
-        await this.client.access({
-            port: this.server.ctrlAddress.port,
+        assert.strictEqual(client.closed, true, "before access")
+        await client.access({
+            port: server.ctrlAddress.port,
             user: "test",
             password: "test"
         })
-        assert.strictEqual(this.client.closed, false, "after access")
-        this.client.close()
-        assert.strictEqual(this.client.closed, true, "after close")
-        return assert.rejects(() => this.client.send("TYPE I"), {
+        assert.strictEqual(client.closed, false, "after access")
+        client.close()
+        assert.strictEqual(client.closed, true, "after close")
+        return assert.rejects(() => client.send("TYPE I"), {
             name: "Error",
             message: "Client is closed because User closed client"
         })
     });
 
-    it("can connect using explicit TLS")
-    it("can connect using implicit TLS")
-})
+    it.todo("can connect using explicit TLS")
+    it.todo("can connect using implicit TLS")
+})