@forwardimpact/libutil 0.1.70 → 0.1.73

package/test/extractor.test.js

@@ -1,338 +0,0 @@
-import { test, describe, beforeEach, afterEach } 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";
-
-// Module under test
-import { TarExtractor, ZipExtractor } from "../extractor.js";
-
-describe("TarExtractor", () => {
-  let extractor;
-  let tempDir;
-  let fixturesDir;
-
-  beforeEach(() => {
-    extractor = new TarExtractor(fsPromises, path);
-
-    // Setup directories
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = path.dirname(__filename);
-    fixturesDir = path.join(__dirname, "fixtures");
-    tempDir = path.join(__dirname, ".tmp-extractor-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 TarExtractor with fs and path", () => {
-      const extractor = new TarExtractor(fsPromises, path);
-
-      assert.ok(extractor instanceof TarExtractor);
-    });
-
-    test("validates fs parameter", () => {
-      assert.throws(() => new TarExtractor(), {
-        message: /fs dependency is required/,
-      });
-      assert.throws(() => new TarExtractor(null, path), {
-        message: /fs dependency is required/,
-      });
-    });
-
-    test("validates path parameter", () => {
-      assert.throws(() => new TarExtractor(fsPromises), {
-        message: /path dependency is required/,
-      });
-      assert.throws(() => new TarExtractor(fsPromises, null), {
-        message: /path dependency is required/,
-      });
-    });
-  });
-
-  describe("extract", () => {
-    test("extracts tar.gz archive to specified directory", async () => {
-      const tarPath = path.join(fixturesDir, "sample.tar.gz");
-      const outputDir = path.join(tempDir, "tar-output");
-
-      await extractor.extract(tarPath, outputDir);
-
-      // Verify extracted files exist
-      assert.ok(fs.existsSync(path.join(outputDir, "test.txt")));
-      assert.ok(fs.existsSync(path.join(outputDir, "nested.txt")));
-      assert.ok(fs.existsSync(path.join(outputDir, "subdir", "deep.txt")));
-    });
-
-    test("extracts files with correct content", async () => {
-      const tarPath = path.join(fixturesDir, "sample.tar.gz");
-      const outputDir = path.join(tempDir, "tar-content");
-
-      await extractor.extract(tarPath, outputDir);
-
-      // Verify file contents
-      const testContent = await fsPromises.readFile(
-        path.join(outputDir, "test.txt"),
-        "utf8",
-      );
-      assert.strictEqual(testContent.trim(), "Hello from root file");
-
-      const nestedContent = await fsPromises.readFile(
-        path.join(outputDir, "nested.txt"),
-        "utf8",
-      );
-      assert.strictEqual(nestedContent.trim(), "Nested content");
-
-      const deepContent = await fsPromises.readFile(
-        path.join(outputDir, "subdir", "deep.txt"),
-        "utf8",
-      );
-      assert.strictEqual(deepContent.trim(), "Deep file content");
-    });
-
-    test("creates nested directory structure", async () => {
-      const tarPath = path.join(fixturesDir, "sample.tar.gz");
-      const outputDir = path.join(tempDir, "tar-structure");
-
-      await extractor.extract(tarPath, outputDir);
-
-      // Verify directory structure
-      const subdirPath = path.join(outputDir, "subdir");
-      assert.ok(fs.existsSync(subdirPath));
-
-      const stats = await fsPromises.stat(subdirPath);
-      assert.ok(stats.isDirectory());
-    });
-
-    test("handles non-existent output directory", async () => {
-      const tarPath = path.join(fixturesDir, "sample.tar.gz");
-      const outputDir = path.join(tempDir, "deep", "nested", "tar-output");
-
-      // Should not throw - should create directory structure
-      await extractor.extract(tarPath, outputDir);
-
-      assert.ok(fs.existsSync(path.join(outputDir, "test.txt")));
-    });
-  });
-});
-
-describe("ZipExtractor", () => {
-  let extractor;
-  let tempDir;
-  let fixturesDir;
-
-  beforeEach(() => {
-    extractor = new ZipExtractor(fsPromises, path);
-
-    // Setup directories
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = path.dirname(__filename);
-    fixturesDir = path.join(__dirname, "fixtures");
-    tempDir = path.join(__dirname, ".tmp-extractor-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 ZipExtractor with fs and path", () => {
-      const extractor = new ZipExtractor(fsPromises, path);
-
-      assert.ok(extractor instanceof ZipExtractor);
-    });
-
-    test("validates fs parameter", () => {
-      assert.throws(() => new ZipExtractor(), {
-        message: /fs dependency is required/,
-      });
-      assert.throws(() => new ZipExtractor(null, path), {
-        message: /fs dependency is required/,
-      });
-    });
-
-    test("validates path parameter", () => {
-      assert.throws(() => new ZipExtractor(fsPromises), {
-        message: /path dependency is required/,
-      });
-      assert.throws(() => new ZipExtractor(fsPromises, null), {
-        message: /path dependency is required/,
-      });
-    });
-  });
-
-  describe("extract", () => {
-    test("extracts zip archive to specified directory", async () => {
-      const zipPath = path.join(fixturesDir, "sample.zip");
-      const outputDir = path.join(tempDir, "zip-output");
-
-      await extractor.extract(zipPath, outputDir);
-
-      // Verify extracted files exist
-      assert.ok(fs.existsSync(path.join(outputDir, "test.txt")));
-      assert.ok(fs.existsSync(path.join(outputDir, "nested.txt")));
-      assert.ok(fs.existsSync(path.join(outputDir, "subdir", "deep.txt")));
-    });
-
-    test("extracts files with correct content", async () => {
-      const zipPath = path.join(fixturesDir, "sample.zip");
-      const outputDir = path.join(tempDir, "zip-content");
-
-      await extractor.extract(zipPath, outputDir);
-
-      // Verify file contents
-      const testContent = await fsPromises.readFile(
-        path.join(outputDir, "test.txt"),
-        "utf8",
-      );
-      assert.strictEqual(testContent.trim(), "Hello from root file");
-
-      const nestedContent = await fsPromises.readFile(
-        path.join(outputDir, "nested.txt"),
-        "utf8",
-      );
-      assert.strictEqual(nestedContent.trim(), "Nested content");
-
-      const deepContent = await fsPromises.readFile(
-        path.join(outputDir, "subdir", "deep.txt"),
-        "utf8",
-      );
-      assert.strictEqual(deepContent.trim(), "Deep file content");
-    });
-
-    test("creates nested directory structure", async () => {
-      const zipPath = path.join(fixturesDir, "sample.zip");
-      const outputDir = path.join(tempDir, "zip-structure");
-
-      await extractor.extract(zipPath, outputDir);
-
-      // Verify directory structure
-      const subdirPath = path.join(outputDir, "subdir");
-      assert.ok(fs.existsSync(subdirPath));
-
-      const stats = await fsPromises.stat(subdirPath);
-      assert.ok(stats.isDirectory());
-    });
-
-    test("handles non-existent output directory", async () => {
-      const zipPath = path.join(fixturesDir, "sample.zip");
-      const outputDir = path.join(tempDir, "deep", "nested", "zip-output");
-
-      // Should not throw - should create directory structure
-      await extractor.extract(zipPath, outputDir);
-
-      assert.ok(fs.existsSync(path.join(outputDir, "test.txt")));
-    });
-
-    test("throws error for invalid zip file", async () => {
-      const invalidZipPath = path.join(tempDir, "invalid.zip");
-
-      // Create an invalid zip file (just some random bytes)
-      await fsPromises.writeFile(invalidZipPath, Buffer.from([0, 1, 2, 3, 4]));
-
-      const outputDir = path.join(tempDir, "invalid-output");
-
-      await assert.rejects(
-        async () => {
-          await extractor.extract(invalidZipPath, outputDir);
-        },
-        {
-          message: /Invalid ZIP file/,
-        },
-      );
-    });
-  });
-
-  describe("format comparison", () => {
-    test("both extractors produce identical file content", async () => {
-      const tarPath = path.join(fixturesDir, "sample.tar.gz");
-      const zipPath = path.join(fixturesDir, "sample.zip");
-      const tarOutput = path.join(tempDir, "tar-compare");
-      const zipOutput = path.join(tempDir, "zip-compare");
-
-      const tarExtractor = new TarExtractor(fsPromises, path);
-      const zipExtractor = new ZipExtractor(fsPromises, path);
-
-      await tarExtractor.extract(tarPath, tarOutput);
-      await zipExtractor.extract(zipPath, zipOutput);
-
-      // Compare file contents
-      const tarTest = await fsPromises.readFile(
-        path.join(tarOutput, "test.txt"),
-        "utf8",
-      );
-      const zipTest = await fsPromises.readFile(
-        path.join(zipOutput, "test.txt"),
-        "utf8",
-      );
-      assert.strictEqual(tarTest, zipTest);
-
-      const tarNested = await fsPromises.readFile(
-        path.join(tarOutput, "nested.txt"),
-        "utf8",
-      );
-      const zipNested = await fsPromises.readFile(
-        path.join(zipOutput, "nested.txt"),
-        "utf8",
-      );
-      assert.strictEqual(tarNested, zipNested);
-
-      const tarDeep = await fsPromises.readFile(
-        path.join(tarOutput, "subdir", "deep.txt"),
-        "utf8",
-      );
-      const zipDeep = await fsPromises.readFile(
-        path.join(zipOutput, "subdir", "deep.txt"),
-        "utf8",
-      );
-      assert.strictEqual(tarDeep, zipDeep);
-    });
-
-    test("both extractors create identical directory structure", async () => {
-      const tarPath = path.join(fixturesDir, "sample.tar.gz");
-      const zipPath = path.join(fixturesDir, "sample.zip");
-      const tarOutput = path.join(tempDir, "tar-struct");
-      const zipOutput = path.join(tempDir, "zip-struct");
-
-      const tarExtractor = new TarExtractor(fsPromises, path);
-      const zipExtractor = new ZipExtractor(fsPromises, path);
-
-      await tarExtractor.extract(tarPath, tarOutput);
-      await zipExtractor.extract(zipPath, zipOutput);
-
-      // Check that both have the subdir
-      assert.ok(fs.existsSync(path.join(tarOutput, "subdir")));
-      assert.ok(fs.existsSync(path.join(zipOutput, "subdir")));
-
-      // Check that both subdirs are directories
-      const tarSubdirStats = await fsPromises.stat(
-        path.join(tarOutput, "subdir"),
-      );
-      const zipSubdirStats = await fsPromises.stat(
-        path.join(zipOutput, "subdir"),
-      );
-      assert.ok(tarSubdirStats.isDirectory());
-      assert.ok(zipSubdirStats.isDirectory());
-    });
-  });
-});

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