@forwardimpact/libutil 0.1.72 → 0.1.73

package/test/finder.test.js

@@ -1,358 +0,0 @@
-import { test, describe, beforeEach, afterEach, mock } from "node:test";
-import assert from "node:assert";
-import fs from "fs";
-import fsPromises from "fs/promises";
-import path from "path";
-import { fileURLToPath } from "url";
-
-import { createMockLogger } from "@forwardimpact/libharness";
-
-// Module under test
-import { Finder } from "../finder.js";
-
-describe("Finder", () => {
-  let mockLogger;
-  let mockProcess;
-  let finder;
-  let tempDir;
-
-  beforeEach(() => {
-    mockLogger = createMockLogger();
-
-    mockProcess = {
-      cwd: () => "/test/project",
-    };
-
-    finder = new Finder(fsPromises, mockLogger, mockProcess);
-
-    // Create a temporary directory for testing
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = path.dirname(__filename);
-    tempDir = path.join(__dirname, ".tmp-linker-test");
-
-    // Clean up any existing temp directory
-    if (fs.existsSync(tempDir)) {
-      fs.rmSync(tempDir, { recursive: true, force: true });
-    }
-    fs.mkdirSync(tempDir, { recursive: true });
-  });
-
-  afterEach(() => {
-    // Clean up temp directory
-    if (fs.existsSync(tempDir)) {
-      fs.rmSync(tempDir, { recursive: true, force: true });
-    }
-  });
-
-  describe("constructor", () => {
-    test("creates Finder with fs, logger and process", () => {
-      const finder = new Finder(fsPromises, mockLogger, mockProcess);
-
-      assert.ok(finder instanceof Finder);
-    });
-
-    test("validates fs parameter", () => {
-      assert.throws(() => new Finder(), {
-        message: /fs is required/,
-      });
-      assert.throws(() => new Finder(null), {
-        message: /fs is required/,
-      });
-    });
-
-    test("validates logger parameter", () => {
-      assert.throws(() => new Finder(fsPromises), {
-        message: /logger is required/,
-      });
-      assert.throws(() => new Finder(fsPromises, null), {
-        message: /logger is required/,
-      });
-    });
-
-    test("validates process parameter", () => {
-      assert.throws(() => new Finder(fsPromises, mockLogger, null), {
-        message: /process is required/,
-      });
-    });
-
-    test("uses global process when not provided", () => {
-      const finder = new Finder(fsPromises, mockLogger);
-      assert.ok(finder instanceof Finder);
-    });
-  });
-
-  describe("findUpward", () => {
-    test("finds file in current directory", () => {
-      // Create test structure
-      const testFile = path.join(tempDir, "target.txt");
-      fs.writeFileSync(testFile, "test");
-
-      const result = finder.findUpward(tempDir, "target.txt");
-
-      assert.strictEqual(result, testFile);
-    });
-
-    test("finds file in parent directory", () => {
-      // Create test structure
-      const subDir = path.join(tempDir, "subdir");
-      fs.mkdirSync(subDir);
-      const testFile = path.join(tempDir, "target.txt");
-      fs.writeFileSync(testFile, "test");
-
-      const result = finder.findUpward(subDir, "target.txt");
-
-      assert.strictEqual(result, testFile);
-    });
-
-    test("returns null when file not found", () => {
-      const result = finder.findUpward(tempDir, "nonexistent.txt");
-
-      assert.strictEqual(result, null);
-    });
-
-    test("respects maxDepth parameter", () => {
-      // Create nested structure
-      const deepDir = path.join(tempDir, "a", "b", "c");
-      fs.mkdirSync(deepDir, { recursive: true });
-      const testFile = path.join(tempDir, "target.txt");
-      fs.writeFileSync(testFile, "test");
-
-      // Should not find with maxDepth of 2
-      const result = finder.findUpward(deepDir, "target.txt", 2);
-
-      assert.strictEqual(result, null);
-    });
-  });
-
-  describe("findProjectRoot", () => {
-    test("finds project root with package.json", () => {
-      // Create test project structure
-      const projectRoot = path.join(tempDir, "project");
-      const packagesDir = path.join(projectRoot, "packages", "somepackage");
-      fs.mkdirSync(packagesDir, { recursive: true });
-      fs.writeFileSync(path.join(projectRoot, "package.json"), "{}");
-
-      // Test from the package directory (3 levels deep from project root)
-      const result = finder.findProjectRoot(packagesDir);
-
-      assert.strictEqual(result, projectRoot);
-    });
-
-    test("throws error when project root not found", () => {
-      // Create a directory structure without package.json at any level
-      const deepDir = path.join(tempDir, "no-project", "deep", "dir");
-      fs.mkdirSync(deepDir, { recursive: true });
-
-      assert.throws(() => finder.findProjectRoot(deepDir), {
-        message: /Could not find project root/,
-      });
-    });
-  });
-
-  describe("createSymlink", () => {
-    test("creates symlink between directories", async () => {
-      const sourceDir = path.join(tempDir, "source");
-      const targetPath = path.join(tempDir, "target");
-
-      await finder.createSymlink(sourceDir, targetPath);
-
-      assert.ok(fs.existsSync(targetPath));
-      assert.ok(fs.lstatSync(targetPath).isSymbolicLink());
-      assert.strictEqual(mockLogger.debug.mock.calls.length, 1);
-      assert.ok(
-        mockLogger.debug.mock.calls[0].arguments[1].includes("Created symlink"),
-      );
-    });
-
-    test("removes existing target before creating symlink", async () => {
-      const sourceDir = path.join(tempDir, "source");
-      const targetPath = path.join(tempDir, "target");
-
-      // Create existing target directory
-      fs.mkdirSync(targetPath);
-      fs.writeFileSync(path.join(targetPath, "existing.txt"), "test");
-
-      await finder.createSymlink(sourceDir, targetPath);
-
-      assert.ok(fs.existsSync(targetPath));
-      assert.ok(fs.lstatSync(targetPath).isSymbolicLink());
-      // Original file should be gone
-      assert.ok(!fs.existsSync(path.join(targetPath, "existing.txt")));
-    });
-
-    test("removes existing symlink before creating new one", async () => {
-      const sourceDir = path.join(tempDir, "source");
-      const oldSourceDir = path.join(tempDir, "old-source");
-      const targetPath = path.join(tempDir, "target");
-
-      // Create old symlink
-      fs.mkdirSync(oldSourceDir);
-      fs.symlinkSync(oldSourceDir, targetPath, "dir");
-
-      await finder.createSymlink(sourceDir, targetPath);
-
-      assert.ok(fs.existsSync(targetPath));
-      assert.ok(fs.lstatSync(targetPath).isSymbolicLink());
-      // Should point to new source
-      assert.strictEqual(fs.readlinkSync(targetPath), sourceDir);
-    });
-  });
-
-  describe("createPackageSymlinks", () => {
-    test("creates symlinks when project root is found", async () => {
-      // Mock findProjectRoot to return a valid path
-      const originalFindProjectRoot = finder.findProjectRoot;
-      finder.findProjectRoot = mock.fn(() => {
-        const projectRoot = path.join(tempDir, "project");
-        const packagesDir = path.join(projectRoot, "packages");
-        fs.mkdirSync(path.join(packagesDir, "libtype"), { recursive: true });
-        fs.mkdirSync(path.join(packagesDir, "librpc"), { recursive: true });
-        return projectRoot;
-      });
-
-      const generatedPath = path.join(tempDir, "generated");
-
-      await finder.createPackageSymlinks(generatedPath);
-
-      // Should have called findProjectRoot
-      assert.strictEqual(finder.findProjectRoot.mock.calls.length, 1);
-
-      // Restore original method
-      finder.findProjectRoot = originalFindProjectRoot;
-    });
-
-    test("creates symlinks for standard packages", async () => {
-      // Create mock project structure
-      const projectRoot = path.join(tempDir, "project");
-      const packagesDir = path.join(projectRoot, "packages");
-      fs.mkdirSync(path.join(packagesDir, "libtype"), { recursive: true });
-      fs.mkdirSync(path.join(packagesDir, "librpc"), { recursive: true });
-
-      // Mock findProjectRoot
-      const originalFindProjectRoot = finder.findProjectRoot;
-      finder.findProjectRoot = mock.fn(() => projectRoot);
-
-      const generatedPath = path.join(tempDir, "generated");
-      fs.mkdirSync(generatedPath, { recursive: true });
-
-      await finder.createPackageSymlinks(generatedPath);
-
-      // Check that symlinks were created
-      const libtypeTarget = path.join(packagesDir, "libtype", "generated");
-      const librpcTarget = path.join(packagesDir, "librpc", "generated");
-
-      assert.ok(fs.existsSync(libtypeTarget));
-      assert.ok(fs.lstatSync(libtypeTarget).isSymbolicLink());
-      assert.ok(fs.existsSync(librpcTarget));
-      assert.ok(fs.lstatSync(librpcTarget).isSymbolicLink());
-
-      assert.ok(
-        mockLogger.debug.mock.calls.some((call) =>
-          call.arguments[1].includes("Created symlink"),
-        ),
-      );
-
-      // Restore original method
-      finder.findProjectRoot = originalFindProjectRoot;
-    });
-  });
-
-  describe("findData", () => {
-    test("finds data/ in CWD via findUpward", () => {
-      const dataDir = path.join(tempDir, "data");
-      fs.mkdirSync(dataDir);
-
-      const cwdFinder = new Finder(fsPromises, mockLogger, {
-        cwd: () => tempDir,
-      });
-      const result = cwdFinder.findData("data", "/nonexistent-home");
-
-      assert.strictEqual(result, dataDir);
-    });
-
-    test("finds data/ in a parent directory via findUpward", () => {
-      const dataDir = path.join(tempDir, "data");
-      fs.mkdirSync(dataDir);
-      const subDir = path.join(tempDir, "products", "pathway");
-      fs.mkdirSync(subDir, { recursive: true });
-
-      const cwdFinder = new Finder(fsPromises, mockLogger, {
-        cwd: () => subDir,
-      });
-      const result = cwdFinder.findData("data", "/nonexistent-home");
-
-      assert.strictEqual(result, dataDir);
-    });
-
-    test("falls back to ~/.fit/data/ when CWD traversal fails", () => {
-      const fakeHome = path.join(tempDir, "fakehome");
-      const homeFitData = path.join(fakeHome, ".fit", "data");
-      fs.mkdirSync(homeFitData, { recursive: true });
-
-      const isolatedDir = path.join(tempDir, "isolated");
-      fs.mkdirSync(isolatedDir);
-
-      const cwdFinder = new Finder(fsPromises, mockLogger, {
-        cwd: () => isolatedDir,
-      });
-      const result = cwdFinder.findData("data", fakeHome);
-
-      assert.strictEqual(result, homeFitData);
-    });
-
-    test("throws when neither CWD traversal nor HOME fallback finds directory", () => {
-      const isolatedDir = path.join(tempDir, "isolated");
-      fs.mkdirSync(isolatedDir);
-
-      const cwdFinder = new Finder(fsPromises, mockLogger, {
-        cwd: () => isolatedDir,
-      });
-
-      assert.throws(() => cwdFinder.findData("data", "/nonexistent-home"), {
-        message: /No data directory found/,
-      });
-    });
-
-    test("CWD takes priority over HOME when both exist", () => {
-      const cwdData = path.join(tempDir, "data");
-      fs.mkdirSync(cwdData);
-
-      const fakeHome = path.join(tempDir, "fakehome");
-      const homeFitData = path.join(fakeHome, ".fit", "data");
-      fs.mkdirSync(homeFitData, { recursive: true });
-
-      const cwdFinder = new Finder(fsPromises, mockLogger, {
-        cwd: () => tempDir,
-      });
-      const result = cwdFinder.findData("data", fakeHome);
-
-      assert.strictEqual(result, cwdData);
-    });
-  });
-
-  describe("findPackagePath", () => {
-    test("finds package in local monorepo structure", () => {
-      // Create mock monorepo structure
-      const projectRoot = path.join(tempDir, "project");
-      const packagePath = path.join(projectRoot, "packages", "libtype");
-      fs.mkdirSync(packagePath, { recursive: true });
-
-      const result = finder.findPackagePath(projectRoot, "libtype");
-
-      assert.strictEqual(result, packagePath);
-    });
-  });
-
-  describe("findGeneratedPath", () => {
-    test("returns generated directory path for package", () => {
-      // Create mock structure
-      const projectRoot = path.join(tempDir, "project");
-      const packagePath = path.join(projectRoot, "packages", "libtype");
-      fs.mkdirSync(packagePath, { recursive: true });
-
-      const result = finder.findGeneratedPath(projectRoot, "libtype");
-
-      assert.strictEqual(result, path.join(packagePath, "generated"));
-    });
-  });
-});

package/test/http.test.js

@@ -1,93 +0,0 @@
-import { test, describe } from "node:test";
-import assert from "node:assert";
-import { parseJsonBody } from "../http.js";
-
-/**
- * Creates a mock HTTP request object with event emitter behavior
- * @param {object} options - Request options
- * @returns {object} Mock request object
- */
-function createMockRequest(options = {}) {
-  const { body = {} } = options;
-  const bodyStr = JSON.stringify(body);
-  let dataCallback;
-  let endCallback;
-  let errorCallback;
-
-  return {
-    on: (event, callback) => {
-      if (event === "data") dataCallback = callback;
-      if (event === "end") endCallback = callback;
-      if (event === "error") errorCallback = callback;
-    },
-    simulateBody: () => {
-      if (dataCallback) dataCallback(bodyStr);
-      if (endCallback) endCallback();
-    },
-    simulateError: (err) => {
-      if (errorCallback) errorCallback(err);
-    },
-  };
-}
-
-describe("parseJsonBody", () => {
-  test("parses valid JSON body", async () => {
-    const req = createMockRequest({
-      body: { message: "Hello", correlationId: "123" },
-    });
-
-    const parsePromise = parseJsonBody(req);
-    req.simulateBody();
-    const result = await parsePromise;
-
-    assert.deepStrictEqual(result, { message: "Hello", correlationId: "123" });
-  });
-
-  test("returns empty object for invalid JSON", async () => {
-    const req = createMockRequest({ body: {} });
-    let dataCallback;
-    let endCallback;
-
-    req.on = (event, callback) => {
-      if (event === "data") dataCallback = callback;
-      if (event === "end") endCallback = callback;
-    };
-
-    const parsePromise = parseJsonBody(req);
-    dataCallback("not valid json {{{");
-    endCallback();
-    const result = await parsePromise;
-
-    assert.deepStrictEqual(result, {});
-  });
-
-  test("rejects on request error", async () => {
-    const req = createMockRequest({ body: {} });
-    const testError = new Error("Connection reset");
-
-    const parsePromise = parseJsonBody(req);
-    req.simulateError(testError);
-
-    await assert.rejects(() => parsePromise, {
-      message: "Connection reset",
-    });
-  });
-
-  test("handles empty body", async () => {
-    const req = createMockRequest({ body: {} });
-    let dataCallback;
-    let endCallback;
-
-    req.on = (event, callback) => {
-      if (event === "data") dataCallback = callback;
-      if (event === "end") endCallback = callback;
-    };
-
-    const parsePromise = parseJsonBody(req);
-    dataCallback("");
-    endCallback();
-    const result = await parsePromise;
-
-    assert.deepStrictEqual(result, {});
-  });
-});

package/test/libutil.test.js

@@ -1,35 +0,0 @@
-import { describe, test, mock } from "node:test";
-import assert from "node:assert";
-
-// Module under test
-import { createBundleDownloader } from "../index.js";
-
-const noop = () => {};
-const mockLogger = { info: noop, debug: noop, warn: noop, error: noop };
-
-describe("libutil", () => {
-  describe("createBundleDownloader", () => {
-    test("creates BundleDownloader instance with correct dependencies", () => {
-      const mockStorageFactory = mock.fn();
-
-      const downloader = createBundleDownloader(mockStorageFactory, mockLogger);
-
-      assert.ok(downloader);
-      assert.ok(typeof downloader.initialize === "function");
-      assert.ok(typeof downloader.download === "function");
-    });
-
-    test("validates storageFactory parameter", () => {
-      assert.throws(() => createBundleDownloader(null, mockLogger), {
-        message: /createStorage is required/,
-      });
-    });
-
-    test("validates logger parameter", () => {
-      const mockStorageFactory = mock.fn();
-      assert.throws(() => createBundleDownloader(mockStorageFactory, null), {
-        message: /logger is required/,
-      });
-    });
-  });
-});