@aigne/doc-smith 0.8.6 → 0.8.8

package/tests/utils/file-utils.test.mjs

@@ -0,0 +1,213 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { getFilesWithGlob, loadGitignore } from "../../utils/file-utils.mjs";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+describe("file-utils", () => {
+  let testDir;
+
+  beforeEach(async () => {
+    // Create a temporary test directory
+    testDir = join(__dirname, "test-file-utils");
+    await mkdir(testDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    // Clean up test directory
+    try {
+      await rm(testDir, { recursive: true, force: true });
+    } catch {
+      // Ignore cleanup errors since they don't affect test results
+    }
+  });
+
+  describe("loadGitignore", () => {
+    test("should load gitignore patterns from current directory", async () => {
+      const gitignorePath = join(testDir, ".gitignore");
+      const gitignoreContent = `
+node_modules/
+dist/
+*.log
+.env
+# Comment line
+      `.trim();
+
+      await writeFile(gitignorePath, gitignoreContent);
+
+      const patterns = await loadGitignore(testDir);
+
+      expect(patterns).toBeDefined();
+      expect(Array.isArray(patterns)).toBe(true);
+      expect(patterns.length).toBeGreaterThan(0);
+
+      // Should convert gitignore patterns to glob patterns
+      expect(patterns.some((p) => p.includes("node_modules"))).toBe(true);
+      expect(patterns.some((p) => p.includes("dist"))).toBe(true);
+      expect(patterns.some((p) => p.includes("*.log"))).toBe(true);
+      expect(patterns.some((p) => p.includes(".env"))).toBe(true);
+    });
+
+    test("should load gitignore patterns from git repository", async () => {
+      const patterns = await loadGitignore(testDir);
+      // Since we're in a git repository, it should load patterns
+      expect(patterns).not.toBeNull();
+      expect(Array.isArray(patterns)).toBe(true);
+    });
+
+    test("should handle empty gitignore file", async () => {
+      const gitignorePath = join(testDir, ".gitignore");
+      await writeFile(gitignorePath, "");
+
+      const patterns = await loadGitignore(testDir);
+      // Even with empty gitignore, parent git repo patterns are loaded
+      expect(patterns).not.toBeNull();
+      expect(Array.isArray(patterns)).toBe(true);
+    });
+
+    test("should ignore comment lines and empty lines", async () => {
+      const gitignorePath = join(testDir, ".gitignore");
+      const gitignoreContent = `
+# This is a comment
+node_modules/
+
+# Another comment
+*.log
+`.trim();
+
+      await writeFile(gitignorePath, gitignoreContent);
+
+      const patterns = await loadGitignore(testDir);
+
+      expect(patterns).toBeDefined();
+      // Should not contain empty strings or comments
+      expect(patterns.every((p) => p.trim().length > 0 && !p.startsWith("#"))).toBe(true);
+    });
+
+    test("should handle various gitignore pattern formats", async () => {
+      const gitignorePath = join(testDir, ".gitignore");
+      const gitignoreContent = `
+/absolute-path
+relative-path
+directory/
+*.extension
+**/*.js
+temp*
+`.trim();
+
+      await writeFile(gitignorePath, gitignoreContent);
+
+      const patterns = await loadGitignore(testDir);
+
+      expect(patterns).toBeDefined();
+      expect(patterns.length).toBeGreaterThan(0);
+
+      // Should handle different pattern types
+      expect(patterns.some((p) => p.includes("absolute-path"))).toBe(true);
+      expect(patterns.some((p) => p.includes("relative-path"))).toBe(true);
+      expect(patterns.some((p) => p.includes("directory"))).toBe(true);
+      expect(patterns.some((p) => p.includes("*.extension"))).toBe(true);
+    });
+  });
+
+  describe("getFilesWithGlob", () => {
+    beforeEach(async () => {
+      // Create test file structure
+      await mkdir(join(testDir, "src"), { recursive: true });
+      await mkdir(join(testDir, "lib"), { recursive: true });
+      await mkdir(join(testDir, "node_modules"), { recursive: true });
+
+      await writeFile(join(testDir, "src", "index.js"), "// main file");
+      await writeFile(join(testDir, "src", "utils.ts"), "// utils file");
+      await writeFile(join(testDir, "lib", "helper.js"), "// helper file");
+      await writeFile(join(testDir, "README.md"), "# readme");
+      await writeFile(join(testDir, "package.json"), "{}");
+      await writeFile(join(testDir, "node_modules", "dep.js"), "// dependency");
+    });
+
+    test("should find files with basic include patterns", async () => {
+      const files = await getFilesWithGlob(testDir, ["*.js"], [], []);
+
+      expect(files).toBeDefined();
+      expect(Array.isArray(files)).toBe(true);
+      expect(files.some((f) => f.includes("index.js"))).toBe(true);
+      expect(files.some((f) => f.includes("helper.js"))).toBe(true);
+    });
+
+    test("should exclude files based on exclude patterns", async () => {
+      const files = await getFilesWithGlob(testDir, ["**/*.js"], ["node_modules/**"], []);
+
+      expect(files).toBeDefined();
+      expect(files.some((f) => f.includes("index.js"))).toBe(true);
+      expect(files.some((f) => f.includes("helper.js"))).toBe(true);
+      expect(files.some((f) => f.includes("node_modules"))).toBe(false);
+    });
+
+    test("should handle multiple include patterns", async () => {
+      const files = await getFilesWithGlob(testDir, ["*.js", "*.ts"], [], []);
+
+      expect(files).toBeDefined();
+      expect(files.some((f) => f.includes("index.js"))).toBe(true);
+      expect(files.some((f) => f.includes("utils.ts"))).toBe(true);
+      expect(files.some((f) => f.includes("helper.js"))).toBe(true);
+    });
+
+    test("should handle gitignore patterns", async () => {
+      const gitignorePatterns = ["node_modules/**"];
+      const files = await getFilesWithGlob(testDir, ["**/*.js"], [], gitignorePatterns);
+
+      expect(files).toBeDefined();
+      expect(files.some((f) => f.includes("index.js"))).toBe(true);
+      expect(files.some((f) => f.includes("node_modules"))).toBe(false);
+    });
+
+    test("should return empty array for empty include patterns", async () => {
+      const files = await getFilesWithGlob(testDir, [], [], []);
+
+      expect(files).toBeDefined();
+      expect(Array.isArray(files)).toBe(true);
+      expect(files.length).toBe(0);
+    });
+
+    test("should return absolute paths", async () => {
+      const files = await getFilesWithGlob(testDir, ["*.js"], [], []);
+
+      expect(files).toBeDefined();
+      files.forEach((file) => {
+        expect(file.startsWith("/")).toBe(true);
+      });
+    });
+
+    test("should handle nested directory patterns", async () => {
+      await mkdir(join(testDir, "src", "components"), { recursive: true });
+      await writeFile(join(testDir, "src", "components", "button.js"), "// button");
+
+      const files = await getFilesWithGlob(testDir, ["src/**/*.js"], [], []);
+
+      expect(files).toBeDefined();
+      expect(files.some((f) => f.includes("index.js"))).toBe(true);
+      expect(files.some((f) => f.includes("button.js"))).toBe(true);
+    });
+
+    test("should handle complex glob patterns", async () => {
+      const files = await getFilesWithGlob(testDir, ["**/*.{js,ts,md}"], ["node_modules/**"], []);
+
+      expect(files).toBeDefined();
+      expect(files.some((f) => f.includes("index.js"))).toBe(true);
+      expect(files.some((f) => f.includes("utils.ts"))).toBe(true);
+      expect(files.some((f) => f.includes("README.md"))).toBe(true);
+      expect(files.some((f) => f.includes("node_modules"))).toBe(false);
+    });
+
+    test("should handle non-existent directory gracefully", async () => {
+      const nonExistentDir = join(testDir, "non-existent");
+      const files = await getFilesWithGlob(nonExistentDir, ["*.js"], [], []);
+
+      expect(files).toBeDefined();
+      expect(Array.isArray(files)).toBe(true);
+      expect(files.length).toBe(0);
+    });
+  });
+});

package/tests/{kroki-utils.test.mjs → utils/kroki-utils.test.mjs}

@@ -6,7 +6,7 @@ import path from "node:path";
 
 import Debug from "debug";
 
-import { TMP_ASSETS_DIR } from "../utils/constants.mjs";
+import { TMP_ASSETS_DIR } from "../../utils/constants.mjs";
 import {
   beforePublishHook,
   checkD2Content,
@@ -14,7 +14,7 @@ import {
   getChart,
   getD2Svg,
   saveD2Assets,
-} from "../utils/kroki-utils.mjs";
+} from "../../utils/kroki-utils.mjs";
 
 describe("kroki-utils", () => {
   let tempDir;

package/tests/utils/load-config.test.mjs

@@ -0,0 +1,141 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import loadConfig from "../../utils/load-config.mjs";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+describe("load-config", () => {
+  let testDir;
+
+  beforeEach(async () => {
+    // Create a temporary test directory
+    testDir = join(__dirname, "test-load-config");
+    await mkdir(testDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    // Clean up test directory
+    try {
+      await rm(testDir, { recursive: true, force: true });
+    } catch {
+      // Ignore cleanup errors since they don't affect test results
+    }
+  });
+
+  test("should load valid YAML config file", async () => {
+    const configPath = join(testDir, "config.yaml");
+    const configContent = `
+projectName: "Test Project"
+locale: "en"
+docsDir: "./docs"
+sourcesPath:
+  - "./src"
+  - "./lib"
+`;
+    await writeFile(configPath, configContent);
+
+    const result = await loadConfig({ config: configPath });
+
+    expect(result).toBeDefined();
+    expect(result.projectName).toBe("Test Project");
+    expect(result.locale).toBe("en");
+    expect(result.docsDir).toBe("./docs");
+    expect(result.sourcesPath).toEqual(["./src", "./lib"]);
+    expect(result.lastGitHead).toBe("");
+  });
+
+  test("should handle appUrl parameter", async () => {
+    const configPath = join(testDir, "config.yaml");
+    const configContent = `
+projectName: "Test Project"
+locale: "en"
+`;
+    await writeFile(configPath, configContent);
+
+    const result = await loadConfig({
+      config: configPath,
+      appUrl: "example.com",
+    });
+
+    expect(result.appUrl).toBe("https://example.com");
+  });
+
+  test("should preserve appUrl with existing protocol", async () => {
+    const configPath = join(testDir, "config.yaml");
+    const configContent = `
+projectName: "Test Project"
+locale: "en"
+`;
+    await writeFile(configPath, configContent);
+
+    const result = await loadConfig({
+      config: configPath,
+      appUrl: "http://localhost:3000",
+    });
+
+    expect(result.appUrl).toBe("http://localhost:3000");
+  });
+
+  test("should handle absolute config path", async () => {
+    const configPath = join(testDir, "absolute-config.yaml");
+    const configContent = `
+projectName: "Absolute Path Test"
+locale: "zh"
+`;
+    await writeFile(configPath, configContent);
+
+    const result = await loadConfig({ config: configPath });
+
+    expect(result.projectName).toBe("Absolute Path Test");
+    expect(result.locale).toBe("zh");
+  });
+
+  test("should throw error for non-existent config file", async () => {
+    const nonExistentPath = join(testDir, "non-existent.yaml");
+
+    await expect(loadConfig({ config: nonExistentPath })).rejects.toThrow(
+      `Config file not found: ${nonExistentPath}`,
+    );
+  });
+
+  test("should throw error for invalid YAML syntax", async () => {
+    const configPath = join(testDir, "invalid.yaml");
+    const invalidContent = `
+projectName: "Test
+locale: en
+invalid: yaml: syntax
+`;
+    await writeFile(configPath, invalidContent);
+
+    await expect(loadConfig({ config: configPath })).rejects.toThrow(
+      "Failed to parse config file:",
+    );
+  });
+
+  test("should throw error for empty config file", async () => {
+    const configPath = join(testDir, "empty.yaml");
+    await writeFile(configPath, "");
+
+    // Empty YAML files result in null, which causes an error in the processing
+    await expect(loadConfig({ config: configPath })).rejects.toThrow(
+      "Failed to parse config file:",
+    );
+  });
+
+  test("should handle config with lastGitHead", async () => {
+    const configPath = join(testDir, "config-with-git.yaml");
+    const configContent = `
+projectName: "Git Project"
+lastGitHead: "abc123def456"
+locale: "en"
+`;
+    await writeFile(configPath, configContent);
+
+    const result = await loadConfig({ config: configPath });
+
+    expect(result.lastGitHead).toBe("abc123def456");
+    expect(result.projectName).toBe("Git Project");
+  });
+});

package/tests/{mermaid-validation.test.mjs → utils/mermaid-validator.test.mjs}

@@ -6,12 +6,12 @@ import {
   shutdownValidation,
   validateBasicMermaidSyntax,
   validateMermaidSyntax,
-} from "../utils/mermaid-validator.mjs";
+} from "../../utils/mermaid-validator.mjs";
 import {
   getMermaidWorkerPool,
   SimpleMermaidWorkerPool,
   shutdownMermaidWorkerPool,
-} from "../utils/mermaid-worker-pool.mjs";
+} from "../../utils/mermaid-worker-pool.mjs";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);

package/tests/utils/mock-chat-model.mjs

@@ -0,0 +1,12 @@
+// Mock ChatModel for testing
+export class MockChatModel {
+  constructor(options = {}) {
+    this.options = options;
+  }
+
+  process() {
+    throw new Error("Method not implemented in test mock");
+  }
+}
+
+export const loadModel = () => new MockChatModel();

package/tests/{preferences-utils.test.mjs → utils/preferences-utils.test.mjs}

@@ -10,7 +10,7 @@ import {
   readPreferences,
   removeRule,
   writePreferences,
-} from "../utils/preferences-utils.mjs";
+} from "../../utils/preferences-utils.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 

package/tests/{save-value-to-config.test.mjs → utils/save-value-to-config.test.mjs}

@@ -1,9 +1,11 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+import * as fs from "node:fs";
 import { existsSync } from "node:fs";
+import fsPromisesDefault, * as fsPromises from "node:fs/promises";
 import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { saveValueToConfig } from "../utils/utils.mjs";
+import { saveValueToConfig } from "../../utils/utils.mjs";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -13,8 +15,14 @@ const TEST_DIR = join(__dirname, "temp-config-test");
 const TEST_CONFIG_DIR = join(TEST_DIR, ".aigne", "doc-smith");
 const TEST_CONFIG_PATH = join(TEST_CONFIG_DIR, "config.yaml");
 
+// Store original working directory
+let originalCwd;
+
 // Setup and teardown helpers
 async function setupTestDir() {
+  // Save original working directory
+  originalCwd = process.cwd();
+
   if (existsSync(TEST_DIR)) {
     await rm(TEST_DIR, { recursive: true, force: true });
   }
@@ -26,7 +34,7 @@ async function setupTestDir() {
 
 async function teardownTestDir() {
   // Change back to original directory
-  process.chdir(dirname(TEST_DIR));
+  process.chdir(originalCwd);
 
   if (existsSync(TEST_DIR)) {
     await rm(TEST_DIR, { recursive: true, force: true });
@@ -46,13 +54,62 @@ async function createInitialConfig(content) {
 }
 
 // Test suite
-describe("saveValueToConfig", () => {
+describe("save-value-to-config", () => {
+  let restoreFunctions = [];
+
   beforeEach(async () => {
     await setupTestDir();
+
+    // Restore any existing mocks that might interfere with our file operations
+    // This is crucial when running alongside other test files like utils.test.mjs
+    restoreFunctions = [];
+
+    // Restore fs sync mocks if they exist
+    if (typeof fs.existsSync.mockRestore === "function") {
+      fs.existsSync.mockRestore();
+      restoreFunctions.push(() => spyOn(fs, "existsSync").mockReturnValue(true));
+    }
+    if (typeof fs.mkdirSync.mockRestore === "function") {
+      fs.mkdirSync.mockRestore();
+      restoreFunctions.push(() => spyOn(fs, "mkdirSync").mockImplementation(() => {}));
+    }
+
+    // Restore fs async mocks if they exist
+    if (typeof fsPromises.writeFile.mockRestore === "function") {
+      fsPromises.writeFile.mockRestore();
+      restoreFunctions.push(() => spyOn(fsPromises, "writeFile").mockResolvedValue());
+    }
+    if (typeof fsPromises.mkdir.mockRestore === "function") {
+      fsPromises.mkdir.mockRestore();
+      restoreFunctions.push(() => spyOn(fsPromises, "mkdir").mockResolvedValue());
+    }
+    if (typeof fsPromises.readFile.mockRestore === "function") {
+      fsPromises.readFile.mockRestore();
+      restoreFunctions.push(() => spyOn(fsPromises, "readFile").mockResolvedValue("test content"));
+    }
+
+    // Restore default import mocks if they exist
+    if (typeof fsPromisesDefault.writeFile.mockRestore === "function") {
+      fsPromisesDefault.writeFile.mockRestore();
+      restoreFunctions.push(() => spyOn(fsPromisesDefault, "writeFile").mockResolvedValue());
+    }
+    if (typeof fsPromisesDefault.mkdir.mockRestore === "function") {
+      fsPromisesDefault.mkdir.mockRestore();
+      restoreFunctions.push(() => spyOn(fsPromisesDefault, "mkdir").mockResolvedValue());
+    }
   });
 
   afterEach(async () => {
     await teardownTestDir();
+
+    // Restore the original mocks that other tests might depend on
+    restoreFunctions.forEach((restoreFn) => {
+      try {
+        restoreFn();
+      } catch {
+        // Ignore errors when restoring mocks
+      }
+    });
   });
 
   test("Save string value to empty file", async () => {