automaker/apps/server/tests/unit/lib/fs-utils.test.ts

import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
import { mkdirSafe, existsSafe } from "@/lib/fs-utils.js";
import fs from "fs/promises";
import path from "path";
import os from "os";

describe("fs-utils.ts", () => {
  let testDir: string;

  beforeEach(async () => {
    // Create a temporary test directory
    testDir = path.join(os.tmpdir(), `fs-utils-test-${Date.now()}`);
    await fs.mkdir(testDir, { recursive: true });
  });

  afterEach(async () => {
    // Clean up test directory
    try {
      await fs.rm(testDir, { recursive: true, force: true });
    } catch {
      // Ignore cleanup errors
    }
  });

  describe("mkdirSafe", () => {
    it("should create a new directory", async () => {
      const newDir = path.join(testDir, "new-directory");
      await mkdirSafe(newDir);

      const stats = await fs.stat(newDir);
      expect(stats.isDirectory()).toBe(true);
    });

    it("should succeed if directory already exists", async () => {
      const existingDir = path.join(testDir, "existing");
      await fs.mkdir(existingDir);

      // Should not throw
      await expect(mkdirSafe(existingDir)).resolves.toBeUndefined();
    });

    it("should create nested directories", async () => {
      const nestedDir = path.join(testDir, "a", "b", "c");
      await mkdirSafe(nestedDir);

      const stats = await fs.stat(nestedDir);
      expect(stats.isDirectory()).toBe(true);
    });

    it("should throw if path exists as a file", async () => {
      const filePath = path.join(testDir, "file.txt");
      await fs.writeFile(filePath, "content");

      await expect(mkdirSafe(filePath)).rejects.toThrow(
        "Path exists and is not a directory"
      );
    });

    it("should succeed if path is a symlink to a directory", async () => {
      const realDir = path.join(testDir, "real-dir");
      const symlinkPath = path.join(testDir, "link-to-dir");
      await fs.mkdir(realDir);
      await fs.symlink(realDir, symlinkPath);

      // Should not throw
      await expect(mkdirSafe(symlinkPath)).resolves.toBeUndefined();
    });

    it("should handle ELOOP error gracefully when checking path", async () => {
      // Mock lstat to throw ELOOP error
      const originalLstat = fs.lstat;
      const mkdirSafePath = path.join(testDir, "eloop-path");
      
      vi.spyOn(fs, "lstat").mockRejectedValueOnce({ code: "ELOOP" });

      // Should not throw, should return gracefully
      await expect(mkdirSafe(mkdirSafePath)).resolves.toBeUndefined();

      vi.restoreAllMocks();
    });

    it("should handle EEXIST error gracefully when creating directory", async () => {
      const newDir = path.join(testDir, "race-condition-dir");
      
      // Mock lstat to return ENOENT (path doesn't exist)
      // Then mock mkdir to throw EEXIST (race condition)
      vi.spyOn(fs, "lstat").mockRejectedValueOnce({ code: "ENOENT" });
      vi.spyOn(fs, "mkdir").mockRejectedValueOnce({ code: "EEXIST" });

      // Should not throw, should return gracefully
      await expect(mkdirSafe(newDir)).resolves.toBeUndefined();

      vi.restoreAllMocks();
    });

    it("should handle ELOOP error gracefully when creating directory", async () => {
      const newDir = path.join(testDir, "eloop-create-dir");
      
      // Mock lstat to return ENOENT (path doesn't exist)
      // Then mock mkdir to throw ELOOP
      vi.spyOn(fs, "lstat").mockRejectedValueOnce({ code: "ENOENT" });
      vi.spyOn(fs, "mkdir").mockRejectedValueOnce({ code: "ELOOP" });

      // Should not throw, should return gracefully
      await expect(mkdirSafe(newDir)).resolves.toBeUndefined();

      vi.restoreAllMocks();
    });
  });

  describe("existsSafe", () => {
    it("should return true for existing file", async () => {
      const filePath = path.join(testDir, "test-file.txt");
      await fs.writeFile(filePath, "content");

      const exists = await existsSafe(filePath);
      expect(exists).toBe(true);
    });

    it("should return true for existing directory", async () => {
      const dirPath = path.join(testDir, "test-dir");
      await fs.mkdir(dirPath);

      const exists = await existsSafe(dirPath);
      expect(exists).toBe(true);
    });

    it("should return false for non-existent path", async () => {
      const nonExistent = path.join(testDir, "does-not-exist");

      const exists = await existsSafe(nonExistent);
      expect(exists).toBe(false);
    });

    it("should return true for symlink", async () => {
      const realFile = path.join(testDir, "real-file.txt");
      const symlinkPath = path.join(testDir, "link-to-file");
      await fs.writeFile(realFile, "content");
      await fs.symlink(realFile, symlinkPath);

      const exists = await existsSafe(symlinkPath);
      expect(exists).toBe(true);
    });

    it("should return true for broken symlink (symlink exists even if target doesn't)", async () => {
      const symlinkPath = path.join(testDir, "broken-link");
      const nonExistent = path.join(testDir, "non-existent-target");
      await fs.symlink(nonExistent, symlinkPath);

      const exists = await existsSafe(symlinkPath);
      expect(exists).toBe(true);
    });

    it("should return true for ELOOP error (symlink loop)", async () => {
      // Mock lstat to throw ELOOP error
      vi.spyOn(fs, "lstat").mockRejectedValueOnce({ code: "ELOOP" });

      const exists = await existsSafe("/some/path/with/loop");
      expect(exists).toBe(true);

      vi.restoreAllMocks();
    });

    it("should throw for other errors", async () => {
      // Mock lstat to throw a non-ENOENT, non-ELOOP error
      vi.spyOn(fs, "lstat").mockRejectedValueOnce({ code: "EACCES" });

      await expect(existsSafe("/some/path")).rejects.toMatchObject({ code: "EACCES" });

      vi.restoreAllMocks();
    });
  });
});