@aigne/doc-smith 0.8.6 → 0.8.8

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

@@ -0,0 +1,358 @@
+import {
+  afterAll,
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  spyOn,
+  test,
+} from "bun:test";
+import * as fs from "node:fs";
+import * as fsPromises from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import * as yaml from "yaml";
+import { getAccessToken } from "../../utils/auth-utils.mjs";
+import * as blockletUtils from "../../utils/blocklet.mjs";
+
+// Mock external modules that involve network requests
+const mockCreateConnect = mock(() => Promise.resolve({ accessKeySecret: "new-access-token" }));
+const mockOpen = mock(() => Promise.resolve());
+const mockJoinURL = mock((base, path) => `${base}${path}`);
+
+describe("auth-utils", () => {
+  let originalEnv;
+
+  // Spies for internal operations
+  let existsSyncSpy;
+  let readFileSpy;
+  let writeFileSpy;
+  let mkdirSyncSpy;
+  let homedirSpy;
+  let joinSpy;
+  let parseSpy;
+  let stringifySpy;
+  let getComponentMountPointSpy;
+  let consoleWarnSpy;
+  let consoleDebugSpy;
+
+  beforeAll(() => {
+    // Apply mocks for external dependencies that involve network requests
+    mock.module("@aigne/cli/utils/aigne-hub/credential.js", () => ({
+      createConnect: mockCreateConnect,
+    }));
+    mock.module("open", () => ({ default: mockOpen }));
+    mock.module("join-url", () => ({ default: mockJoinURL }));
+  });
+
+  afterAll(() => {
+    // Restore all mocks when this test file is complete
+    mock.restore();
+  });
+
+  beforeEach(() => {
+    originalEnv = { ...process.env };
+    delete process.env.DOC_DISCUSS_KIT_ACCESS_TOKEN;
+
+    // Reset external mocks
+    mockCreateConnect.mockClear();
+    mockCreateConnect.mockImplementation(() =>
+      Promise.resolve({ accessKeySecret: "new-access-token" }),
+    );
+    mockOpen.mockClear();
+    mockOpen.mockImplementation(() => Promise.resolve());
+    mockJoinURL.mockClear();
+    mockJoinURL.mockImplementation((base, path) => `${base}${path}`);
+
+    // Spy on filesystem operations
+    existsSyncSpy = spyOn(fs, "existsSync").mockReturnValue(false);
+    readFileSpy = spyOn(fsPromises, "readFile").mockResolvedValue("");
+    writeFileSpy = spyOn(fsPromises, "writeFile").mockResolvedValue();
+    mkdirSyncSpy = spyOn(fs, "mkdirSync").mockImplementation(() => {});
+
+    // Spy on path operations
+    homedirSpy = spyOn(os, "homedir").mockReturnValue("/mock/home");
+    joinSpy = spyOn(path, "join").mockImplementation((...paths) => paths.join("/"));
+
+    // Spy on YAML operations
+    parseSpy = spyOn(yaml, "parse").mockReturnValue({});
+    stringifySpy = spyOn(yaml, "stringify").mockReturnValue("mock yaml");
+
+    // Spy on blocklet operations
+    getComponentMountPointSpy = spyOn(blockletUtils, "getComponentMountPoint").mockResolvedValue();
+
+    // Spy on console methods
+    consoleWarnSpy = spyOn(console, "warn").mockImplementation(() => {});
+    consoleDebugSpy = spyOn(console, "debug").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+
+    // Restore all spies
+    existsSyncSpy?.mockRestore();
+    readFileSpy?.mockRestore();
+    writeFileSpy?.mockRestore();
+    mkdirSyncSpy?.mockRestore();
+    homedirSpy?.mockRestore();
+    joinSpy?.mockRestore();
+    parseSpy?.mockRestore();
+    stringifySpy?.mockRestore();
+    getComponentMountPointSpy?.mockRestore();
+    consoleWarnSpy?.mockRestore();
+    consoleDebugSpy?.mockRestore();
+  });
+
+  test("should return access token from environment variable", async () => {
+    process.env.DOC_DISCUSS_KIT_ACCESS_TOKEN = "env-token";
+
+    const result = await getAccessToken("https://example.com");
+
+    expect(result).toBe("env-token");
+  });
+
+  test("should handle different URL formats", async () => {
+    process.env.DOC_DISCUSS_KIT_ACCESS_TOKEN = "test-token";
+
+    // Test different URL formats
+    const urls = [
+      "https://example.com",
+      "http://example.com",
+      "https://example.com:8080",
+      "https://sub.example.com/path",
+    ];
+
+    for (const url of urls) {
+      const result = await getAccessToken(url);
+      expect(result).toBe("test-token");
+    }
+  });
+
+  test("should handle invalid URL", async () => {
+    process.env.DOC_DISCUSS_KIT_ACCESS_TOKEN = "test-token";
+
+    await expect(getAccessToken("invalid-url")).rejects.toThrow();
+  });
+
+  test("should work with localhost URLs", async () => {
+    process.env.DOC_DISCUSS_KIT_ACCESS_TOKEN = "local-token";
+
+    const result = await getAccessToken("http://localhost:3000");
+
+    expect(result).toBe("local-token");
+  });
+
+  test("should preserve environment variable after function call", async () => {
+    process.env.DOC_DISCUSS_KIT_ACCESS_TOKEN = "persistent-token";
+
+    await getAccessToken("https://example.com");
+
+    expect(process.env.DOC_DISCUSS_KIT_ACCESS_TOKEN).toBe("persistent-token");
+  });
+
+  // CONFIG FILE READING TESTS
+  test("should read access token from config file", async () => {
+    existsSyncSpy.mockReturnValue(true);
+    readFileSpy.mockResolvedValue("DOC_DISCUSS_KIT_ACCESS_TOKEN: config-token");
+    parseSpy.mockReturnValue({
+      "example.com": {
+        DOC_DISCUSS_KIT_ACCESS_TOKEN: "config-token",
+      },
+    });
+
+    const result = await getAccessToken("https://example.com");
+
+    expect(result).toBe("config-token");
+    expect(joinSpy).toHaveBeenCalledWith("/mock/home", ".aigne", "doc-smith-connected.yaml");
+    expect(existsSyncSpy).toHaveBeenCalledWith("/mock/home/.aigne/doc-smith-connected.yaml");
+    expect(readFileSpy).toHaveBeenCalledWith("/mock/home/.aigne/doc-smith-connected.yaml", "utf8");
+    expect(parseSpy).toHaveBeenCalled();
+  });
+
+  test("should handle config file without token field", async () => {
+    existsSyncSpy.mockReturnValue(true);
+    readFileSpy.mockResolvedValue("other: value");
+    parseSpy.mockReturnValue({
+      "example.com": {
+        other: "value",
+      },
+    });
+
+    // Since we now have successful authorization flow mocked, this should succeed
+    const result = await getAccessToken("https://example.com");
+    expect(result).toBe("new-access-token");
+    expect(getComponentMountPointSpy).toHaveBeenCalled();
+  });
+
+  test("should handle missing hostname in config", async () => {
+    existsSyncSpy.mockReturnValue(true);
+    readFileSpy.mockResolvedValue("DOC_DISCUSS_KIT_ACCESS_TOKEN: token");
+    parseSpy.mockReturnValue({
+      "other-domain.com": {
+        DOC_DISCUSS_KIT_ACCESS_TOKEN: "other-token",
+      },
+    });
+
+    // Since we now have successful authorization flow mocked, this should succeed
+    const result = await getAccessToken("https://example.com");
+    expect(result).toBe("new-access-token");
+    expect(getComponentMountPointSpy).toHaveBeenCalled();
+  });
+
+  test("should handle config file read errors", async () => {
+    existsSyncSpy.mockReturnValue(true);
+    readFileSpy.mockRejectedValue(new Error("File read error"));
+    // Make createConnect fail to test the error path
+    mockCreateConnect.mockRejectedValueOnce(new Error("Network error"));
+
+    await expect(getAccessToken("https://example.com")).rejects.toThrow(
+      "Failed to obtain access token. Please check your network connection and try again later.",
+    );
+    expect(consoleWarnSpy).toHaveBeenCalledWith("Failed to read config file:", "File read error");
+  });
+
+  test("should handle config file without DOC_DISCUSS_KIT_ACCESS_TOKEN keyword", async () => {
+    existsSyncSpy.mockReturnValue(true);
+    readFileSpy.mockResolvedValue("some other content");
+
+    // Should succeed with authorization flow
+    const result = await getAccessToken("https://example.com");
+    expect(result).toBe("new-access-token");
+    // Verify that the config file was read but the flow proceeded to authorization
+    expect(readFileSpy).toHaveBeenCalled();
+  });
+
+  // ERROR HANDLING TESTS
+  test("should throw error for invalid blocklet", async () => {
+    const InvalidBlockletError = (await import("../../utils/blocklet.mjs")).InvalidBlockletError;
+    getComponentMountPointSpy.mockRejectedValue(new InvalidBlockletError());
+
+    await expect(getAccessToken("https://example.com")).rejects.toThrow(
+      "The provided URL is not a valid website on ArcBlock platform",
+    );
+  });
+
+  test("should throw error for missing component", async () => {
+    const ComponentNotFoundError = (await import("../../utils/blocklet.mjs"))
+      .ComponentNotFoundError;
+    getComponentMountPointSpy.mockRejectedValue(new ComponentNotFoundError());
+
+    await expect(getAccessToken("https://example.com")).rejects.toThrow(
+      "This website does not have required components for publishing",
+    );
+  });
+
+  test("should throw error for network issues", async () => {
+    getComponentMountPointSpy.mockRejectedValue(new Error("Network error"));
+
+    await expect(getAccessToken("https://example.com")).rejects.toThrow("Unable to connect to:");
+  });
+
+  // AUTHORIZATION FLOW TESTS
+  test("should successfully complete authorization flow", async () => {
+    // Mock successful component check
+    getComponentMountPointSpy.mockResolvedValue({ endpoint: "https://example.com/api" });
+
+    const result = await getAccessToken("https://example.com");
+
+    expect(result).toBe("new-access-token");
+
+    // Verify the authorization flow
+    expect(getComponentMountPointSpy).toHaveBeenCalledWith(
+      "https://example.com",
+      expect.any(String),
+    );
+    expect(mockCreateConnect).toHaveBeenCalledWith(
+      expect.objectContaining({
+        connectAction: "gen-simple-access-key",
+        source: "AIGNE DocSmith connect to website",
+        closeOnSuccess: true,
+        appName: "AIGNE DocSmith",
+        openPage: expect.any(Function),
+      }),
+    );
+
+    // Verify environment variable is set
+    expect(process.env.DOC_DISCUSS_KIT_ACCESS_TOKEN).toBe("new-access-token");
+
+    // Verify config file is saved
+    expect(writeFileSpy).toHaveBeenCalledWith(
+      "/mock/home/.aigne/doc-smith-connected.yaml",
+      "mock yaml",
+    );
+    expect(stringifySpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        "example.com": {
+          DOC_DISCUSS_KIT_ACCESS_TOKEN: "new-access-token",
+          DOC_DISCUSS_KIT_URL: "https://example.com",
+        },
+      }),
+    );
+  });
+
+  test("should create .aigne directory if it doesn't exist", async () => {
+    getComponentMountPointSpy.mockResolvedValue({ endpoint: "https://example.com/api" });
+    existsSyncSpy.mockReturnValueOnce(false); // .aigne directory doesn't exist
+
+    const result = await getAccessToken("https://example.com");
+
+    expect(result).toBe("new-access-token");
+    expect(mkdirSyncSpy).toHaveBeenCalledWith("/mock/home/.aigne", { recursive: true });
+  });
+
+  test("should merge with existing config file", async () => {
+    getComponentMountPointSpy.mockResolvedValue({ endpoint: "https://example.com/api" });
+    existsSyncSpy
+      .mockReturnValueOnce(true) // .aigne directory exists
+      .mockReturnValueOnce(true); // config file exists at save time
+    readFileSpy.mockResolvedValue("other.com:\n  token: other-token");
+    parseSpy.mockReturnValue({ "other.com": { token: "other-token" } });
+
+    const result = await getAccessToken("https://example.com");
+
+    expect(result).toBe("new-access-token");
+    expect(stringifySpy).toHaveBeenCalled();
+    // Verify that config file writing was attempted
+    expect(writeFileSpy).toHaveBeenCalled();
+  });
+
+  test("should call openPage function with correct URL", async () => {
+    getComponentMountPointSpy.mockResolvedValue({ endpoint: "https://example.com/api" });
+
+    let capturedOpenPage;
+    mockCreateConnect.mockImplementation((options) => {
+      capturedOpenPage = options.openPage;
+      return Promise.resolve({ accessKeySecret: "new-access-token" });
+    });
+
+    const result = await getAccessToken("https://example.com");
+
+    expect(result).toBe("new-access-token");
+    expect(typeof capturedOpenPage).toBe("function");
+
+    // Test that openPage calls the mock open function
+    await capturedOpenPage("https://auth.example.com");
+    expect(mockOpen).toHaveBeenCalledWith("https://auth.example.com/");
+  });
+
+  test("should handle authorization failure", async () => {
+    getComponentMountPointSpy.mockResolvedValue({ endpoint: "https://example.com/api" });
+    mockCreateConnect.mockRejectedValue(new Error("Authorization failed"));
+
+    await expect(getAccessToken("https://example.com")).rejects.toThrow(
+      "Failed to obtain access token. Please check your network connection and try again later.",
+    );
+    expect(consoleDebugSpy).toHaveBeenCalledWith(expect.any(Error));
+  });
+
+  test("should handle createConnect with different error types", async () => {
+    getComponentMountPointSpy.mockResolvedValue({ endpoint: "https://example.com/api" });
+    mockCreateConnect.mockRejectedValue(new TypeError("Network error"));
+
+    await expect(getAccessToken("https://example.com")).rejects.toThrow(
+      "Failed to obtain access token. Please check your network connection and try again later.",
+    );
+  });
+});

package/tests/utils/blocklet.test.mjs

@@ -0,0 +1,334 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import {
+  ComponentNotFoundError,
+  getComponentMountPoint,
+  InvalidBlockletError,
+} from "../../utils/blocklet.mjs";
+
+// Mock global fetch
+const mockFetch = mock();
+global.fetch = mockFetch;
+
+describe("blocklet", () => {
+  beforeEach(() => {
+    mockFetch.mockClear();
+  });
+
+  afterEach(() => {
+    mockFetch.mockRestore?.();
+  });
+
+  // ERROR CLASSES TESTS
+  describe("InvalidBlockletError", () => {
+    test("should create error with correct properties", () => {
+      const url = "https://example.com";
+      const status = 404;
+      const statusText = "Not Found";
+
+      const error = new InvalidBlockletError(url, status, statusText);
+
+      expect(error).toBeInstanceOf(Error);
+      expect(error.name).toBe("InvalidBlockletError");
+      expect(error.message).toBe(
+        'Invalid application URL: "https://example.com". Unable to fetch configuration.',
+      );
+      expect(error.url).toBe(url);
+      expect(error.status).toBe(status);
+      expect(error.statusText).toBe(statusText);
+    });
+
+    test("should handle null status and statusText", () => {
+      const url = "https://example.com";
+
+      const error = new InvalidBlockletError(url, null, "Network error");
+
+      expect(error.url).toBe(url);
+      expect(error.status).toBeNull();
+      expect(error.statusText).toBe("Network error");
+    });
+
+    test("should be instanceof Error", () => {
+      const error = new InvalidBlockletError("https://example.com");
+      expect(error instanceof Error).toBe(true);
+      expect(error instanceof InvalidBlockletError).toBe(true);
+    });
+  });
+
+  describe("ComponentNotFoundError", () => {
+    test("should create error with correct properties", () => {
+      const did = "z8ia28nJVd6UMcS4dcJf5NLhv3rLmrFCK";
+      const appUrl = "https://example.com";
+
+      const error = new ComponentNotFoundError(did, appUrl);
+
+      expect(error).toBeInstanceOf(Error);
+      expect(error.name).toBe("ComponentNotFoundError");
+      expect(error.message).toBe(
+        'Your website "https://example.com" missing required component to host your docs.',
+      );
+      expect(error.did).toBe(did);
+      expect(error.appUrl).toBe(appUrl);
+    });
+
+    test("should be instanceof Error", () => {
+      const error = new ComponentNotFoundError("test-did", "https://example.com");
+      expect(error instanceof Error).toBe(true);
+      expect(error instanceof ComponentNotFoundError).toBe(true);
+    });
+  });
+
+  // GETCOMPONENTMOUNTPOINT FUNCTION TESTS
+  describe("getComponentMountPoint", () => {
+    const testAppUrl = "https://example.com";
+    const testDid = "z8ia28nJVd6UMcS4dcJf5NLhv3rLmrFCK";
+    const expectedUrl = "https://example.com/__blocklet__.js?type=json";
+
+    test("should return mount point for existing component", async () => {
+      const mockConfig = {
+        componentMountPoints: [
+          { did: "other-did", mountPoint: "/other" },
+          { did: testDid, mountPoint: "/api/discuss" },
+          { did: "another-did", mountPoint: "/another" },
+        ],
+      };
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve(mockConfig),
+      });
+
+      const result = await getComponentMountPoint(testAppUrl, testDid);
+
+      expect(result).toBe("/api/discuss");
+      expect(mockFetch).toHaveBeenCalledWith(expectedUrl, {
+        method: "GET",
+        headers: { Accept: "application/json" },
+      });
+    });
+
+    // NETWORK ERROR TESTS
+    test("should throw InvalidBlockletError when fetch fails", async () => {
+      mockFetch.mockRejectedValue(new Error("Network timeout"));
+
+      await expect(getComponentMountPoint(testAppUrl, testDid)).rejects.toThrow(
+        InvalidBlockletError,
+      );
+
+      try {
+        await getComponentMountPoint(testAppUrl, testDid);
+      } catch (error) {
+        expect(error.url).toBe(testAppUrl);
+        expect(error.status).toBeNull();
+        expect(error.statusText).toBe("Network timeout");
+      }
+    });
+
+    test("should throw InvalidBlockletError when response is not ok", async () => {
+      mockFetch.mockResolvedValue({
+        ok: false,
+        status: 404,
+        statusText: "Not Found",
+      });
+
+      await expect(getComponentMountPoint(testAppUrl, testDid)).rejects.toThrow(
+        InvalidBlockletError,
+      );
+
+      try {
+        await getComponentMountPoint(testAppUrl, testDid);
+      } catch (error) {
+        expect(error.url).toBe(testAppUrl);
+        expect(error.status).toBe(404);
+        expect(error.statusText).toBe("Not Found");
+      }
+    });
+
+    test("should throw InvalidBlockletError when JSON parsing fails", async () => {
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.reject(new Error("Invalid JSON")),
+      });
+
+      await expect(getComponentMountPoint(testAppUrl, testDid)).rejects.toThrow(
+        InvalidBlockletError,
+      );
+
+      try {
+        await getComponentMountPoint(testAppUrl, testDid);
+      } catch (error) {
+        expect(error.url).toBe(testAppUrl);
+        expect(error.status).toBeNull();
+        expect(error.statusText).toBe("Invalid JSON response");
+      }
+    });
+
+    // COMPONENT NOT FOUND TESTS
+    test("should throw ComponentNotFoundError when component is not found", async () => {
+      const mockConfig = {
+        componentMountPoints: [
+          { did: "other-did", mountPoint: "/other" },
+          { did: "another-did", mountPoint: "/another" },
+        ],
+      };
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve(mockConfig),
+      });
+
+      await expect(getComponentMountPoint(testAppUrl, testDid)).rejects.toThrow(
+        ComponentNotFoundError,
+      );
+
+      try {
+        await getComponentMountPoint(testAppUrl, testDid);
+      } catch (error) {
+        expect(error.did).toBe(testDid);
+        expect(error.appUrl).toBe(testAppUrl);
+      }
+    });
+
+    test("should throw ComponentNotFoundError when componentMountPoints is undefined", async () => {
+      const mockConfig = {};
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve(mockConfig),
+      });
+
+      await expect(getComponentMountPoint(testAppUrl, testDid)).rejects.toThrow(
+        ComponentNotFoundError,
+      );
+    });
+
+    test("should throw ComponentNotFoundError when componentMountPoints is empty", async () => {
+      const mockConfig = {
+        componentMountPoints: [],
+      };
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve(mockConfig),
+      });
+
+      await expect(getComponentMountPoint(testAppUrl, testDid)).rejects.toThrow(
+        ComponentNotFoundError,
+      );
+    });
+
+    // EDGE CASES
+    test("should handle component at the beginning of array", async () => {
+      const mockConfig = {
+        componentMountPoints: [
+          { did: testDid, mountPoint: "/first" },
+          { did: "other-did", mountPoint: "/other" },
+        ],
+      };
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve(mockConfig),
+      });
+
+      const result = await getComponentMountPoint(testAppUrl, testDid);
+      expect(result).toBe("/first");
+    });
+
+    test("should handle component at the end of array", async () => {
+      const mockConfig = {
+        componentMountPoints: [
+          { did: "other-did", mountPoint: "/other" },
+          { did: testDid, mountPoint: "/last" },
+        ],
+      };
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve(mockConfig),
+      });
+
+      const result = await getComponentMountPoint(testAppUrl, testDid);
+      expect(result).toBe("/last");
+    });
+
+    test("should handle single component", async () => {
+      const mockConfig = {
+        componentMountPoints: [{ did: testDid, mountPoint: "/single" }],
+      };
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve(mockConfig),
+      });
+
+      const result = await getComponentMountPoint(testAppUrl, testDid);
+      expect(result).toBe("/single");
+    });
+
+    test("should handle complex mount points", async () => {
+      const mockConfig = {
+        componentMountPoints: [{ did: testDid, mountPoint: "/api/v1/discuss-kit/endpoint" }],
+      };
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve(mockConfig),
+      });
+
+      const result = await getComponentMountPoint(testAppUrl, testDid);
+      expect(result).toBe("/api/v1/discuss-kit/endpoint");
+    });
+
+    test("should handle empty mount point", async () => {
+      const mockConfig = {
+        componentMountPoints: [{ did: testDid, mountPoint: "" }],
+      };
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve(mockConfig),
+      });
+
+      const result = await getComponentMountPoint(testAppUrl, testDid);
+      expect(result).toBe("");
+    });
+
+    test("should handle null/undefined mount point", async () => {
+      const mockConfig = {
+        componentMountPoints: [{ did: testDid, mountPoint: null }],
+      };
+
+      mockFetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve(mockConfig),
+      });
+
+      const result = await getComponentMountPoint(testAppUrl, testDid);
+      expect(result).toBeNull();
+    });
+
+    // NETWORK TIMEOUT AND RETRY SCENARIOS
+    test("should handle network errors with different error types", async () => {
+      const errorTypes = [
+        new TypeError("Failed to fetch"),
+        new Error("Connection refused"),
+        new Error("Timeout"),
+        new ReferenceError("Network error"),
+      ];
+
+      for (const error of errorTypes) {
+        mockFetch.mockRejectedValueOnce(error);
+
+        try {
+          await getComponentMountPoint(testAppUrl, testDid);
+          expect(true).toBe(false); // Should not reach here
+        } catch (caughtError) {
+          expect(caughtError).toBeInstanceOf(InvalidBlockletError);
+          expect(caughtError.url).toBe(testAppUrl);
+          expect(caughtError.status).toBeNull();
+          expect(caughtError.statusText).toBe(error.message);
+        }
+      }
+    });
+  });
+});

package/tests/{conflict-resolution.test.mjs → utils/conflict-detector.test.mjs}

@@ -3,10 +3,10 @@ import {
   detectResolvableConflicts,
   generateConflictResolutionRules,
   getFilteredOptions,
-} from "../utils/conflict-detector.mjs";
-import { processConfigFields } from "../utils/utils.mjs";
+} from "../../utils/conflict-detector.mjs";
+import { processConfigFields } from "../../utils/utils.mjs";
 
-describe("conflict resolution", () => {
+describe("conflict-detector", () => {
   describe("getFilteredOptions", () => {
     test("should filter experiencedUsers when documentPurpose is getStarted", () => {
       const allOptions = {