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

package/tests/utils/linter/index.test.mjs

@@ -1,440 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import fsSync from "node:fs";
-import fs from "node:fs/promises";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-import { CODE_LANGUAGE_MAP_LINTER } from "../../../utils/constants/linter.mjs";
-import { lintCode } from "../../../utils/linter/index.mjs";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// Expected exact counts observed from linter service for our fixtures.
-// Generated by local scan-results script.
-const EXPECTED = {
-  js: {
-    "undeclare-variable.js": { errors: 1, warnings: 2 },
-    "keyword-error.js": { errors: 2, warnings: 1 },
-    "missing-semicolon.js": { errors: 0, warnings: 1 },
-    "syntax-error.js": { errors: 1, warnings: 1 },
-    "unused-variable.js": { errors: 0, warnings: 2 },
-    "valid-code.js": { errors: 0, warnings: 0 },
-  },
-  python: {
-    "missing-semicolon.py": { errors: 0, warnings: 1 },
-    "unused-variable.py": { errors: 0, warnings: 2 },
-    "valid-code.py": { errors: 0, warnings: 2 },
-    "keyword-error.py": { errors: 0, warnings: 1 },
-    "undeclare-variable.py": { errors: 0, warnings: 1 },
-    "syntax-error.py": { errors: 0, warnings: 1 },
-  },
-  css: {
-    "missing-semicolon.css": { errors: 0, warnings: 0 },
-    "syntax-error.css": { errors: 0, warnings: 0 },
-    "unused-variable.css": { errors: 0, warnings: 0 },
-    "keyword-error.css": { errors: 0, warnings: 0 },
-    "valid-code.css": { errors: 0, warnings: 0 },
-    "undeclare-variable.css": { errors: 0, warnings: 0 },
-  },
-  ts: {
-    "undeclare-variable.ts": { errors: 1, warnings: 0 },
-    "valid-code.ts": { errors: 0, warnings: 0 },
-    "unused-variable.ts": { errors: 0, warnings: 1 },
-    "missing-semicolon.ts": { errors: 0, warnings: 0 },
-    "keyword-error.ts": { errors: 2, warnings: 0 },
-    "syntax-error.ts": { errors: 2, warnings: 0 },
-  },
-  jsx: {
-    "valid-code.jsx": { errors: 0, warnings: 1 },
-    "keyword-error.jsx": { errors: 0, warnings: 0 },
-    "syntax-error.jsx": { errors: 0, warnings: 0 },
-    "missing-semicolon.jsx": { errors: 0, warnings: 1 },
-    "unused-variable.jsx": { errors: 0, warnings: 2 },
-    "undeclare-variable.jsx": { errors: 0, warnings: 1 },
-  },
-  yaml: {
-    "unused-variable.yml": { errors: 0, warnings: 1 },
-    "valid-code.yml": { errors: 0, warnings: 1 },
-    "syntax-error.yml": { errors: 1, warnings: 1 },
-    "missing-semicolon.yml": { errors: 0, warnings: 1 },
-    "keyword-error.yml": { errors: 0, warnings: 1 },
-    "undeclare-variable.yml": { errors: 3, warnings: 0 },
-  },
-  sass: {
-    "syntax-error.sass": { errors: 0, warnings: 0 },
-    "unused-variable.sass": { errors: 0, warnings: 0 },
-    "keyword-error.sass": { errors: 0, warnings: 0 },
-    "undeclare-variable.sass": { errors: 0, warnings: 0 },
-    "valid-code.sass": { errors: 0, warnings: 0 },
-    "missing-semicolon.sass": { errors: 0, warnings: 0 },
-  },
-  json: {
-    "missing-semicolon.json": { errors: 0, warnings: 0 },
-    "unused-variable.json": { errors: 0, warnings: 0 },
-    "keyword-error.json": { errors: 1, warnings: 0 },
-    "undeclare-variable.json": { errors: 2, warnings: 0 },
-    "syntax-error.json": { errors: 1, warnings: 0 },
-    "valid-code.json": { errors: 0, warnings: 0 },
-  },
-  tsx: {
-    "unused-variable.tsx": { errors: 0, warnings: 2 },
-    "undeclare-variable.tsx": { errors: 0, warnings: 2 },
-    "valid-code.tsx": { errors: 0, warnings: 1 },
-    "missing-semicolon.tsx": { errors: 0, warnings: 1 },
-    "keyword-error.tsx": { errors: 0, warnings: 0 },
-    "syntax-error.tsx": { errors: 0, warnings: 0 },
-  },
-  ruby: {
-    "valid-code.rb": { errors: 0, warnings: 0 },
-    "keyword-error.rb": { errors: 0, warnings: 0 },
-    "syntax-error.rb": { errors: 0, warnings: 0 },
-    "undeclare-variable.rb": { errors: 0, warnings: 0 },
-    "missing-semicolon.rb": { errors: 0, warnings: 0 },
-    "unused-variable.rb": { errors: 0, warnings: 0 },
-  },
-  dockerfile: {
-    "syntax-error.dockerfile": { errors: 1, warnings: 1 },
-    "unused-variable.dockerfile": { errors: 0, warnings: 0 },
-    "keyword-error.dockerfile": { errors: 1, warnings: 0 },
-    "valid-code.dockerfile": { errors: 0, warnings: 0 },
-    "undeclare-variable.dockerfile": { errors: 0, warnings: 0 },
-    "missing-semicolon.dockerfile": { errors: 0, warnings: 1 },
-  },
-  scss: {
-    "keyword-error.scss": { errors: 0, warnings: 0 },
-    "syntax-error.scss": { errors: 0, warnings: 0 },
-    "undeclare-variable.scss": { errors: 0, warnings: 0 },
-    "valid-code.scss": { errors: 0, warnings: 0 },
-    "missing-semicolon.scss": { errors: 0, warnings: 0 },
-    "unused-variable.scss": { errors: 0, warnings: 0 },
-  },
-  vue: {
-    "unused-variable.vue": { errors: 0, warnings: 0 },
-    "missing-semicolon.vue": { errors: 0, warnings: 0 },
-    "valid-code.vue": { errors: 0, warnings: 0 },
-    "keyword-error.vue": { errors: 0, warnings: 0 },
-    "syntax-error.vue": { errors: 0, warnings: 0 },
-    "undeclare-variable.vue": { errors: 0, warnings: 0 },
-  },
-  go: {
-    "valid-code.go": { errors: 0, warnings: 0 },
-    "unused-variable.go": { errors: 0, warnings: 0 },
-    "undeclare-variable.go": { errors: 0, warnings: 0 },
-    "keyword-error.go": { errors: 0, warnings: 0 },
-    "syntax-error.go": { errors: 0, warnings: 0 },
-    "missing-semicolon.go": { errors: 0, warnings: 0 },
-  },
-};
-
-// Error handling tests for uncovered lines
-describe("lintCode error handling", () => {
-  test("should throw error when code parameter is missing", async () => {
-    await expect(lintCode({ code: null })).rejects.toThrow("Code parameter is required");
-    await expect(lintCode({ code: undefined })).rejects.toThrow("Code parameter is required");
-    await expect(lintCode({ code: "" })).rejects.toThrow("Code parameter is required");
-    await expect(lintCode({})).rejects.toThrow("Code parameter is required");
-  });
-
-  test("should throw error for HTTP error response", async () => {
-    const originalFetch = globalThis.fetch;
-
-    // Mock fetch to return HTTP error
-    globalThis.fetch = async () => ({
-      ok: false,
-      status: 500,
-    });
-
-    try {
-      await expect(lintCode({ code: "console.log('test')" })).rejects.toThrow(
-        "HTTP error! status: 500",
-      );
-    } finally {
-      globalThis.fetch = originalFetch;
-    }
-  });
-
-  test("should throw error for invalid response data", async () => {
-    const originalFetch = globalThis.fetch;
-
-    // Mock fetch to return response with null data
-    globalThis.fetch = async () => ({
-      ok: true,
-      json: async () => null,
-    });
-
-    try {
-      await expect(lintCode({ code: "console.log('test')" })).rejects.toThrow(
-        "Invalid response data",
-      );
-    } finally {
-      globalThis.fetch = originalFetch;
-    }
-  });
-
-  test("should handle fetch timeout and other network errors", async () => {
-    const originalFetch = globalThis.fetch;
-
-    // Mock fetch to throw network error
-    globalThis.fetch = async () => {
-      throw new Error("Network error");
-    };
-
-    try {
-      await expect(lintCode({ code: "console.log('test')" })).rejects.toThrow(
-        "Linting failed: Network error",
-      );
-    } finally {
-      globalThis.fetch = originalFetch;
-    }
-  });
-
-  test("should handle JSON parsing errors", async () => {
-    const originalFetch = globalThis.fetch;
-
-    // Mock fetch to return invalid JSON
-    globalThis.fetch = async () => ({
-      ok: true,
-      json: async () => {
-        throw new Error("Invalid JSON");
-      },
-    });
-
-    try {
-      await expect(lintCode({ code: "console.log('test')" })).rejects.toThrow(
-        "Linting failed: Invalid JSON",
-      );
-    } finally {
-      globalThis.fetch = originalFetch;
-    }
-  });
-
-  test("should handle AbortController abort signal", async () => {
-    const originalFetch = globalThis.fetch;
-
-    // Mock fetch to simulate abort error
-    globalThis.fetch = async (_url, _options) => {
-      // Simulate immediate abort
-      const error = new Error("The operation was aborted");
-      error.name = "AbortError";
-      throw error;
-    };
-
-    try {
-      await expect(lintCode({ code: "console.log('test')" })).rejects.toThrow(
-        "Linting failed: The operation was aborted",
-      );
-    } finally {
-      globalThis.fetch = originalFetch;
-    }
-  });
-});
-
-describe("lintCode js", () => {
-  const jsLinter = CODE_LANGUAGE_MAP_LINTER.js;
-
-  test("should lint js undeclare variable error", async () => {
-    const code = await fs.readFile(
-      path.join(__dirname, "fixtures/js/undeclare-variable.js"),
-      "utf-8",
-    );
-    const result = await lintCode({ code, linter: jsLinter });
-    if (!result || !Array.isArray(result.issues)) return;
-    const expectMap = EXPECTED?.js?.["undeclare-variable.js"];
-    if (!expectMap) return;
-    const errors = result.issues.filter((x) => x.severity === "error").length;
-    const warnings = result.issues.filter((x) => x.severity === "warning").length;
-    expect(errors).toEqual(expectMap.errors);
-    expect(warnings).toEqual(expectMap.warnings);
-  });
-
-  test("should lint js keyword error", async () => {
-    const code = await fs.readFile(path.join(__dirname, "fixtures/js/keyword-error.js"), "utf-8");
-    const result = await lintCode({ code, linter: "biome-lint" });
-    if (!result || !Array.isArray(result.issues)) return;
-    const expectMap = EXPECTED?.js?.["keyword-error.js"];
-    if (!expectMap) return;
-    const errors = result.issues.filter((x) => x.severity === "error").length;
-    const warnings = result.issues.filter((x) => x.severity === "warning").length;
-    expect(errors).toEqual(expectMap.errors);
-    expect(warnings).toEqual(expectMap.warnings);
-  });
-
-  test("should lint js missing semicolon error", async () => {
-    const code = await fs.readFile(
-      path.join(__dirname, "fixtures/js/missing-semicolon.js"),
-      "utf-8",
-    );
-    const result = await lintCode({ code, linter: jsLinter });
-    if (!result || !Array.isArray(result.issues)) return;
-    const expectMap = EXPECTED?.js?.["missing-semicolon.js"];
-    if (!expectMap) return;
-    const errors = result.issues.filter((x) => x.severity === "error").length;
-    const warnings = result.issues.filter((x) => x.severity === "warning").length;
-    expect(errors).toEqual(expectMap.errors);
-    expect(warnings).toEqual(expectMap.warnings);
-  });
-
-  test("should lint js syntax error in syntax-error.js", async () => {
-    const code = await fs.readFile(path.join(__dirname, "fixtures/js/syntax-error.js"), "utf-8");
-    const result = await lintCode({ code, linter: jsLinter });
-    if (!result || !Array.isArray(result.issues)) return;
-    const expectMap = EXPECTED?.js?.["syntax-error.js"];
-    if (!expectMap) return;
-    const errors = result.issues.filter((x) => x.severity === "error").length;
-    const warnings = result.issues.filter((x) => x.severity === "warning").length;
-    expect(errors).toEqual(expectMap.errors);
-    expect(warnings).toEqual(expectMap.warnings);
-  });
-
-  test("should lint js code with unused variables", async () => {
-    const code = await fs.readFile(path.join(__dirname, "fixtures/js/unused-variable.js"), "utf-8");
-    const result = await lintCode({ code, linter: jsLinter });
-    if (!result || !Array.isArray(result.issues)) return;
-    const expectMap = EXPECTED?.js?.["unused-variable.js"];
-    if (!expectMap) return;
-    const errors = result.issues.filter((x) => x.severity === "error").length;
-    const warnings = result.issues.filter((x) => x.severity === "warning").length;
-    expect(errors).toEqual(expectMap.errors);
-    expect(warnings).toEqual(expectMap.warnings);
-  });
-
-  test("should lint valid js code with no errors", async () => {
-    const code = await fs.readFile(path.join(__dirname, "fixtures/js/valid-code.js"), "utf-8");
-    const result = await lintCode({ code, linter: jsLinter });
-    if (!result || !Array.isArray(result.issues)) return;
-    const expectMap = EXPECTED?.js?.["valid-code.js"];
-    if (!expectMap) return;
-    const errors = result.issues.filter((x) => x.severity === "error").length;
-    const warnings = result.issues.filter((x) => x.severity === "warning").length;
-    expect(errors).toEqual(expectMap.errors);
-    expect(warnings).toEqual(expectMap.warnings);
-  });
-});
-
-// Helper to create a suite for a language
-function createLanguageSuite({ langKey, fixtureDir, suffix }) {
-  const linter = CODE_LANGUAGE_MAP_LINTER[langKey];
-  // Skip if fixture files for this language do not exist to avoid ENOENT errors
-  const validPath = path.join(__dirname, `fixtures/${fixtureDir}/valid-code${suffix || ""}`);
-  if (!fsSync.existsSync(validPath)) return;
-
-  describe(`lintCode ${langKey}`, () => {
-    test(`should lint ${langKey} undeclare variable error`, async () => {
-      const code = await fs.readFile(
-        path.join(__dirname, `fixtures/${fixtureDir}/undeclare-variable${suffix || ""}`),
-        "utf-8",
-      );
-      const result = await lintCode({ code, linter, suffix });
-      if (!result || !Array.isArray(result.issues)) return;
-      const key = `undeclare-variable${suffix || ""}`.replace(/^[.]/, "");
-      const expectMap = EXPECTED?.[fixtureDir]?.[key];
-      if (!expectMap) return;
-      const errors = result.issues.filter((x) => x.severity === "error").length;
-      const warnings = result.issues.filter((x) => x.severity === "warning").length;
-      expect(errors).toEqual(expectMap.errors);
-      expect(warnings).toEqual(expectMap.warnings);
-    });
-
-    test(`should lint ${langKey} keyword error`, async () => {
-      const code = await fs.readFile(
-        path.join(__dirname, `fixtures/${fixtureDir}/keyword-error${suffix || ""}`),
-        "utf-8",
-      );
-      const result = await lintCode({ code, linter, suffix });
-      if (!result || !Array.isArray(result.issues)) return;
-      const expectMap = EXPECTED?.[fixtureDir]?.[`keyword-error${suffix || ""}`];
-      if (!expectMap) return;
-      const errors = result.issues.filter((x) => x.severity === "error").length;
-      const warnings = result.issues.filter((x) => x.severity === "warning").length;
-      expect(errors).toEqual(expectMap.errors);
-      expect(warnings).toEqual(expectMap.warnings);
-    });
-
-    test(`should lint ${langKey} missing semicolon/style issue`, async () => {
-      const file = `missing-semicolon${suffix || ""}`;
-      const code = await fs.readFile(
-        path.join(__dirname, `fixtures/${fixtureDir}/${file}`),
-        "utf-8",
-      );
-      const result = await lintCode({ code, linter, suffix });
-      if (!result || !Array.isArray(result.issues)) return;
-      const expectMap = EXPECTED?.[fixtureDir]?.[file];
-      if (!expectMap) return;
-      const errors = result.issues.filter((x) => x.severity === "error").length;
-      const warnings = result.issues.filter((x) => x.severity === "warning").length;
-      expect(errors).toEqual(expectMap.errors);
-      expect(warnings).toEqual(expectMap.warnings);
-    });
-
-    test(`should lint ${langKey} syntax error`, async () => {
-      const code = await fs.readFile(
-        path.join(__dirname, `fixtures/${fixtureDir}/syntax-error${suffix || ""}`),
-        "utf-8",
-      );
-      const result = await lintCode({ code, linter, suffix });
-      if (!result || !Array.isArray(result.issues)) return;
-      const expectMap = EXPECTED?.[fixtureDir]?.[`syntax-error${suffix || ""}`];
-      if (!expectMap) return;
-      const errors = result.issues.filter((x) => x.severity === "error").length;
-      const warnings = result.issues.filter((x) => x.severity === "warning").length;
-      expect(errors).toEqual(expectMap.errors);
-      expect(warnings).toEqual(expectMap.warnings);
-    });
-
-    test(`should lint ${langKey} code with unused variables`, async () => {
-      const code = await fs.readFile(
-        path.join(__dirname, `fixtures/${fixtureDir}/unused-variable${suffix || ""}`),
-        "utf-8",
-      );
-      const result = await lintCode({ code, linter, suffix });
-      if (!result || !Array.isArray(result.issues)) return;
-      const expectMap = EXPECTED?.[fixtureDir]?.[`unused-variable${suffix || ""}`];
-      if (!expectMap) return;
-      const errors = result.issues.filter((x) => x.severity === "error").length;
-      const warnings = result.issues.filter((x) => x.severity === "warning").length;
-      expect(errors).toEqual(expectMap.errors);
-      expect(warnings).toEqual(expectMap.warnings);
-    });
-
-    test(`should lint valid ${langKey} code with no errors`, async () => {
-      const code = await fs.readFile(
-        path.join(__dirname, `fixtures/${fixtureDir}/valid-code${suffix || ""}`),
-        "utf-8",
-      );
-      const result = await lintCode({ code, linter, suffix });
-      if (!result || !Array.isArray(result.issues)) return;
-      const expectMap = EXPECTED?.[fixtureDir]?.[`valid-code${suffix || ""}`];
-      if (!expectMap) return;
-      const errors = result.issues.filter((x) => x.severity === "error").length;
-      const warnings = result.issues.filter((x) => x.severity === "warning").length;
-      expect(errors).toEqual(expectMap.errors);
-      expect(warnings).toEqual(expectMap.warnings);
-    });
-  });
-}
-
-// Create suites for other languages defined in CODE_LANGUAGE_MAP_LINTER
-// FIXME: @zhanghan lint error is wrong, skip it now
-// createLanguageSuite({ langKey: "python", fixtureDir: "python", suffix: ".py" });
-createLanguageSuite({ langKey: "shell", fixtureDir: "shell", suffix: ".sh" });
-// FIXME: @zhanghan lint error is wrong, skip it now
-// createLanguageSuite({ langKey: "go", fixtureDir: "go", suffix: ".go" });
-// FIXME: @zhanghan lint error is wrong, skip it now
-// createLanguageSuite({ langKey: "ruby", fixtureDir: "ruby", suffix: ".rb" });
-createLanguageSuite({ langKey: "dockerfile", fixtureDir: "dockerfile", suffix: ".dockerfile" });
-createLanguageSuite({ langKey: "yaml", fixtureDir: "yaml", suffix: ".yml" });
-// FIXME: @zhanghan lint error failed, skip it now
-// createLanguageSuite({ langKey: "css", fixtureDir: "css", suffix: ".css" });
-// FIXME: @zhanghan lint error failed (INSERT INTO lint_results), skip it now
-// createLanguageSuite({ langKey: "jsx", fixtureDir: "jsx", suffix: ".jsx" });
-// FIXME: @zhanghan lint error failed (INSERT INTO lint_results), skip it now
-// createLanguageSuite({ langKey: "tsx", fixtureDir: "tsx", suffix: ".tsx" });
-createLanguageSuite({ langKey: "ts", fixtureDir: "ts", suffix: ".ts" });
-// FIXME: @zhanghan lint error failed (ESLint couldn't find a configuration file), skip it now
-// createLanguageSuite({ langKey: "vue", fixtureDir: "vue", suffix: ".vue" });
-// FIXME: @zhanghan lint error failed (Error: No configuration provided), skip it now
-// createLanguageSuite({ langKey: "sass", fixtureDir: "sass", suffix: ".sass" });
-// FIXME: @zhanghan lint error failed (Error: No configuration provided), skip it now
-// createLanguageSuite({ langKey: "scss", fixtureDir: "scss", suffix: ".scss" });
-createLanguageSuite({ langKey: "json", fixtureDir: "json", suffix: ".json" });

package/tests/utils/linter/scan-results.mjs

@@ -1,42 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-
-const fixturesRoot = path.join(process.cwd(), "tests", "utils", "linter", "fixtures");
-const { lintCode } = await import(
-  `file://${path.join(process.cwd(), "utils", "linter", "index.mjs")}`
-);
-const { CODE_LANGUAGE_MAP_LINTER } = await import(
-  `file://${path.join(process.cwd(), "utils", "constants", "linter.mjs")}`
-);
-
-async function scan() {
-  const langs = await fs.readdir(fixturesRoot);
-  const results = {};
-  for (const lang of langs) {
-    const dir = path.join(fixturesRoot, lang);
-    const stat = await fs.stat(dir);
-    if (!stat.isDirectory()) continue;
-    const files = await fs.readdir(dir);
-    if (files.length === 0) continue;
-    const linter =
-      CODE_LANGUAGE_MAP_LINTER[lang] || CODE_LANGUAGE_MAP_LINTER[lang.replace(".", "")] || null;
-    results[lang] = [];
-    for (const file of files) {
-      const filePath = path.join(dir, file);
-      const code = await fs.readFile(filePath, "utf-8");
-      const suffix = path.extname(file);
-      try {
-        const res = await lintCode({ code, linter: linter || undefined, suffix });
-        const issues = Array.isArray(res?.issues) ? res.issues : [];
-        const errors = issues.filter((i) => i.severity === "error").length;
-        const warnings = issues.filter((i) => i.severity === "warning").length;
-        results[lang].push({ file, success: res?.success, total: issues.length, errors, warnings });
-      } catch (err) {
-        results[lang].push({ file, error: String(err) });
-      }
-    }
-  }
-  console.log(JSON.stringify(results, null, 2));
-}
-
-await scan();

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

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