@aigne/doc-smith 0.8.6 → 0.8.8

package/tests/agents/utils/save-output.test.mjs

@@ -0,0 +1,315 @@
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+import fs from "node:fs";
+import * as path from "node:path";
+import saveOutput from "../../../agents/utils/save-output.mjs";
+
+describe("saveOutput utility", () => {
+  let mkdirSpy;
+  let writeFileSpy;
+  let joinSpy;
+  let consoleWarnSpy;
+
+  beforeEach(() => {
+    // Spy on fs.promises methods
+    mkdirSpy = spyOn(fs.promises, "mkdir").mockResolvedValue();
+    writeFileSpy = spyOn(fs.promises, "writeFile").mockResolvedValue();
+
+    // Spy on path methods
+    joinSpy = spyOn(path, "join").mockImplementation((...paths) => paths.join("/"));
+
+    // Spy on console.warn
+    consoleWarnSpy = spyOn(console, "warn").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    // Restore all spies
+    mkdirSpy?.mockRestore();
+    writeFileSpy?.mockRestore();
+    joinSpy?.mockRestore();
+    consoleWarnSpy?.mockRestore();
+  });
+
+  // SUCCESSFUL SAVE TESTS
+  test("should save string content successfully", async () => {
+    const result = await saveOutput({
+      savePath: "/output/dir",
+      fileName: "result.txt",
+      saveKey: "textContent",
+      textContent: "Hello, World!",
+    });
+
+    expect(mkdirSpy).toHaveBeenCalledWith("/output/dir", { recursive: true });
+    expect(joinSpy).toHaveBeenCalledWith("/output/dir", "result.txt");
+    expect(writeFileSpy).toHaveBeenCalledWith("/output/dir/result.txt", "Hello, World!", "utf8");
+    expect(result).toEqual({
+      saveOutputStatus: true,
+      saveOutputPath: "/output/dir/result.txt",
+    });
+  });
+
+  test("should save object content as formatted JSON", async () => {
+    const objectData = {
+      title: "Test Document",
+      tags: ["test", "sample"],
+      metadata: { version: 1 },
+    };
+
+    const result = await saveOutput({
+      savePath: "/data",
+      fileName: "config.json",
+      saveKey: "configData",
+      configData: objectData,
+    });
+
+    const expectedContent = JSON.stringify(objectData, null, 2);
+    expect(writeFileSpy).toHaveBeenCalledWith("/data/config.json", expectedContent, "utf8");
+    expect(result.saveOutputStatus).toBe(true);
+    expect(result.saveOutputPath).toBe("/data/config.json");
+  });
+
+  test("should save number content as string", async () => {
+    const result = await saveOutput({
+      savePath: "/numbers",
+      fileName: "count.txt",
+      saveKey: "count",
+      count: 42,
+    });
+
+    expect(writeFileSpy).toHaveBeenCalledWith("/numbers/count.txt", "42", "utf8");
+    expect(result.saveOutputStatus).toBe(true);
+  });
+
+  test("should save boolean content as string", async () => {
+    const result = await saveOutput({
+      savePath: "/flags",
+      fileName: "flag.txt",
+      saveKey: "isEnabled",
+      isEnabled: true,
+    });
+
+    expect(writeFileSpy).toHaveBeenCalledWith("/flags/flag.txt", "true", "utf8");
+    expect(result.saveOutputStatus).toBe(true);
+  });
+
+  test("should save array content as formatted JSON", async () => {
+    const arrayData = ["item1", "item2", { nested: "object" }];
+
+    const result = await saveOutput({
+      savePath: "/arrays",
+      fileName: "list.json",
+      saveKey: "items",
+      items: arrayData,
+    });
+
+    const expectedContent = JSON.stringify(arrayData, null, 2);
+    expect(writeFileSpy).toHaveBeenCalledWith("/arrays/list.json", expectedContent, "utf8");
+    expect(result.saveOutputStatus).toBe(true);
+  });
+
+  // NULL AND UNDEFINED HANDLING
+  test("should handle null values by converting to JSON string", async () => {
+    const result = await saveOutput({
+      savePath: "/null-test",
+      fileName: "null.json",
+      saveKey: "nullValue",
+      nullValue: null,
+    });
+
+    expect(writeFileSpy).toHaveBeenCalledWith("/null-test/null.json", "null", "utf8");
+    expect(result.saveOutputStatus).toBe(true);
+  });
+
+  test("should handle undefined values by converting to string", async () => {
+    const result = await saveOutput({
+      savePath: "/undefined-test",
+      fileName: "undefined.txt",
+      saveKey: "undefinedValue",
+      undefinedValue: undefined,
+    });
+
+    expect(writeFileSpy).toHaveBeenCalledWith("/undefined-test/undefined.txt", "undefined", "utf8");
+    expect(result.saveOutputStatus).toBe(true);
+  });
+
+  // MISSING SAVE KEY TESTS
+  test("should warn and return false when saveKey is not found", async () => {
+    const result = await saveOutput({
+      savePath: "/output",
+      fileName: "missing.txt",
+      saveKey: "nonExistentKey",
+      existingKey: "some value",
+    });
+
+    expect(consoleWarnSpy).toHaveBeenCalledWith(
+      'saveKey "nonExistentKey" not found in input, skip saving.',
+    );
+    expect(result).toEqual({
+      saveOutputStatus: false,
+      saveOutputPath: null,
+    });
+    expect(mkdirSpy).not.toHaveBeenCalled();
+    expect(writeFileSpy).not.toHaveBeenCalled();
+  });
+
+  test("should not save when saveKey exists but is undefined", async () => {
+    const result = await saveOutput({
+      savePath: "/output",
+      fileName: "test.txt",
+      saveKey: "undefinedKey",
+      // undefinedKey is not provided, so it will be undefined
+    });
+
+    expect(consoleWarnSpy).toHaveBeenCalledWith(
+      'saveKey "undefinedKey" not found in input, skip saving.',
+    );
+    expect(result.saveOutputStatus).toBe(false);
+  });
+
+  // COMPLEX PATH HANDLING
+  test("should handle nested directory paths", async () => {
+    await saveOutput({
+      savePath: "/deep/nested/directory/structure",
+      fileName: "file.txt",
+      saveKey: "content",
+      content: "test content",
+    });
+
+    expect(mkdirSpy).toHaveBeenCalledWith("/deep/nested/directory/structure", {
+      recursive: true,
+    });
+    expect(joinSpy).toHaveBeenCalledWith("/deep/nested/directory/structure", "file.txt");
+  });
+
+  test("should handle paths with special characters", async () => {
+    await saveOutput({
+      savePath: "/path with spaces/特殊字符/symbols!@#",
+      fileName: "file-name_with-symbols.json",
+      saveKey: "data",
+      data: { test: "value" },
+    });
+
+    expect(mkdirSpy).toHaveBeenCalledWith("/path with spaces/特殊字符/symbols!@#", {
+      recursive: true,
+    });
+    expect(joinSpy).toHaveBeenCalledWith(
+      "/path with spaces/特殊字符/symbols!@#",
+      "file-name_with-symbols.json",
+    );
+  });
+
+  // EMPTY AND EDGE CASES
+  test("should save empty string content", async () => {
+    const result = await saveOutput({
+      savePath: "/empty",
+      fileName: "empty.txt",
+      saveKey: "emptyString",
+      emptyString: "",
+    });
+
+    expect(writeFileSpy).toHaveBeenCalledWith("/empty/empty.txt", "", "utf8");
+    expect(result.saveOutputStatus).toBe(true);
+  });
+
+  test("should save empty object as formatted JSON", async () => {
+    const result = await saveOutput({
+      savePath: "/empty",
+      fileName: "empty.json",
+      saveKey: "emptyObject",
+      emptyObject: {},
+    });
+
+    expect(writeFileSpy).toHaveBeenCalledWith("/empty/empty.json", "{}", "utf8");
+    expect(result.saveOutputStatus).toBe(true);
+  });
+
+  test("should save empty array as formatted JSON", async () => {
+    const result = await saveOutput({
+      savePath: "/empty",
+      fileName: "empty-array.json",
+      saveKey: "emptyArray",
+      emptyArray: [],
+    });
+
+    expect(writeFileSpy).toHaveBeenCalledWith("/empty/empty-array.json", "[]", "utf8");
+    expect(result.saveOutputStatus).toBe(true);
+  });
+
+  // COMPLEX OBJECT SERIALIZATION
+  test("should handle complex nested objects", async () => {
+    const complexObject = {
+      users: [
+        { id: 1, name: "Alice", settings: { theme: "dark", notifications: true } },
+        { id: 2, name: "Bob", settings: { theme: "light", notifications: false } },
+      ],
+      metadata: {
+        version: "1.0.0",
+        created: "2024-01-01",
+        features: ["auth", "api", "ui"],
+      },
+    };
+
+    const result = await saveOutput({
+      savePath: "/complex",
+      fileName: "data.json",
+      saveKey: "complexData",
+      complexData: complexObject,
+    });
+
+    const expectedContent = JSON.stringify(complexObject, null, 2);
+    expect(writeFileSpy).toHaveBeenCalledWith("/complex/data.json", expectedContent, "utf8");
+    expect(result.saveOutputStatus).toBe(true);
+  });
+
+  // MULTIPLE KEYS IN INPUT
+  test("should only save the specified saveKey among multiple keys", async () => {
+    const result = await saveOutput({
+      savePath: "/selective",
+      fileName: "selected.txt",
+      saveKey: "targetKey",
+      targetKey: "This should be saved",
+      otherKey: "This should be ignored",
+      anotherKey: { ignored: "data" },
+    });
+
+    expect(writeFileSpy).toHaveBeenCalledWith(
+      "/selective/selected.txt",
+      "This should be saved",
+      "utf8",
+    );
+    expect(result.saveOutputStatus).toBe(true);
+  });
+
+  // FUNCTION CONTENT HANDLING
+  test("should convert function to string", async () => {
+    const testFunction = function testFn() {
+      return "hello";
+    };
+
+    const result = await saveOutput({
+      savePath: "/functions",
+      fileName: "function.txt",
+      saveKey: "fn",
+      fn: testFunction,
+    });
+
+    expect(writeFileSpy).toHaveBeenCalledWith(
+      "/functions/function.txt",
+      testFunction.toString(),
+      "utf8",
+    );
+    expect(result.saveOutputStatus).toBe(true);
+  });
+
+  // ZERO VALUES
+  test("should save zero values correctly", async () => {
+    const result = await saveOutput({
+      savePath: "/zeros",
+      fileName: "zero.txt",
+      saveKey: "zeroValue",
+      zeroValue: 0,
+    });
+
+    expect(writeFileSpy).toHaveBeenCalledWith("/zeros/zero.txt", "0", "utf8");
+    expect(result.saveOutputStatus).toBe(true);
+  });
+});

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

@@ -0,0 +1,364 @@
+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");
+  });
+});