@aigne/doc-smith 0.8.5 → 0.8.7

package/tests/agents/utils/fs.test.mjs

@@ -0,0 +1,267 @@
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+import * as fsPromises from "node:fs/promises";
+import * as path from "node:path";
+import fs from "../../../agents/utils/fs.mjs";
+
+describe("fs utility", () => {
+  let readFileSpy;
+  let writeFileSpy;
+  let mkdirSpy;
+  let rmSpy;
+  let readdirSpy;
+  let joinSpy;
+  let dirnameSpy;
+
+  beforeEach(() => {
+    // Spy on fs/promises methods
+    readFileSpy = spyOn(fsPromises, "readFile").mockResolvedValue("mocked file content");
+    writeFileSpy = spyOn(fsPromises, "writeFile").mockResolvedValue();
+    mkdirSpy = spyOn(fsPromises, "mkdir").mockResolvedValue();
+    rmSpy = spyOn(fsPromises, "rm").mockResolvedValue();
+    readdirSpy = spyOn(fsPromises, "readdir").mockResolvedValue([
+      { name: "file1.txt", parentPath: "/test/root", isDirectory: () => false },
+      { name: "subdir", parentPath: "/test/root", isDirectory: () => true },
+    ]);
+
+    // Spy on path methods
+    joinSpy = spyOn(path, "join").mockImplementation((...paths) => paths.join("/"));
+    dirnameSpy = spyOn(path, "dirname").mockImplementation(
+      (path) => path.split("/").slice(0, -1).join("/") || "/",
+    );
+  });
+
+  afterEach(() => {
+    // Restore all spies
+    readFileSpy?.mockRestore();
+    writeFileSpy?.mockRestore();
+    mkdirSpy?.mockRestore();
+    rmSpy?.mockRestore();
+    readdirSpy?.mockRestore();
+    joinSpy?.mockRestore();
+    dirnameSpy?.mockRestore();
+  });
+
+  // ERROR HANDLING TESTS
+  test("should throw error when rootDir is not specified", async () => {
+    await expect(
+      fs({
+        action: "read_file",
+        path: "test.txt",
+      }),
+    ).rejects.toThrow("Root directory is not specified");
+  });
+
+  test("should throw error when rootDir is empty string", async () => {
+    await expect(
+      fs({
+        rootDir: "",
+        action: "read_file",
+        path: "test.txt",
+      }),
+    ).rejects.toThrow("Root directory is not specified");
+  });
+
+  // READ_FILE ACTION TESTS
+  test("should read file successfully", async () => {
+    readFileSpy.mockResolvedValue("test file content");
+
+    const result = await fs({
+      rootDir: "/test/root",
+      action: "read_file",
+      path: "test.txt",
+    });
+
+    expect(joinSpy).toHaveBeenCalledWith("/test/root", "test.txt");
+    expect(readFileSpy).toHaveBeenCalledWith("/test/root/test.txt", "utf-8");
+    expect(result).toEqual({
+      status: "ok",
+      path: "/test/root/test.txt",
+      content: "test file content",
+    });
+  });
+
+  test("should handle read file with nested path", async () => {
+    await fs({
+      rootDir: "/project",
+      action: "read_file",
+      path: "src/components/Button.tsx",
+    });
+
+    expect(joinSpy).toHaveBeenCalledWith("/project", "src/components/Button.tsx");
+    expect(readFileSpy).toHaveBeenCalledWith("/project/src/components/Button.tsx", "utf-8");
+  });
+
+  // WRITE_FILE ACTION TESTS
+  test("should write file successfully", async () => {
+    const result = await fs({
+      rootDir: "/test/root",
+      action: "write_file",
+      path: "output.txt",
+      content: "Hello, world!",
+    });
+
+    expect(dirnameSpy).toHaveBeenCalledWith("/test/root/output.txt");
+    expect(mkdirSpy).toHaveBeenCalledWith("/test/root", { recursive: true });
+    expect(writeFileSpy).toHaveBeenCalledWith("/test/root/output.txt", "Hello, world!");
+    expect(result).toEqual({
+      status: "ok",
+      path: "/test/root/output.txt",
+      content: "Hello, world!",
+    });
+  });
+
+  test("should write file with empty content when content is not provided", async () => {
+    const result = await fs({
+      rootDir: "/test/root",
+      action: "write_file",
+      path: "empty.txt",
+    });
+
+    expect(writeFileSpy).toHaveBeenCalledWith("/test/root/empty.txt", "");
+    expect(result.content).toBeUndefined(); // The function returns the original content parameter
+  });
+
+  test("should create directories recursively when writing file", async () => {
+    dirnameSpy.mockReturnValue("/test/root/deep/nested");
+
+    await fs({
+      rootDir: "/test/root",
+      action: "write_file",
+      path: "deep/nested/file.txt",
+      content: "nested content",
+    });
+
+    expect(mkdirSpy).toHaveBeenCalledWith("/test/root/deep/nested", {
+      recursive: true,
+    });
+  });
+
+  // DELETE_FILE ACTION TESTS
+  test("should delete file successfully", async () => {
+    const result = await fs({
+      rootDir: "/test/root",
+      action: "delete_file",
+      path: "to-delete.txt",
+    });
+
+    expect(joinSpy).toHaveBeenCalledWith("/test/root", "to-delete.txt");
+    expect(rmSpy).toHaveBeenCalledWith("/test/root/to-delete.txt", {
+      recursive: true,
+      force: true,
+    });
+    expect(result).toEqual({
+      status: "ok",
+      path: "/test/root/to-delete.txt",
+    });
+  });
+
+  test("should delete directory recursively", async () => {
+    await fs({
+      rootDir: "/project",
+      action: "delete_file",
+      path: "build",
+    });
+
+    expect(rmSpy).toHaveBeenCalledWith("/project/build", {
+      recursive: true,
+      force: true,
+    });
+  });
+
+  // LIST_DIRECTORY ACTION TESTS
+  test("should list directory entries successfully", async () => {
+    const result = await fs({
+      rootDir: "/test/root",
+      action: "list_directory",
+      path: "src",
+    });
+
+    expect(joinSpy).toHaveBeenCalledWith("/test/root", "src");
+    expect(readdirSpy).toHaveBeenCalledWith("/test/root/src", { withFileTypes: true });
+    expect(result).toEqual({
+      status: "ok",
+      entries: [
+        { path: "/test/root/file1.txt", isDirectory: false },
+        { path: "/test/root/subdir", isDirectory: true },
+      ],
+    });
+  });
+
+  test("should handle empty directory listing", async () => {
+    readdirSpy.mockResolvedValue([]);
+
+    const result = await fs({
+      rootDir: "/test/root",
+      action: "list_directory",
+      path: "empty-dir",
+    });
+
+    expect(result.entries).toEqual([]);
+  });
+
+  // PATH HANDLING TESTS
+  test("should handle root directory with trailing slash", async () => {
+    await fs({
+      rootDir: "/test/root/",
+      action: "read_file",
+      path: "file.txt",
+    });
+
+    expect(joinSpy).toHaveBeenCalledWith("/test/root/", "file.txt");
+  });
+
+  test("should handle path with leading slash", async () => {
+    await fs({
+      rootDir: "/test/root",
+      action: "read_file",
+      path: "/absolute/path.txt",
+    });
+
+    expect(joinSpy).toHaveBeenCalledWith("/test/root", "/absolute/path.txt");
+  });
+
+  test("should handle complex nested paths", async () => {
+    await fs({
+      rootDir: "/project",
+      action: "write_file",
+      path: "src/components/ui/Button/index.tsx",
+      content: "export default Button;",
+    });
+
+    expect(joinSpy).toHaveBeenCalledWith("/project", "src/components/ui/Button/index.tsx");
+  });
+
+  // UNDEFINED ACTION TEST
+  test("should return undefined for unknown action", async () => {
+    const result = await fs({
+      rootDir: "/test/root",
+      action: "unknown_action",
+      path: "test.txt",
+    });
+
+    expect(result).toBeUndefined();
+  });
+
+  // EDGE CASES
+  test("should handle special characters in paths", async () => {
+    await fs({
+      rootDir: "/test/root",
+      action: "read_file",
+      path: "文件名 with spaces & symbols!.txt",
+    });
+
+    expect(joinSpy).toHaveBeenCalledWith("/test/root", "文件名 with spaces & symbols!.txt");
+  });
+
+  test("should handle null content for write_file", async () => {
+    const result = await fs({
+      rootDir: "/test/root",
+      action: "write_file",
+      path: "null-content.txt",
+      content: null,
+    });
+
+    expect(writeFileSpy).toHaveBeenCalledWith("/test/root/null-content.txt", "");
+    expect(result.content).toBe(null);
+  });
+});

package/tests/{load-sources.test.mjs → agents/utils/load-sources.test.mjs}

@@ -1,18 +1,19 @@
-import { afterAll, afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdir, rm, writeFile } from "node:fs/promises";
+import { afterAll, afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import path, { dirname } from "node:path";
 import { fileURLToPath } from "node:url";
-import loadSources from "../agents/load-sources.mjs";
+import loadSources from "../../../agents/utils/load-sources.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
-describe("loadSources", () => {
+describe("load-sources", () => {
   let testDir;
   let tempDir;
 
   beforeEach(async () => {
-    // Create test directory structure
-    testDir = path.join(__dirname, "test-content-generator");
+    // Create test directory structure with unique name to avoid conflicts
+    const uniqueId = `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+    testDir = path.join(__dirname, `test-content-generator-${uniqueId}`);
     tempDir = path.join(testDir, "temp");
 
     await mkdir(testDir, { recursive: true });
@@ -687,6 +688,9 @@ describe("loadSources", () => {
       await mkdir(deepPath, { recursive: true });
       await writeFile(path.join(deepPath, "deep.js"), "console.log('deep');");
 
+      const content = await readFile(path.join(deepPath, "deep.js"), "utf8");
+      console.log("deep content", content);
+
       const result = await loadSources({
         sourcesPath: testDir,
         includePatterns: ["**/*.js"],
@@ -1026,14 +1030,14 @@ describe("loadSources", () => {
     });
   });
 
-  describe("Document path and structure plan handling", () => {
-    test("should load existing structure plan", async () => {
-      const structurePlan = {
+  describe("Document path and document structure handling", () => {
+    test("should load existing document structure", async () => {
+      const documentStructure = {
         sections: ["Introduction", "API", "Examples"],
         lastUpdated: new Date().toISOString(),
       };
 
-      await writeFile(path.join(tempDir, "structure-plan.json"), JSON.stringify(structurePlan));
+      await writeFile(path.join(tempDir, "structure-plan.json"), JSON.stringify(documentStructure));
 
       const result = await loadSources({
         sourcesPath: testDir,
@@ -1043,10 +1047,10 @@ describe("loadSources", () => {
         docsDir: path.join(testDir, "docs"),
       });
 
-      expect(result.originalStructurePlan).toEqual(structurePlan);
+      expect(result.originalDocumentStructure).toEqual(documentStructure);
     });
 
-    test("should handle malformed structure plan JSON", async () => {
+    test("should handle malformed document structure JSON", async () => {
       await writeFile(path.join(tempDir, "structure-plan.json"), "{ invalid json content");
 
       const result = await loadSources({
@@ -1057,7 +1061,120 @@ describe("loadSources", () => {
         docsDir: path.join(testDir, "docs"),
       });
 
-      expect(result.originalStructurePlan).toBeUndefined();
+      expect(result.originalDocumentStructure).toBeUndefined();
+    });
+
+    test("should handle non-ENOENT errors when reading document structure JSON", async () => {
+      // Import fs promises module to spy on
+      const fsPromises = await import("node:fs/promises");
+
+      // Get the original readFile function
+      const originalReadFile = fsPromises.readFile;
+
+      // Create a spy that only throws error for structure-plan.json
+      const readFileSpy = spyOn(fsPromises, "readFile").mockImplementation((filePath, encoding) => {
+        if (filePath.includes("structure-plan.json")) {
+          const error = new Error("Permission denied");
+          error.code = "EACCES";
+          throw error;
+        }
+        // For all other files, use the original readFile
+        return originalReadFile(filePath, encoding);
+      });
+
+      try {
+        const result = await loadSources({
+          sourcesPath: testDir,
+          includePatterns: ["*.js"],
+          useDefaultPatterns: false,
+          outputDir: tempDir,
+          docsDir: path.join(testDir, "docs"),
+        });
+
+        expect(result.originalDocumentStructure).toBeUndefined();
+      } finally {
+        // Restore the original readFile function
+        readFileSpy.mockRestore();
+      }
+    });
+
+    test("should handle non-ENOENT errors when reading docPath file", async () => {
+      // Import fs promises module to spy on
+      const fsPromises = await import("node:fs/promises");
+
+      // Get the original readFile function
+      const originalReadFile = fsPromises.readFile;
+
+      // Create a spy that only throws error for the specific docPath file
+      const readFileSpy = spyOn(fsPromises, "readFile").mockImplementation((filePath, encoding) => {
+        // Check if this is the docPath file (api-overview.md)
+        if (filePath.includes("api-overview.md")) {
+          const error = new Error("Permission denied");
+          error.code = "EACCES";
+          throw error;
+        }
+        // For all other files, use the original readFile
+        return originalReadFile(filePath, encoding);
+      });
+
+      try {
+        const result = await loadSources({
+          sourcesPath: testDir,
+          "doc-path": "/api/overview",
+          includePatterns: ["*.js"],
+          useDefaultPatterns: false,
+          outputDir: tempDir,
+          docsDir: path.join(testDir, "docs"),
+        });
+
+        expect(result.content).toBeUndefined();
+      } finally {
+        // Restore the original readFile function
+        readFileSpy.mockRestore();
+      }
+    });
+
+    test("should handle non-ENOENT errors when reading boardId-based docPath file", async () => {
+      // Import fs promises module to spy on
+      const fsPromises = await import("node:fs/promises");
+
+      // Get the original readFile function
+      const originalReadFile = fsPromises.readFile;
+
+      // Create a spy that only throws error for the boardId file
+      const readFileSpy = spyOn(fsPromises, "readFile").mockImplementation((filePath, encoding) => {
+        // First call will fail for the original format (board123-api-overview.md)
+        // Second call should fail for the boardId format (api-overview.md)
+        if (filePath.includes("board123-api-overview.md")) {
+          const error = new Error("File not found");
+          error.code = "ENOENT";
+          throw error;
+        }
+        if (filePath.includes("api-overview.md") && !filePath.includes("board123-")) {
+          const error = new Error("Permission denied");
+          error.code = "EACCES";
+          throw error;
+        }
+        // For all other files, use the original readFile
+        return originalReadFile(filePath, encoding);
+      });
+
+      try {
+        const result = await loadSources({
+          sourcesPath: testDir,
+          "doc-path": "board123-api-overview",
+          boardId: "board123",
+          includePatterns: ["*.js"],
+          useDefaultPatterns: false,
+          outputDir: tempDir,
+          docsDir: path.join(testDir, "docs"),
+        });
+
+        expect(result.content).toBeUndefined();
+      } finally {
+        // Restore the original readFile function
+        readFileSpy.mockRestore();
+      }
     });
 
     test("should load document content by docPath", async () => {
@@ -1323,20 +1440,31 @@ describe("loadSources", () => {
 
   // Global cleanup to ensure test directories are fully removed
   afterAll(async () => {
-    const testDirBase = path.join(__dirname, "test-content-generator");
+    // Clean up all test-content-generator directories (including unique ones)
     try {
-      await rm(testDirBase, { recursive: true, force: true });
-    } catch {
-      // Try with system command as final fallback
-      try {
-        const { exec } = await import("node:child_process");
-        const { promisify } = await import("node:util");
-        const execAsync = promisify(exec);
-        await execAsync(`rm -rf "${testDirBase}"`);
-      } catch {
-        // If we still can't clean up, warn but don't fail
-        console.warn(`Warning: Could not fully clean up test directory: ${testDirBase}`);
+      const { readdir } = await import("node:fs/promises");
+      const entries = await readdir(__dirname, { withFileTypes: true });
+
+      for (const entry of entries) {
+        if (entry.isDirectory() && entry.name.startsWith("test-content-generator")) {
+          const testDirToClean = path.join(__dirname, entry.name);
+          try {
+            await rm(testDirToClean, { recursive: true, force: true });
+          } catch {
+            // Try with system command as fallback
+            try {
+              const { exec } = await import("node:child_process");
+              const { promisify } = await import("node:util");
+              const execAsync = promisify(exec);
+              await execAsync(`rm -rf "${testDirToClean}"`);
+            } catch {
+              console.warn(`Warning: Could not fully clean up test directory: ${testDirToClean}`);
+            }
+          }
+        }
       }
+    } catch (error) {
+      console.warn(`Warning: Could not clean up test directories: ${error.message}`);
     }
   });
 });

package/tests/{save-docs.test.mjs → agents/utils/save-docs.test.mjs}

@@ -2,14 +2,17 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { mkdir, readdir, rm, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import saveDocs from "../agents/save-docs.mjs";
+import saveDocs from "../../../agents/utils/save-docs.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
-describe("saveDocs", () => {
+describe("save-docs", () => {
   let testDir;
 
   beforeEach(async () => {
+    // Set test environment variable to prevent actual config file modification
+    process.env.NODE_ENV = "test";
+
     // Create a temporary test directory
     testDir = join(__dirname, "test-docs");
     await mkdir(testDir, { recursive: true });
@@ -32,6 +35,9 @@ describe("saveDocs", () => {
   });
 
   afterEach(async () => {
+    // Clean up environment variable
+    delete process.env.NODE_ENV;
+
     // Clean up test directory
     try {
       await rm(testDir, { recursive: true, force: true });
@@ -46,8 +52,8 @@ describe("saveDocs", () => {
     expect(initialFiles).toContain("getting-started.md");
     expect(initialFiles).toContain("old-file.md");
 
-    // Test structure plan
-    const structurePlan = [
+    // Test document structure
+    const documentStructure = [
       {
         path: "/overview",
         title: "Overview",
@@ -64,7 +70,7 @@ describe("saveDocs", () => {
     const translateLanguages = ["zh", "en"];
 
     const result = await saveDocs({
-      structurePlanResult: structurePlan,
+      documentExecutionStructure: documentStructure,
       docsDir: testDir,
       translateLanguages,
     });