fix: udpates utils/parser test

Author: yowainwright

package.json

@@ -91,7 +91,8 @@
     ],
     "transformIgnorePatterns": [
       "node_modules/(?!node:http)",
-      "node_modules/(?!@jspm/import-map)"
+      "node_modules/(?!@jspm/import-map)",
+      "node_modules/(?!@jspm/generator)"
     ],
     "transform": {
       "^.+\\.(ts)$": "@swc/jest"

src/__tests__/parser.test.ts

@@ -1,8 +1,6 @@
-import * as fs from "node:fs";
-import * as utils from 'src/utils';
 import { parseNodeModuleCachePath } from '../parser';
 
-jest.mock("node:fs");
+import * as fs from "node:fs";
 
 jest.mock("node:path", () => {
   const actual = jest.requireActual("node:path");
@@ -20,21 +18,26 @@ jest.mock("node-fetch", () =>
   })
 );
 
-const mockImportMapResolve = jest.fn();
-
 jest.mock("@jspm/import-map", () => ({
   ImportMap: jest.fn(() => ({
-    resolve: mockImportMapResolve,
+    resolve: jest.fn(),
   })),
 }));
 
-jest.mock("src/utils", () => {
-  const actual = jest.requireActual("src/utils");
+jest.mock('@jspm/generator', () => ({
+  parseUrlPkg: jest.fn(),
+}))
+
+jest.mock("../utils", () => {
+  const actual = jest.requireActual("../utils");
   return {
     __esModule: true,
     ...actual,
   };
 });
+import * as utils from "../utils";
+
+jest.mock('../config')
 
 describe("parseNodeModuleCachePath", () => {
   const cachePath = "file:///path/to/cache";
@@ -43,6 +46,7 @@ describe("parseNodeModuleCachePath", () => {
     return {
       ...actual,
       existsSync: jest.fn(),
+      writeFileSync: jest.fn(),
     };
   });
 
@@ -51,22 +55,20 @@ describe("parseNodeModuleCachePath", () => {
   });
 
   test("should return cachePath if it exists", async () => {
-    (fs.existsSync as jest.Mock).mockReturnValue(true);
+    jest.spyOn(fs, "existsSync").mockReturnValue(true);
     const result = await parseNodeModuleCachePath("modulePath", cachePath);
     expect(result).toBe(cachePath);
   });
 
   test("should make directories and write file if cachePath does not exist", async () => {
-    (fs.existsSync as jest.Mock).mockReturnValue(false);
-    const ensureDirSyncSpy = jest.spyOn(utils, "ensureDirSync");
-    const writeFileSyncSpy = jest.spyOn(fs, "writeFileSync");
+    jest.spyOn(fs, "existsSync").mockReturnValue(false);
+    const ensureFileSyncSpy = jest.spyOn(utils, "ensureFileSync");
     await parseNodeModuleCachePath("modulePath", cachePath);
-    expect(ensureDirSyncSpy).toBeCalled();
-    expect(writeFileSyncSpy).toBeCalledWith(cachePath, "module code");
+    expect(ensureFileSyncSpy).toBeCalled();
   });
 
   test("should return empty string if there is an error", async () => {
-    (fs.existsSync as jest.Mock).mockReturnValue(false);
+    jest.spyOn(fs, "existsSync").mockReturnValue(false);
     await jest.spyOn(fs, "writeFileSync").mockImplementation(() => {
       throw new Error("error");
     });

src/__tests__/utils.test.ts

@@ -1,21 +1,119 @@
+import {
+  checkIfNodeOrFileProtocol,
+  ensureDirSync,
+  ensureFileSync,
+  resolveModulePath,
+  resolveNodeModuleCachePath,
+  resolveParsedModulePath
+} from '../utils';
+
+jest.mock('node:fs');
+jest.mock('node:path');
 import * as fs from "node:fs";
-import { ensureDirSync } from 'src/utils';
+import * as path from "node:path";
+
+jest.mock("@jspm/import-map", () => ({
+  ImportMap: jest.fn(() => ({
+    resolve: jest.fn(),
+  })),
+}));
+
+jest.mock('@jspm/generator', () => ({
+  parseUrlPkg: jest.fn(),
+}))
 
-jest.mock("node:fs");
+import * as generator from '@jspm/generator';
+
+jest.mock('../config')
+import * as config from '../config';
+
+jest.mock('../parser', () => ({
+  parseNodeModuleCachePath: jest.fn(),
+}))
+import * as parser from '../parser';
 
 test("ensureDirSync has dir", () => {
   const dir = "/path/to/dir";
   const existsSyncMock = jest.spyOn(fs, 'existsSync').mockReturnValue(true);
+  const dirnameMock = jest.spyOn(path, 'dirname')
   ensureDirSync(dir);
   expect(existsSyncMock).toBeCalledWith(dir);
-  expect(fs.mkdirSync).not.toBeCalled();
+  expect(dirnameMock).not.toBeCalled();
 });
 
-test("ensureDirSync has no dir", () => {
+test("ensureDirSync has parent dir", () => {
   const dir = "/path/to/dir";
   const existsSyncMock = jest.spyOn(fs, 'existsSync').mockReturnValue(false);
+  const dirnameMock = jest.spyOn(path, 'dirname').mockReturnValue("/path/to/dir");
   const mkdirSyncMock = jest.spyOn(fs, 'mkdirSync')
   ensureDirSync(dir);
   expect(existsSyncMock).toBeCalledWith(dir);
-  expect(mkdirSyncMock).toBeCalledWith(dir);
+  expect(dirnameMock).toBeCalledWith(dir);
+  expect(mkdirSyncMock).toHaveBeenCalledTimes(1);
 });
+
+test("ensureDirSync to have recursion", () => {
+  const dir = "/path/to/dir";
+  const existsSyncMock = jest.spyOn(fs, 'existsSync').mockReturnValue(false);
+  const dirnameMock = jest.spyOn(path, 'dirname').mockReturnValue("/path/");
+  const mkdirSyncMock = jest.spyOn(fs, 'mkdirSync')
+  ensureDirSync(dir);
+  expect(existsSyncMock).toBeCalledWith(dir);
+  expect(dirnameMock).toBeCalledWith(dir);
+  expect(mkdirSyncMock).toHaveBeenCalledTimes(2);
+});
+
+test("ensureFileSync has file", () => {
+  const dir = 'path/to/file';
+  const dirnameMock = jest.spyOn(path, 'dirname').mockReturnValue("/path/to/dir");
+  const existsSyncMock = jest.spyOn(fs, 'existsSync').mockReturnValue(true);
+  const writeFileSyncSpy = jest.spyOn(fs, 'writeFileSync');
+  ensureFileSync(dir);
+  expect(dirnameMock).toBeCalled();
+  expect(existsSyncMock).toBeCalled();
+  expect(writeFileSyncSpy).toBeCalled();
+});
+
+test('checkIfNodeOrFileProtocol returns true', () => {
+  const protocol = 'node:foo';
+  expect(checkIfNodeOrFileProtocol(protocol)).toBeTruthy();
+})
+
+test('checkIfNodeOrFileProtocol returns false', () => {
+  const protocol = 'http:foo';
+  expect(checkIfNodeOrFileProtocol(protocol)).toBeFalsy();
+})
+
+test('resolveModulePath', () => {
+  const specifier = 'foo';
+  const cacheMapPath = 'file:///bar';
+  const resolve = jest.fn().mockReturnValue('file:///bar/foo');
+  (jest.mocked(config).importmap as unknown) = {
+    resolve
+  }
+  const result = resolveModulePath(specifier, cacheMapPath);
+  expect(result).toBe('file:///bar/foo');
+})
+
+test('resolveModulePath with modulePath', async () => {
+  const parseUrlPkgSpy = await jest.spyOn(generator, 'parseUrlPkg').mockResolvedValue({
+    pkg: {
+      name: 'foo',
+      version: '1.0.0',
+    }
+  } as any);
+  (jest.mocked(config).cache as unknown) = 'test/.cache'
+  const modulePath = 'file:///bar/index.js';
+  const joinSpy = jest.spyOn(path, 'join').mockReturnValue('test/.cache/[email protected]/bar/index.js');
+  const result = await resolveNodeModuleCachePath(modulePath);
+  expect(parseUrlPkgSpy).toBeCalledWith(modulePath);
+  expect(joinSpy).toBeCalled();
+  expect(result).toBe('test/.cache/[email protected]/bar/index.js');
+});
+
+test('resolveParsedModulePath', async () => {
+  const parseNodeModuleCachePathSpy = await jest.spyOn(parser, 'parseNodeModuleCachePath').mockResolvedValue('file:///foo/bar');
+  const result = await resolveParsedModulePath('file:///foo/bar', 'file:///foo/bar');
+  expect(parseNodeModuleCachePathSpy).toBeCalled();
+  expect(result).toBe('file:///foo/bar');
+})

src/config.ts

@@ -4,18 +4,19 @@ import { fileURLToPath } from "node:url";
 import { ImportMap } from "@jspm/import-map";
 /**
  * ******************************************************
- * CONFIG
+ * CONFIG 🗺️
  * ------------------------------------------------------
  * @description utility variable assignment
- * @summary utility variables which are assigned 1x. Assigning them here simplifies testability and later configuration if CLI functionality is added.
+ * @summary utility variables which are assigned 1x.
+ * Assigning them here simplifies testability and later configuration if CLI functionality is added.
  *
  * ******************************************************
  */
 export const root = fileURLToPath(`file://${process.cwd()}`);
 export const cacheMap = new Map();
 export const nodeImportMapPath = join(root, "node.importmap");
 export const cache = join(root, ".cache");
-export const map = existsSync(nodeImportMapPath)
+const map = existsSync(nodeImportMapPath)
   ? JSON.parse(readFileSync(nodeImportMapPath, { encoding: "utf8" }))
   : {};
-export const importMap = new ImportMap({ rootUrl: import.meta.url, map });
+export const importmap = new ImportMap({ rootUrl: import.meta.url, map });

src/loader.ts

@@ -9,7 +9,7 @@ import { Context, NextResolve } from "./types";
 
 /**
  * ******************************************************
- * LOADER
+ * LOADER 🚛
  * ------------------------------------------------------
  * @summary loads node modules via an *assumed root working directory with a cache and node.importmap*
  * @notes

src/parser.ts

@@ -4,6 +4,15 @@ import { ensureFileSync } from "src/utils";
 import { IS_DEBUGGING } from "src/constants";
 import { logger } from "src/logger";
 
+/**
+ * ******************************************************
+ * PARSER 🔪
+ * ------------------------------------------------------
+ * @description handles parsing directories for cached paths
+ *
+ * ******************************************************
+ */
+
 const log = logger({ file: "parser", isLogging: IS_DEBUGGING });
 
 /**

src/types.ts

@@ -1,37 +1,9 @@
-import { URL } from "node:url";
-
 export type Context = {
   parentURL?: string;
 };
 
-export type ConstructCachePath = {
-  cache: string;
-  modulePath: string;
-  debug?: boolean;
-  matcher?: RegExp | string;
-};
-
 export type NextResolve = (specifier: string) => Promise<string | unknown>;
 
-export type UrlType = URL;
-
-export type CreateCacheMapFactory = {
-  cachePath?: string;
-  instance: Map<string, string>;
-  isDebugging?: boolean;
-  modulePath?: string;
-  get: (cachePath: string) => string | undefined;
-  set: (cachePath: string, modulePath: string) => void;
-};
-
-export type ResolveOptions = {
-  base?: string;
-  cache?: string;
-  debug?: boolean;
-  importmap?: string;
-  cacheMap?: CreateCacheMapFactory;
-};
-
 export type LoggerOptions = {
   file: string;
   isLogging?: boolean;

src/utils.ts

@@ -1,14 +1,14 @@
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { parseUrlPkg } from "@jspm/generator";
-import { parseNodeModuleCachePath } from "src/parser";
-import { cache, importMap } from "src/config";
-import { IS_DEBUGGING } from "src/constants";
-import { logger } from "src/logger";
+import { parseNodeModuleCachePath } from "./parser";
+import { cache, importmap } from "./config";
+import { IS_DEBUGGING } from "./constants";
+import { logger } from "./logger";
 
 /**
  * ******************************************************
- * UTILS
+ * UTILS 📦
  * ------------------------------------------------------
  * @description a collection of utility functions
  * @summary a collection of utility functions
@@ -44,7 +44,7 @@ export const checkIfNodeOrFileProtocol = (modulePath: string) => {
 };
 
 export const resolveModulePath = (specifier: string, cacheMapPath: string) => {
-  const modulePath = importMap.resolve(specifier, cacheMapPath);
+  const modulePath = importmap.resolve(specifier, cacheMapPath);
   log.debug("resolveModulePath:", { modulePath });
   return modulePath;
 };
@@ -56,7 +56,7 @@ export const resolveNodeModuleCachePath = async (modulePath: string) => {
     const version = moduleMetadata?.pkg?.version;
     const moduleFile = modulePath.split("/").reverse()[0] || "";
     const nodeModuleCachePath = join(cache, `${name}@${version}`, moduleFile);
-    log.debug("resolveNodeModuleCachePath:", { moduleMetadata, name, version, nodeModuleCachePath });
+    log.debug("resolveNodeModuleCachePath:", { nodeModuleCachePath });
     return nodeModuleCachePath;
   } catch (err) {
     log.error("resolveNodeModuleCachePath:", err);

tsconfig.json

@@ -30,5 +30,5 @@
     "types": ["jest", "node"]
   },
   "include": ["src/**/*"],
-  "exclude": ["tests/*.ts", "tests/e2e/*.js"]
+  "exclude": ["src/__tests__/*.ts", "tests/e2e/*.js"]
 }