test: replace jest with node test runner

Author: danielpza

src/utils/get-relative-path.ts

@@ -47,7 +47,7 @@ function getIsFsCaseSensitive() {
 }
 
 /** @private The Export is only for unit tests */
-export function getMatchPortion(from: string, to: string) {
+export function getMatchPortion(from: string, to: string): string {
   const lowerFrom = from.toLocaleLowerCase();
   const lowerTo = to.toLocaleLowerCase();
 

test/jest.config.ts

@@ -2,22 +2,17 @@
   "private": true,
   "license": "MIT",
   "scripts": {
-    "test": "jest",
-    "g:ts-node": "cd $INIT_CWD && ts-node",
+    "test": "node --test --import tsx 'tests/**/*.test.ts'",
     "postinstall": "node prepare.mjs"
   },
   "devDependencies": {
-    "@nrwl/cli": "^15.9.7",
-    "@nrwl/js": "^15.9.7",
-    "@nrwl/node": "^15.9.7",
-    "@nrwl/workspace": "^15.9.7",
     "@tsconfig/node18": "^18.2.4",
-    "@types/jest": "^29.5.14",
+    "@tsconfig/node22": "^22.0.2",
+    "@types/node": "^24.3.0",
     "@types/ts-expose-internals": "npm:ts-expose-internals@^4.9.5",
-    "jest": "^29.7.0",
-    "ts-jest": "^29.2.4",
-    "ts-node": "^10.9.2",
+    "escape-string-regexp": "^5.0.0",
     "ts-patch": "^3.3.0",
+    "tsx": "^4.20.4",
     "typescript": "^5.7.2",
     "typescript-transform-paths": "portal:../"
   },

test/package.json

@@ -1,22 +1,10 @@
 // @ts-check
-import { existsSync } from "node:fs";
-import { symlink } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { patch } from "ts-patch";
 
 const __dirname = dirname(fileURLToPath(import.meta.url)); // https://stackoverflow.com/questions/46745014/alternative-for-dirname-in-node-js-when-using-es6-modules
 
-async function symlinkTsNode() {
-  // we need to patch the root package node_modules in order for it to locate ts-node for the register tests.
-  // installing ts-node as a depenency in the root is not an option since it would create two copies of ts-node
-  // thus messing with the mocks in the tests
-  const target = resolve(__dirname, "node_modules/ts-node");
-  const path = resolve(__dirname, "../node_modules/ts-node");
-
-  if (!existsSync(path)) await symlink(target, path, "junction");
-}
-
 function patchTsModules() {
   const rootDir = __dirname;
 
@@ -30,4 +18,3 @@ function patchTsModules() {
 }
 
 patchTsModules();
-await symlinkTsNode();

test/prepare.mjs

@@ -1,8 +1,9 @@
+import { describe, test } from "node:test";
 import { getMatchPortion } from "../../src/utils/get-relative-path";
 
 describe(`getMatchPortion`, () => {
-  it("works in a simple case", () => {
-    expect(getMatchPortion("/foo/bar", "/foo/quux")).toBe("/foo/");
+  test("works in a simple case", (t) => {
+    t.assert.equal(getMatchPortion("/foo/bar", "/foo/quux"), "/foo/");
   });
 
   // We use the function getMatchPortion to generate a new path for “to”, so let’s preserve
@@ -11,8 +12,8 @@ describe(`getMatchPortion`, () => {
   // their file is named Foo, but we rewrite the path to foo.
   // Although the file is still accessible in the file system, other tools might reasonably
   // complain about the unexpected case mismatch.
-  it("prioritizes the casing of the “to” parameter", () => {
-    expect(getMatchPortion("/foo/bar", "/foO/quux")).toBe("/foO/");
-    expect(getMatchPortion("/foo/bar", "/foo/Bonk")).toBe("/foo/B");
+  test('prioritizes the casing of the "to" parameter', (t) => {
+    t.assert.equal(getMatchPortion("/foo/bar", "/foO/quux"), "/foO/");
+    t.assert.equal(getMatchPortion("/foo/bar", "/foo/Bonk"), "/foo/B");
   });
 });

test/tests/get-match-portion.test.ts

@@ -1,5 +1,6 @@
 // noinspection ES6UnusedImports
 import * as path from "node:path";
+import { describe, test, before } from "node:test";
 import { createTsSolutionBuilder, EmittedFiles } from "../utils";
 import { projectsPaths, ts } from "../config";
 
@@ -19,18 +20,18 @@ const indexFile = ts.normalizePath(path.join(projectDir, "lib/b/index.ts"));
 describe(`Project References`, () => {
   let emittedFiles: EmittedFiles;
 
-  beforeAll(() => {
+  before(() => {
     const builder = createTsSolutionBuilder({ tsInstance: ts, projectDir });
     emittedFiles = builder.getEmitFiles();
   });
 
-  test(`Specifier for referenced project file resolves properly`, () => {
-    expect(emittedFiles[indexFile].js).toMatch(`export { AReffedConst } from "../a/index"`);
-    expect(emittedFiles[indexFile].dts).toMatch(`export { AReffedConst } from "../a/index"`);
+  test(`Specifier for referenced project file resolves properly`, (t) => {
+    t.assert.match(emittedFiles[indexFile].js, /export { AReffedConst } from "..\/a\/index"/);
+    t.assert.match(emittedFiles[indexFile].dts, /export { AReffedConst } from "..\/a\/index"/);
   });
 
-  test(`Specifier for local file resolves properly`, () => {
-    expect(emittedFiles[indexFile].js).toMatch(`export { LocalConst } from "./local/index"`);
-    expect(emittedFiles[indexFile].dts).toMatch(`export { LocalConst } from "./local/index"`);
+  test(`Specifier for local file resolves properly`, (t) => {
+    t.assert.match(emittedFiles[indexFile].js, /export { LocalConst } from ".\/local\/index"/);
+    t.assert.match(emittedFiles[indexFile].dts, /export { LocalConst } from ".\/local\/index"/);
   });
 });

test/tests/project-ref.test.ts

@@ -1,5 +1,6 @@
 // noinspection ES6UnusedImports
 import * as path from "node:path";
+import { describe, before, test } from "node:test";
 import { createTsProgram, EmittedFiles, getEmitResultFromProgram } from "../../utils";
 import { ts, tsModules, projectsPaths } from "../../config";
 
@@ -30,33 +31,36 @@ describe(`Transformer -> General Tests`, () => {
   const projectRoot = path.join(projectsPaths, "general");
   const tsConfigFile = path.join(projectRoot, "tsconfig.json");
 
-  describe.each(tsModules)(`TypeScript %s`, (s, tsInstance) => {
-    let originalFiles: EmittedFiles = {};
-    let transformedFiles: EmittedFiles = {};
+  for (const [s, tsInstance] of tsModules)
+    describe(`TypeScript ${s}`, () => {
+      let originalFiles: EmittedFiles = {};
+      let transformedFiles: EmittedFiles = {};
 
-    const program = createTsProgram({ tsInstance: tsInstance as typeof ts, tsConfigFile, disablePlugin: true });
-    const programWithTransformer = createTsProgram({ tsInstance: tsInstance as typeof ts, tsConfigFile });
-    const fileNames = program.getRootFileNames() as string[];
+      const program = createTsProgram({ tsInstance: tsInstance as typeof ts, tsConfigFile, disablePlugin: true });
+      const programWithTransformer = createTsProgram({ tsInstance: tsInstance as typeof ts, tsConfigFile });
+      const fileNames = program.getRootFileNames() as string[];
 
-    beforeAll(() => {
-      originalFiles = getEmitResultFromProgram(program);
-      transformedFiles = getEmitResultFromProgram(programWithTransformer);
-    });
+      before(() => {
+        originalFiles = getEmitResultFromProgram(program);
+        transformedFiles = getEmitResultFromProgram(programWithTransformer);
+      });
 
-    describe.each(fileNames!.map((p) => [p.slice(projectRoot.length), p]))(`%s`, (_, file) => {
-      let expected: EmittedFiles[string];
-      let transformed: EmittedFiles[string];
+      for (const file of fileNames!) {
+        describe(file, () => {
+          let expected: EmittedFiles[string];
+          let transformed: EmittedFiles[string];
 
-      beforeAll(() => {
-        transformed = transformedFiles[file];
-        expected = {
-          js: getExpected(tsInstance, file, originalFiles[file].js, projectRoot),
-          dts: getExpected(tsInstance, file, originalFiles[file].dts, projectRoot),
-        };
-      });
+          before(() => {
+            transformed = transformedFiles[file];
+            expected = {
+              js: getExpected(tsInstance, file, originalFiles[file].js, projectRoot),
+              dts: getExpected(tsInstance, file, originalFiles[file].dts, projectRoot),
+            };
+          });
 
-      test(`js matches`, () => expect(transformed.js).toEqual(expected.js));
-      test(`dts matches`, () => expect(transformed.dts).toEqual(expected.dts));
+          test(`js matches`, (t) => t.assert.strictEqual(transformed.js, expected.js));
+          test(`dts matches`, (t) => t.assert.strictEqual(transformed.dts, expected.dts));
+        });
+      }
     });
-  });
 });