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

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

@@ -1,437 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { existsSync, mkdtemp, rmdir } from "node:fs";
-import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path from "node:path";
-
-import Debug from "debug";
-
-import { DOC_SMITH_DIR, TMP_ASSETS_DIR, TMP_DIR } from "../../utils/constants/index.mjs";
-import {
-  beforePublishHook,
-  checkContent,
-  ensureTmpDir,
-  getChart,
-  isValidCode,
-  saveAssets,
-  wrapCode,
-} from "../../utils/d2-utils.mjs";
-
-describe("d2-utils", () => {
-  let tempDir;
-
-  beforeEach(async () => {
-    tempDir = await new Promise((resolve, reject) => {
-      mkdtemp(path.join(tmpdir(), "d2-test-"), (err, dir) => {
-        if (err) reject(err);
-        else resolve(dir);
-      });
-    });
-  });
-
-  afterEach(async () => {
-    if (tempDir && existsSync(tempDir)) {
-      await new Promise((resolve) => {
-        rmdir(tempDir, { recursive: true }, () => resolve());
-      });
-    }
-  });
-
-  describe("getChart", () => {
-    test("should generate chart for valid d2 content", async () => {
-      const content = "A -> B";
-      const result = await getChart({ content });
-      expect(typeof result).toBe("string");
-      expect(result).toContain("<svg");
-    }, 15000);
-
-    test("should return null for invalid d2 content with strict=false", async () => {
-      const content = "A -> B -> C -> [invalid syntax";
-      const result = await getChart({ content, strict: false });
-      expect(result).toBe(null);
-    }, 15000);
-
-    test("should throw for invalid d2 content with strict=true", async () => {
-      const content = "A -> B -> C -> [invalid syntax";
-      await expect(getChart({ content, strict: true })).rejects.toThrow();
-    }, 15000);
-
-    test("should handle empty content", async () => {
-      const result = await getChart({ content: "" });
-      expect(typeof result).toBe("string");
-      expect(result).toContain("<svg");
-    }, 10000);
-
-    test("should add stroke-dash to container shapes", async () => {
-      const content = `
-        container {
-          A -> B
-        }
-      `;
-      const result = await getChart({ content });
-      expect(typeof result).toBe("string");
-      // d2 will convert `strokeDash: 3` to `stroke-dasharray:6.000000,5.919384;`
-      expect(result).toContain("stroke-dasharray:6.000000");
-    }, 15000);
-
-    test("should not add stroke-dash to sequence diagrams", async () => {
-      const content = `
-        shape: sequence_diagram
-        A -> B: Hello
-      `;
-      const result = await getChart({ content });
-      expect(typeof result).toBe("string");
-      // d2 will convert `strokeDash: 3` to `stroke-dasharray:6.000000,5.919384;`
-      expect(result).not.toContain("stroke-dasharray:6.000000");
-    }, 15000);
-  });
-
-  describe("saveAssets", () => {
-    test("should process markdown with D2 code blocks", async () => {
-      const docsDir = path.join(tempDir, "docs");
-      await mkdir(docsDir, { recursive: true });
-
-      const markdown = `# Test Document
-
-This is a test document with D2 diagram:
-
-\`\`\`d2
-A -> B: connection
-B -> C: another connection
-\`\`\`
-
-Some more content here.
-`;
-
-      const result = await saveAssets({ markdown, docsDir });
-
-      expect(typeof result).toBe("string");
-      expect(result).toContain("# Test Document");
-      expect(result).toContain("Some more content here");
-
-      // Should replace D2 code block with image reference
-      expect(result).not.toContain("```d2");
-      expect(result).toContain("![](../assets/d2/");
-      expect(result).toContain(".svg)");
-    });
-
-    test("should handle markdown without D2 blocks", async () => {
-      const docsDir = path.join(tempDir, "docs");
-      await mkdir(docsDir, { recursive: true });
-
-      const markdown = `# Test Document
-
-This document has no D2 diagrams.
-
-\`\`\`javascript
-console.log('hello world');
-\`\`\`
-`;
-
-      const result = await saveAssets({ markdown, docsDir });
-
-      expect(result).toBe(markdown); // Should remain unchanged
-    });
-
-    test("should handle multiple D2 blocks", async () => {
-      const docsDir = path.join(tempDir, "docs");
-      await mkdir(docsDir, { recursive: true });
-
-      const markdown = `# Test
-
-\`\`\`d2
-A -> B
-\`\`\`
-
-Some text.
-
-\`\`\`d2
-C -> D
-E -> F
-\`\`\`
-`;
-
-      const result = await saveAssets({ markdown, docsDir });
-
-      expect(typeof result).toBe("string");
-      expect(result).not.toContain("```d2");
-
-      // Should have two image references
-      const imageMatches = result.match(/!\[\]\(\.\.\/assets\/d2\/.*\.svg\)/g);
-      expect(imageMatches).toBeTruthy();
-      expect(imageMatches.length).toBe(2);
-    });
-
-    test("should handle empty markdown", async () => {
-      const docsDir = path.join(tempDir, "docs");
-      await mkdir(docsDir, { recursive: true });
-
-      const result = await saveAssets({ markdown: "", docsDir });
-      expect(result).toBe("");
-    });
-
-    test("should skip generation if SVG file already exists", async () => {
-      const docsDir = path.join(tempDir, "docs");
-      await mkdir(docsDir, { recursive: true });
-      const markdown = `\`\`\`d2\nA -> B\n\`\`\``;
-
-      // 1. First run to generate the file
-      await saveAssets({ markdown, docsDir });
-
-      // 2. Second run to check if cache is used
-      const debugLogs = [];
-      const originalWrite = process.stderr.write;
-      process.stderr.write = (chunk) => {
-        debugLogs.push(chunk.toString());
-        return true;
-      };
-      Debug.enable("doc-smith");
-
-      try {
-        const result = await saveAssets({ markdown, docsDir });
-
-        expect(typeof result).toBe("string");
-        expect(result).toContain(`![](${path.posix.join("..", TMP_ASSETS_DIR, "d2")}`);
-        expect(
-          debugLogs.some((log) => log.includes("Found assets cache, skipping generation")),
-        ).toBe(true);
-      } finally {
-        process.stderr.write = originalWrite;
-        Debug.disable();
-      }
-    });
-
-    test("should handle D2 generation errors gracefully", async () => {
-      const docsDir = path.join(tempDir, "docs");
-      await mkdir(docsDir, { recursive: true });
-
-      const markdown = `\`\`\`d2\nA -> B -> [invalid\n\`\`\``;
-
-      const result = await saveAssets({ markdown, docsDir });
-      expect(result).toContain("![](../assets/d2/");
-    });
-
-    test("should write .d2 file when debug is enabled", async () => {
-      const docsDir = path.join(tempDir, "docs");
-      await mkdir(docsDir, { recursive: true });
-
-      const markdown = `\`\`\`d2\nA -> B\n\`\`\``;
-
-      // Enable debug mode
-      Debug.enable("doc-smith");
-
-      try {
-        await saveAssets({ markdown, docsDir });
-
-        const assetDir = path.join(docsDir, "../", TMP_ASSETS_DIR, "d2");
-        const files = await readdir(assetDir);
-        const d2File = files.find((file) => file.endsWith(".d2"));
-        expect(d2File).toBeDefined();
-      } finally {
-        // Restore debug mode
-        Debug.disable();
-      }
-    });
-  });
-
-  describe("beforePublishHook", () => {
-    test("should process all markdown files in directory", async () => {
-      const docsDir = path.join(tempDir, "docs");
-      await mkdir(docsDir, { recursive: true });
-
-      // Create test markdown files
-      const file1Content = `# Doc 1\n\`\`\`d2\nA -> B\n\`\`\``;
-      const file2Content = `# Doc 2\n\`\`\`d2\nC -> D\n\`\`\``;
-      const file3Content = `# Doc 3\nNo diagrams here.`;
-
-      await writeFile(path.join(docsDir, "doc1.md"), file1Content);
-      await writeFile(path.join(docsDir, "doc2.md"), file2Content);
-      await writeFile(path.join(docsDir, "doc3.md"), file3Content);
-
-      await beforePublishHook({ docsDir });
-
-      // Check that files were processed
-      const processedFile1 = await readFile(path.join(docsDir, "doc1.md"), "utf8");
-      const processedFile2 = await readFile(path.join(docsDir, "doc2.md"), "utf8");
-      const processedFile3 = await readFile(path.join(docsDir, "doc3.md"), "utf8");
-
-      expect(processedFile1).not.toContain("```d2");
-      expect(processedFile2).not.toContain("```d2");
-      expect(processedFile3).toBe(file3Content); // Unchanged
-
-      expect(processedFile1).toContain("![](../assets/d2/");
-      expect(processedFile2).toContain("![](../assets/d2/");
-    });
-
-    test("should handle nested directories", async () => {
-      const docsDir = path.join(tempDir, "docs");
-      const subDir = path.join(docsDir, "subdir");
-      await mkdir(subDir, { recursive: true });
-
-      const fileContent = `# Nested Doc\n\`\`\`d2\nA -> B\n\`\`\``;
-      await writeFile(path.join(subDir, "nested.md"), fileContent);
-
-      await beforePublishHook({ docsDir });
-
-      const processedFile = await readFile(path.join(subDir, "nested.md"), "utf8");
-      expect(processedFile).not.toContain("```d2");
-      expect(processedFile).toContain("![](../assets/d2/");
-    });
-
-    test("should handle empty docs directory", async () => {
-      const docsDir = path.join(tempDir, "empty-docs");
-      await mkdir(docsDir, { recursive: true });
-
-      // Should not throw error
-      await expect(beforePublishHook({ docsDir })).resolves.toBeUndefined();
-    });
-
-    test("should handle non-existent directory", async () => {
-      const nonExistentDir = path.join(tempDir, "non-existent");
-      // glob will just return an empty array, so no error should be thrown.
-      await expect(beforePublishHook({ docsDir: nonExistentDir })).resolves.toBeUndefined();
-    });
-  });
-
-  describe("checkContent", () => {
-    test("should generate and cache D2 SVG", async () => {
-      const content = "A -> B: test connection";
-      await expect(checkContent({ content })).resolves.toBeUndefined();
-    });
-
-    test("should use cached file when available", async () => {
-      const content = "A -> B: cached test";
-
-      // First call should generate
-      await checkContent({ content });
-
-      // Second call should use cache
-      const debugLogs = [];
-      const originalWrite = process.stderr.write;
-      process.stderr.write = (chunk) => {
-        debugLogs.push(chunk.toString());
-        return true;
-      };
-      Debug.enable("doc-smith");
-
-      try {
-        const startTime = Date.now();
-        await checkContent({ content });
-        const endTime = Date.now();
-
-        // Cache hit should be very fast (< 100ms)
-        expect(endTime - startTime).toBeLessThan(100);
-        expect(
-          debugLogs.some((log) => log.includes("Found assets cache, skipping generation")),
-        ).toBe(true);
-      } finally {
-        process.stderr.write = originalWrite;
-        Debug.disable();
-      }
-    });
-
-    test("should handle generation errors in strict mode", async () => {
-      const malformedContent = "A -> B -> [invalid";
-      await expect(checkContent({ content: malformedContent })).rejects.toThrow();
-    });
-
-    test("should handle empty content", async () => {
-      await expect(checkContent({ content: "" })).resolves.toBeUndefined();
-    });
-
-    test("should write .d2 file when debug is enabled", async () => {
-      const content = "A -> B: debug test";
-
-      Debug.enable("doc-smith");
-
-      try {
-        await checkContent({ content });
-
-        const assetDir = path.join(process.cwd(), DOC_SMITH_DIR, TMP_DIR, TMP_ASSETS_DIR, "d2");
-        const files = await readdir(assetDir);
-        const d2File = files.find((file) => file.endsWith(".d2"));
-        expect(d2File).toBeDefined();
-      } finally {
-        Debug.disable();
-      }
-    });
-  });
-
-  describe("ensureTmpDir", () => {
-    test("should create tmp directory structure", async () => {
-      // Change to temp directory for testing
-      const originalCwd = process.cwd();
-      process.chdir(tempDir);
-
-      try {
-        await ensureTmpDir();
-
-        const tmpDir = path.join(tempDir, DOC_SMITH_DIR, TMP_DIR);
-        const gitignorePath = path.join(tmpDir, ".gitignore");
-
-        expect(existsSync(tmpDir)).toBe(true);
-        expect(existsSync(gitignorePath)).toBe(true);
-
-        const gitignoreContent = await readFile(gitignorePath, "utf8");
-        expect(gitignoreContent).toBe("**/*");
-      } finally {
-        process.chdir(originalCwd);
-      }
-    });
-
-    test("should not recreate if already exists", async () => {
-      const originalCwd = process.cwd();
-      process.chdir(tempDir);
-
-      try {
-        // First call
-        await ensureTmpDir();
-
-        const tmpDir = path.join(tempDir, DOC_SMITH_DIR, TMP_DIR);
-        const gitignorePath = path.join(tmpDir, ".gitignore");
-
-        // Modify .gitignore to test if it gets overwritten
-        await writeFile(gitignorePath, "modified content");
-
-        // Second call
-        await ensureTmpDir();
-
-        const gitignoreContent = await readFile(gitignorePath, "utf8");
-        expect(gitignoreContent).toBe("modified content"); // Should not be overwritten
-      } finally {
-        process.chdir(originalCwd);
-      }
-    });
-  });
-
-  describe("isValidCode", () => {
-    test("should return true for 'd2'", () => {
-      expect(isValidCode("d2")).toBe(true);
-    });
-
-    test("should return true for 'D2'", () => {
-      expect(isValidCode("D2")).toBe(true);
-    });
-
-    test("should return false for other languages", () => {
-      expect(isValidCode("javascript")).toBe(false);
-      expect(isValidCode("python")).toBe(false);
-      expect(isValidCode("")).toBe(false);
-      expect(isValidCode(null)).toBe(false);
-      expect(isValidCode(undefined)).toBe(false);
-    });
-  });
-
-  describe("wrapCode", () => {
-    test("should return original content when D2 block already exists", () => {
-      const content = "```d2\nA -> B\n```";
-      expect(wrapCode({ content })).toBe(content);
-    });
-
-    test("should wrap plain content in a D2 code block", () => {
-      const content = "A -> B";
-      const expected = "```d2\nA -> B\n```";
-      expect(wrapCode({ content })).toBe(expected);
-    });
-  });
-});