@aigne/doc-smith 0.8.12-beta.8 → 0.8.12-beta.9

package/tests/agents/utils/save-single-doc.test.mjs

@@ -1,364 +0,0 @@
-import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
-import saveSingleDoc from "../../../agents/utils/save-single-doc.mjs";
-import * as mermaidWorkerPool from "../../../utils/mermaid-worker-pool.mjs";
-import * as utils from "../../../utils/utils.mjs";
-
-describe("saveSingleDoc utility", () => {
-  let consoleWarnSpy;
-  let shutdownMermaidWorkerPoolSpy;
-  let saveDocWithTranslationsSpy;
-
-  beforeEach(() => {
-    shutdownMermaidWorkerPoolSpy = spyOn(
-      mermaidWorkerPool,
-      "shutdownMermaidWorkerPool",
-    ).mockResolvedValue();
-    saveDocWithTranslationsSpy = spyOn(utils, "saveDocWithTranslations").mockResolvedValue({
-      success: true,
-    });
-    consoleWarnSpy = spyOn(console, "warn").mockImplementation(() => {});
-  });
-
-  afterEach(() => {
-    // Restore all spies
-    shutdownMermaidWorkerPoolSpy?.mockRestore();
-    saveDocWithTranslationsSpy?.mockRestore();
-    consoleWarnSpy?.mockRestore();
-  });
-
-  // BASIC FUNCTIONALITY TESTS
-  test("should save document without showing message", async () => {
-    const options = {
-      path: "/docs/guide.md",
-      content: "# User Guide\n\nThis is a guide.",
-      docsDir: "/project/docs",
-      translates: [],
-      labels: {},
-      locale: "en",
-      isTranslate: false,
-      isShowMessage: false,
-    };
-
-    const result = await saveSingleDoc(options);
-
-    expect(saveDocWithTranslationsSpy).toHaveBeenCalledWith({
-      path: "/docs/guide.md",
-      content: "# User Guide\n\nThis is a guide.",
-      docsDir: "/project/docs",
-      translates: [],
-      labels: {},
-      locale: "en",
-      isTranslate: false,
-    });
-    expect(shutdownMermaidWorkerPoolSpy).not.toHaveBeenCalled();
-    expect(result).toEqual({});
-  });
-
-  test("should save document with success message for regular update", async () => {
-    const options = {
-      path: "/docs/api.md",
-      content: "# API Reference",
-      docsDir: "/project/docs",
-      translates: ["zh", "ja"],
-      labels: { api: "API" },
-      locale: "en",
-      isTranslate: false,
-      isShowMessage: true,
-    };
-
-    const result = await saveSingleDoc(options);
-
-    expect(saveDocWithTranslationsSpy).toHaveBeenCalledWith({
-      path: "/docs/api.md",
-      content: "# API Reference",
-      docsDir: "/project/docs",
-      translates: ["zh", "ja"],
-      labels: { api: "API" },
-      locale: "en",
-      isTranslate: false,
-    });
-    expect(shutdownMermaidWorkerPoolSpy).toHaveBeenCalled();
-    expect(result).toEqual({
-      message: "✅ Document updated successfully",
-    });
-  });
-
-  test("should save document with success message for translation", async () => {
-    const options = {
-      path: "/docs/zh/guide.md",
-      content: "# 用户指南\n\n这是一个指南。",
-      docsDir: "/project/docs",
-      translates: ["zh", "ja"],
-      labels: { guide: "指南" },
-      locale: "zh",
-      isTranslate: true,
-      isShowMessage: true,
-    };
-
-    const result = await saveSingleDoc(options);
-
-    expect(saveDocWithTranslationsSpy).toHaveBeenCalledWith({
-      path: "/docs/zh/guide.md",
-      content: "# 用户指南\n\n这是一个指南。",
-      docsDir: "/project/docs",
-      translates: ["zh", "ja"],
-      labels: { guide: "指南" },
-      locale: "zh",
-      isTranslate: true,
-    });
-    expect(shutdownMermaidWorkerPoolSpy).toHaveBeenCalled();
-    expect(result).toEqual({
-      message: "✅ Translation completed successfully",
-    });
-  });
-
-  // DEFAULT VALUES TESTS
-  test("should use default values for optional parameters", async () => {
-    const options = {
-      path: "/docs/minimal.md",
-      content: "# Minimal",
-      docsDir: "/docs",
-      translates: [],
-      labels: {},
-      locale: "en",
-    };
-
-    const result = await saveSingleDoc(options);
-
-    expect(saveDocWithTranslationsSpy).toHaveBeenCalledWith({
-      path: "/docs/minimal.md",
-      content: "# Minimal",
-      docsDir: "/docs",
-      translates: [],
-      labels: {},
-      locale: "en",
-      isTranslate: false, // Default value
-    });
-    expect(shutdownMermaidWorkerPoolSpy).not.toHaveBeenCalled();
-    expect(result).toEqual({});
-  });
-
-  test("should handle explicit false values", async () => {
-    const options = {
-      path: "/docs/explicit.md",
-      content: "# Explicit",
-      docsDir: "/docs",
-      translates: [],
-      labels: {},
-      locale: "en",
-      isTranslate: false,
-      isShowMessage: false,
-    };
-
-    const result = await saveSingleDoc(options);
-
-    expect(saveDocWithTranslationsSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        isTranslate: false,
-      }),
-    );
-    expect(result).toEqual({});
-  });
-
-  // MERMAID WORKER POOL SHUTDOWN TESTS
-  test("should handle mermaid worker pool shutdown error gracefully", async () => {
-    const shutdownError = new Error("Worker pool shutdown failed");
-    shutdownMermaidWorkerPoolSpy.mockRejectedValue(shutdownError);
-
-    const options = {
-      path: "/docs/with-error.md",
-      content: "# Document with shutdown error",
-      docsDir: "/docs",
-      translates: [],
-      labels: {},
-      locale: "en",
-      isTranslate: false,
-      isShowMessage: true,
-    };
-
-    const result = await saveSingleDoc(options);
-
-    expect(shutdownMermaidWorkerPoolSpy).toHaveBeenCalled();
-    expect(consoleWarnSpy).toHaveBeenCalledWith(
-      "Failed to shutdown mermaid worker pool:",
-      "Worker pool shutdown failed",
-    );
-    expect(result).toEqual({
-      message: "✅ Document updated successfully",
-    });
-  });
-
-  test("should handle mermaid worker pool shutdown error for translation", async () => {
-    const shutdownError = new Error("Pool cleanup failed");
-    shutdownMermaidWorkerPoolSpy.mockRejectedValue(shutdownError);
-
-    const options = {
-      path: "/docs/zh/with-error.md",
-      content: "# 带错误的文档",
-      docsDir: "/docs",
-      translates: ["zh"],
-      labels: {},
-      locale: "zh",
-      isTranslate: true,
-      isShowMessage: true,
-    };
-
-    const result = await saveSingleDoc(options);
-
-    expect(consoleWarnSpy).toHaveBeenCalledWith(
-      "Failed to shutdown mermaid worker pool:",
-      "Pool cleanup failed",
-    );
-    expect(result).toEqual({
-      message: "✅ Translation completed successfully",
-    });
-  });
-
-  // COMPREHENSIVE PARAMETER TESTS
-  test("should pass all parameters correctly to saveDocWithTranslations", async () => {
-    const complexOptions = {
-      path: "/docs/complex/nested/file.md",
-      content: "# Complex Document\n\nWith multiple sections.",
-      docsDir: "/project/documentation",
-      translates: ["zh-CN", "ja-JP", "ko-KR"],
-      labels: {
-        title: "标题",
-        section: "部分",
-        example: "例子",
-      },
-      locale: "zh-CN",
-      isTranslate: true,
-      isShowMessage: false,
-    };
-
-    await saveSingleDoc(complexOptions);
-
-    expect(saveDocWithTranslationsSpy).toHaveBeenCalledWith({
-      path: "/docs/complex/nested/file.md",
-      content: "# Complex Document\n\nWith multiple sections.",
-      docsDir: "/project/documentation",
-      translates: ["zh-CN", "ja-JP", "ko-KR"],
-      labels: {
-        title: "标题",
-        section: "部分",
-        example: "例子",
-      },
-      locale: "zh-CN",
-      isTranslate: true,
-    });
-  });
-
-  // EDGE CASES
-  test("should handle empty content", async () => {
-    const options = {
-      path: "/docs/empty.md",
-      content: "",
-      docsDir: "/docs",
-      translates: [],
-      labels: {},
-      locale: "en",
-      isShowMessage: true,
-    };
-
-    const result = await saveSingleDoc(options);
-
-    expect(saveDocWithTranslationsSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        content: "",
-      }),
-    );
-    expect(result).toEqual({
-      message: "✅ Document updated successfully",
-    });
-  });
-
-  test("should handle empty translations array", async () => {
-    const options = {
-      path: "/docs/no-translations.md",
-      content: "# No Translations",
-      docsDir: "/docs",
-      translates: [],
-      labels: {},
-      locale: "en",
-    };
-
-    await saveSingleDoc(options);
-
-    expect(saveDocWithTranslationsSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        translates: [],
-      }),
-    );
-  });
-
-  test("should handle empty labels object", async () => {
-    const options = {
-      path: "/docs/no-labels.md",
-      content: "# No Labels",
-      docsDir: "/docs",
-      translates: ["zh"],
-      labels: {},
-      locale: "en",
-    };
-
-    await saveSingleDoc(options);
-
-    expect(saveDocWithTranslationsSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        labels: {},
-      }),
-    );
-  });
-
-  // SPECIAL CHARACTERS AND PATHS
-  test("should handle paths with special characters", async () => {
-    const options = {
-      path: "/docs/特殊字符/file with spaces.md",
-      content: "# Special Characters 特殊字符",
-      docsDir: "/project/docs",
-      translates: ["zh-CN"],
-      labels: { special: "特殊" },
-      locale: "zh-CN",
-      isTranslate: true,
-    };
-
-    await saveSingleDoc(options);
-
-    expect(saveDocWithTranslationsSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        path: "/docs/特殊字符/file with spaces.md",
-        content: "# Special Characters 特殊字符",
-        labels: { special: "特殊" },
-        locale: "zh-CN",
-      }),
-    );
-  });
-
-  // RETURN VALUE CONSISTENCY
-  test("should always return object structure", async () => {
-    const withoutMessage = await saveSingleDoc({
-      path: "/docs/test1.md",
-      content: "Test",
-      docsDir: "/docs",
-      translates: [],
-      labels: {},
-      locale: "en",
-      isShowMessage: false,
-    });
-
-    const withMessage = await saveSingleDoc({
-      path: "/docs/test2.md",
-      content: "Test",
-      docsDir: "/docs",
-      translates: [],
-      labels: {},
-      locale: "en",
-      isShowMessage: true,
-    });
-
-    expect(typeof withoutMessage).toBe("object");
-    expect(typeof withMessage).toBe("object");
-    expect(withoutMessage).toEqual({});
-    expect(withMessage).toHaveProperty("message");
-  });
-});

package/tests/agents/utils/transform-detail-datasources.test.mjs

@@ -1,320 +0,0 @@
-import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
-import { mkdir, rm, writeFile } from "node:fs/promises";
-import path, { dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-import transformDetailDatasources from "../../../agents/utils/transform-detail-datasources.mjs";
-import * as utils from "../../../utils/utils.mjs";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-describe("transformDetailDatasources utility", () => {
-  let normalizePathSpy;
-  let toRelativePathSpy;
-  let testDir;
-
-  beforeEach(async () => {
-    // Create test directory
-    const uniqueId = `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
-    testDir = path.join(__dirname, `test-transform-${uniqueId}`);
-    await mkdir(testDir, { recursive: true });
-
-    // Spy on utility functions
-    normalizePathSpy = spyOn(utils, "normalizePath").mockImplementation((path) =>
-      path?.replace(/\\/g, "/").replace(/^\.\//, ""),
-    );
-    toRelativePathSpy = spyOn(utils, "toRelativePath").mockImplementation((path) =>
-      path?.startsWith("/") ? path.substring(1) : path,
-    );
-  });
-
-  afterEach(async () => {
-    // Restore all spies
-    normalizePathSpy?.mockRestore();
-    toRelativePathSpy?.mockRestore();
-
-    // Clean up test directory
-    try {
-      await rm(testDir, { recursive: true, force: true });
-    } catch {
-      console.warn(`Warning: Could not clean up test directory: ${testDir}`);
-    }
-  });
-
-  // BASIC FUNCTIONALITY TESTS
-  test("should transform simple datasources correctly", async () => {
-    // Create test files
-    const guidePath = path.join(testDir, "guide.md");
-    const apiPath = path.join(testDir, "api.md");
-    await writeFile(guidePath, "# User Guide\n\nThis is a guide.");
-    await writeFile(apiPath, "# API Reference\n\nAPI documentation.");
-
-    // Mock normalizePath to return the actual file path
-    normalizePathSpy.mockImplementation((p) => p);
-
-    const input = {
-      sourceIds: [guidePath, apiPath],
-    };
-
-    const result = transformDetailDatasources(input);
-
-    expect(normalizePathSpy).toHaveBeenCalledWith(guidePath);
-    expect(normalizePathSpy).toHaveBeenCalledWith(apiPath);
-    expect(toRelativePathSpy).toHaveBeenCalledWith(guidePath);
-    expect(toRelativePathSpy).toHaveBeenCalledWith(apiPath);
-
-    expect(result.detailDataSources).toContain("# User Guide\n\nThis is a guide.");
-    expect(result.detailDataSources).toContain("# API Reference\n\nAPI documentation.");
-  });
-
-  test("should handle single datasource", async () => {
-    // Create test file
-    const readmePath = path.join(testDir, "readme.md");
-    await writeFile(readmePath, "# README\n\nProject documentation.");
-
-    normalizePathSpy.mockImplementation((p) => p);
-
-    const input = {
-      sourceIds: [readmePath],
-    };
-
-    const result = transformDetailDatasources(input);
-
-    expect(result.detailDataSources).toContain("# README\n\nProject documentation.");
-  });
-
-  test("should maintain order of sourceIds", async () => {
-    // Create test files
-    const cPath = path.join(testDir, "c.md");
-    const aPath = path.join(testDir, "a.md");
-    const bPath = path.join(testDir, "b.md");
-    await writeFile(cPath, "Content C");
-    await writeFile(aPath, "Content A");
-    await writeFile(bPath, "Content B");
-
-    normalizePathSpy.mockImplementation((p) => p);
-
-    const input = {
-      sourceIds: [cPath, aPath, bPath],
-    };
-
-    const result = transformDetailDatasources(input);
-
-    // Check order by finding indices
-    const indexC = result.detailDataSources.indexOf("Content C");
-    const indexA = result.detailDataSources.indexOf("Content A");
-    const indexB = result.detailDataSources.indexOf("Content B");
-
-    expect(indexC).toBeLessThan(indexA);
-    expect(indexA).toBeLessThan(indexB);
-  });
-
-  // PATH NORMALIZATION TESTS
-  test("should normalize paths correctly", async () => {
-    // Create test files
-    const guidePath = path.join(testDir, "guide.md");
-    const apiPath = path.join(testDir, "api.md");
-    await writeFile(guidePath, "Guide content");
-    await writeFile(apiPath, "API content");
-
-    normalizePathSpy.mockImplementation((p) => p?.replace(/\\/g, "/"));
-
-    const input = {
-      sourceIds: [guidePath, apiPath],
-    };
-
-    const result = transformDetailDatasources(input);
-
-    expect(normalizePathSpy).toHaveBeenCalledWith(guidePath);
-    expect(normalizePathSpy).toHaveBeenCalledWith(apiPath);
-    expect(result.detailDataSources).toContain("Guide content");
-    expect(result.detailDataSources).toContain("API content");
-  });
-
-  test("should handle relative path conversion", async () => {
-    // Create test files
-    const absPath = path.join(testDir, "abs-file.md");
-    const relPath = path.join(testDir, "rel-file.md");
-    await writeFile(absPath, "Absolute content");
-    await writeFile(relPath, "Relative content");
-
-    normalizePathSpy.mockImplementation((p) => p);
-    toRelativePathSpy.mockImplementation((p) => p?.replace(/^\/+/, "").replace(/^\.\//, ""));
-
-    const input = {
-      sourceIds: [absPath, relPath],
-    };
-
-    const result = transformDetailDatasources(input);
-
-    expect(toRelativePathSpy).toHaveBeenCalledWith(absPath);
-    expect(toRelativePathSpy).toHaveBeenCalledWith(relPath);
-    expect(result.detailDataSources).toContain("Absolute content");
-    expect(result.detailDataSources).toContain("Relative content");
-  });
-
-  // MISSING DATA TESTS
-  test("should filter out sourceIds for files that don't exist", async () => {
-    // Create only some test files
-    const guidePath = path.join(testDir, "guide.md");
-    const apiPath = path.join(testDir, "api.md");
-    const missingPath = path.join(testDir, "missing.md");
-    await writeFile(guidePath, "Guide content");
-    await writeFile(apiPath, "API content");
-    // missingPath intentionally not created
-
-    normalizePathSpy.mockImplementation((p) => p);
-
-    const input = {
-      sourceIds: [guidePath, missingPath, apiPath],
-    };
-
-    const result = transformDetailDatasources(input);
-
-    expect(result.detailDataSources).toContain("Guide content");
-    expect(result.detailDataSources).toContain("API content");
-    expect(result.detailDataSources).not.toContain("missing");
-  });
-
-  test("should handle empty sourceIds array", () => {
-    const input = {
-      sourceIds: [],
-    };
-
-    const result = transformDetailDatasources(input);
-
-    expect(result.detailDataSources).toBe("");
-  });
-
-  // NULL AND UNDEFINED HANDLING
-  test("should handle null sourceIds", () => {
-    const input = {
-      sourceIds: null,
-    };
-
-    const result = transformDetailDatasources(input);
-
-    expect(result.detailDataSources).toBe("");
-  });
-
-  test("should handle undefined sourceIds", () => {
-    const input = {
-      sourceIds: undefined,
-    };
-
-    const result = transformDetailDatasources(input);
-
-    expect(result.detailDataSources).toBe("");
-  });
-
-  // CONTENT FORMATTING TESTS
-  test("should format content with proper sourceId comments", async () => {
-    const mainPath = path.join(testDir, "main.js");
-    await writeFile(mainPath, "console.log('Hello World');\nprocess.exit(0);");
-
-    normalizePathSpy.mockImplementation((p) => p);
-
-    const input = {
-      sourceIds: [mainPath],
-    };
-
-    const result = transformDetailDatasources(input);
-
-    expect(result.detailDataSources).toContain("console.log('Hello World');\nprocess.exit(0);");
-    expect(result.detailDataSources).toContain("// sourceId:");
-  });
-
-  test("should handle empty content", async () => {
-    const emptyPath = path.join(testDir, "empty.md");
-    await writeFile(emptyPath, "");
-
-    normalizePathSpy.mockImplementation((p) => p);
-
-    const input = {
-      sourceIds: [emptyPath],
-    };
-
-    const result = transformDetailDatasources(input);
-
-    // Empty file content still gets included with sourceId comment
-    expect(result.detailDataSources).toContain("// sourceId:");
-    expect(result.detailDataSources.trim()).not.toBe("");
-  });
-
-  test("should handle whitespace-only content", async () => {
-    const whitespacePath = path.join(testDir, "whitespace.md");
-    await writeFile(whitespacePath, "   \n\t  ");
-
-    normalizePathSpy.mockImplementation((p) => p);
-
-    const input = {
-      sourceIds: [whitespacePath],
-    };
-
-    const result = transformDetailDatasources(input);
-
-    // Whitespace content is truthy, so it should be included
-    expect(result.detailDataSources).toContain("   \n\t  ");
-  });
-
-  test("should handle content with special characters", async () => {
-    const specialPath = path.join(testDir, "特殊字符.md");
-    await writeFile(specialPath, "# 中文标题\n\n这是一个包含特殊字符的文档: @#$%^&*()");
-
-    normalizePathSpy.mockImplementation((p) => p);
-
-    const input = {
-      sourceIds: [specialPath],
-    };
-
-    const result = transformDetailDatasources(input);
-
-    expect(result.detailDataSources).toContain("中文标题");
-    expect(result.detailDataSources).toContain("@#$%^&*()");
-  });
-
-  // DUPLICATE HANDLING TESTS
-  test("should handle duplicate sourceIds in list", async () => {
-    const guidePath = path.join(testDir, "guide.md");
-    await writeFile(guidePath, "Guide content");
-
-    normalizePathSpy.mockImplementation((p) => p);
-
-    const input = {
-      sourceIds: [guidePath, guidePath], // Duplicate paths
-    };
-
-    const result = transformDetailDatasources(input);
-
-    // Both duplicates should be included
-    const matches = result.detailDataSources.match(/Guide content/g);
-    expect(matches?.length).toBe(2);
-  });
-
-  // RETURN VALUE STRUCTURE TESTS
-  test("should always return object with detailDataSources property", async () => {
-    const inputs = [{ sourceIds: [] }, { sourceIds: null }];
-
-    for (const input of inputs) {
-      const result = transformDetailDatasources(input);
-      expect(result).toHaveProperty("detailDataSources");
-      expect(typeof result.detailDataSources).toBe("string");
-    }
-  });
-
-  // EDGE CASES
-  test("should handle sourceId with null or undefined values", async () => {
-    const validPath = path.join(testDir, "valid.md");
-    await writeFile(validPath, "Valid content");
-
-    normalizePathSpy.mockImplementation((p) => p || "");
-    toRelativePathSpy.mockImplementation((p) => p || "");
-
-    const input = {
-      sourceIds: [null, undefined, validPath],
-    };
-
-    const result = transformDetailDatasources(input);
-
-    expect(result.detailDataSources).toContain("Valid content");
-  });
-});