@aigne/doc-smith 0.8.11-beta → 0.8.11-beta.2

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

@@ -14,8 +14,9 @@ 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 { getAccessToken, getOfficialAccessToken } from "../../utils/auth-utils.mjs";
 import * as blockletUtils from "../../utils/blocklet.mjs";
+import { DOC_OFFICIAL_ACCESS_TOKEN } from "../../utils/constants/index.mjs";
 
 // Mock external modules that involve network requests
 const mockCreateConnect = mock(() => Promise.resolve({ accessKeySecret: "new-access-token" }));
@@ -55,6 +56,7 @@ describe("auth-utils", () => {
   beforeEach(() => {
     originalEnv = { ...process.env };
     delete process.env.DOC_DISCUSS_KIT_ACCESS_TOKEN;
+    delete process.env[DOC_OFFICIAL_ACCESS_TOKEN];
 
     // Reset external mocks
     mockCreateConnect.mockClear();
@@ -355,4 +357,240 @@ describe("auth-utils", () => {
       "Failed to obtain access token. Please check your network connection and try again later.",
     );
   });
+
+  // OFFICIAL ACCESS TOKEN TESTS
+  describe("getOfficialAccessToken", () => {
+    test("should throw error for missing baseUrl parameter", async () => {
+      await expect(getOfficialAccessToken()).rejects.toThrow(
+        "baseUrl parameter is required for getOfficialAccessToken.",
+      );
+      await expect(getOfficialAccessToken("")).rejects.toThrow(
+        "baseUrl parameter is required for getOfficialAccessToken.",
+      );
+    });
+
+    test("should return access token from environment variable", async () => {
+      process.env[DOC_OFFICIAL_ACCESS_TOKEN] = "env-official-token";
+
+      const result = await getOfficialAccessToken("https://example.com");
+
+      expect(result).toBe("env-official-token");
+    });
+
+    test("should handle different URL formats", async () => {
+      process.env[DOC_OFFICIAL_ACCESS_TOKEN] = "test-official-token";
+
+      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 getOfficialAccessToken(url);
+        expect(result).toBe("test-official-token");
+      }
+    });
+
+    test("should handle invalid URL", async () => {
+      process.env[DOC_OFFICIAL_ACCESS_TOKEN] = "test-official-token";
+
+      await expect(getOfficialAccessToken("invalid-url")).rejects.toThrow();
+    });
+
+    test("should work with localhost URLs", async () => {
+      process.env[DOC_OFFICIAL_ACCESS_TOKEN] = "local-official-token";
+
+      const result = await getOfficialAccessToken("http://localhost:3000");
+
+      expect(result).toBe("local-official-token");
+    });
+
+    test("should preserve environment variable after function call", async () => {
+      process.env[DOC_OFFICIAL_ACCESS_TOKEN] = "persistent-official-token";
+
+      await getOfficialAccessToken("https://example.com");
+
+      expect(process.env[DOC_OFFICIAL_ACCESS_TOKEN]).toBe("persistent-official-token");
+    });
+
+    // CONFIG FILE READING TESTS
+    test("should read access token from config file", async () => {
+      existsSyncSpy.mockReturnValue(true);
+      readFileSpy.mockResolvedValue(`DOC_OFFICIAL_ACCESS_TOKEN: config-official-token`);
+      parseSpy.mockReturnValue({
+        "example.com": {
+          [DOC_OFFICIAL_ACCESS_TOKEN]: "config-official-token",
+        },
+      });
+
+      const result = await getOfficialAccessToken("https://example.com");
+
+      expect(result).toBe("config-official-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",
+        },
+      });
+
+      const result = await getOfficialAccessToken("https://example.com");
+      expect(result).toBe("new-access-token");
+    });
+
+    test("should handle missing hostname in config", async () => {
+      existsSyncSpy.mockReturnValue(true);
+      readFileSpy.mockResolvedValue(`${DOC_OFFICIAL_ACCESS_TOKEN}: token`);
+      parseSpy.mockReturnValue({
+        "other-domain.com": {
+          [DOC_OFFICIAL_ACCESS_TOKEN]: "other-token",
+        },
+      });
+
+      const result = await getOfficialAccessToken("https://example.com");
+      expect(result).toBe("new-access-token");
+    });
+
+    test("should handle config file read errors silently", async () => {
+      existsSyncSpy.mockReturnValue(true);
+      readFileSpy.mockRejectedValue(new Error("File read error"));
+
+      const result = await getOfficialAccessToken("https://example.com");
+      expect(result).toBe("new-access-token");
+      // Should not call console.warn for config file errors in getOfficialAccessToken
+    });
+
+    test("should handle empty config file", async () => {
+      existsSyncSpy.mockReturnValue(true);
+      readFileSpy.mockResolvedValue("");
+      parseSpy.mockReturnValue(null);
+
+      const result = await getOfficialAccessToken("https://example.com");
+      expect(result).toBe("new-access-token");
+    });
+
+    // AUTHORIZATION FLOW TESTS
+    test("should successfully complete authorization flow", async () => {
+      const result = await getOfficialAccessToken("https://example.com");
+
+      expect(result).toBe("new-access-token");
+
+      // Verify the authorization flow
+      expect(mockCreateConnect).toHaveBeenCalledWith(
+        expect.objectContaining({
+          connectAction: "gen-simple-access-key",
+          source: "AIGNE DocSmith connect to official service",
+          closeOnSuccess: true,
+          appName: "AIGNE DocSmith",
+          openPage: expect.any(Function),
+        }),
+      );
+
+      // Verify environment variable is set
+      expect(process.env[DOC_OFFICIAL_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_OFFICIAL_ACCESS_TOKEN]: "new-access-token",
+          },
+        }),
+      );
+    });
+
+    test("should create .aigne directory if it doesn't exist", async () => {
+      existsSyncSpy.mockReturnValueOnce(false); // .aigne directory doesn't exist
+
+      const result = await getOfficialAccessToken("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 () => {
+      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 getOfficialAccessToken("https://example.com");
+
+      expect(result).toBe("new-access-token");
+      expect(stringifySpy).toHaveBeenCalled();
+      expect(writeFileSpy).toHaveBeenCalled();
+    });
+
+    test("should call openPage function with correct behavior", async () => {
+      let capturedOpenPage;
+      mockCreateConnect.mockImplementation((options) => {
+        capturedOpenPage = options.openPage;
+        return Promise.resolve({ accessKeySecret: "new-access-token" });
+      });
+
+      const result = await getOfficialAccessToken("https://example.com");
+
+      expect(result).toBe("new-access-token");
+      expect(typeof capturedOpenPage).toBe("function");
+
+      // Test that openPage calls the mock open function and logs
+      const consoleSpy = spyOn(console, "log").mockImplementation(() => {});
+      await capturedOpenPage("https://auth.example.com");
+      expect(mockOpen).toHaveBeenCalledWith("https://auth.example.com");
+      expect(consoleSpy).toHaveBeenCalledWith(
+        "🔗 Please open this URL in your browser to authorize access: ",
+        expect.any(String),
+        "\n",
+      );
+      consoleSpy.mockRestore();
+    });
+
+    test("should handle authorization failure", async () => {
+      mockCreateConnect.mockRejectedValue(new Error("Authorization failed"));
+
+      await expect(getOfficialAccessToken("https://example.com")).rejects.toThrow(
+        "Failed to obtain official 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 () => {
+      mockCreateConnect.mockRejectedValue(new TypeError("Network error"));
+
+      await expect(getOfficialAccessToken("https://example.com")).rejects.toThrow(
+        "Failed to obtain official access token. Please check your network connection and try again later.",
+      );
+    });
+
+    test("should handle config file save errors gracefully", async () => {
+      writeFileSpy.mockRejectedValue(new Error("Write error"));
+      const consoleWarnSpy = spyOn(console, "warn").mockImplementation(() => {});
+
+      const result = await getOfficialAccessToken("https://example.com");
+
+      expect(result).toBe("new-access-token");
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        expect.stringContaining("Failed to save token to config file"),
+        expect.any(Error),
+      );
+      consoleWarnSpy.mockRestore();
+    });
+  });
 });

package/tests/utils/blocklet.test.mjs

@@ -1,21 +1,23 @@
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
 import {
   ComponentNotFoundError,
   getComponentMountPoint,
   InvalidBlockletError,
 } from "../../utils/blocklet.mjs";
 
-// Mock global fetch
-const mockFetch = mock();
-global.fetch = mockFetch;
-
 describe("blocklet", () => {
+  let mockFetch;
   beforeEach(() => {
-    mockFetch.mockClear();
+    // Mock global fetch
+    mockFetch = spyOn(global, "fetch").mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve({ name: "test-repo", description: "Test repo" }),
+      statusText: "OK",
+    });
   });
 
   afterEach(() => {
-    mockFetch.mockRestore?.();
+    mockFetch?.mockRestore();
   });
 
   // ERROR CLASSES TESTS

package/tests/utils/constants.test.mjs

@@ -20,7 +20,7 @@ import {
   TMP_ASSETS_DIR,
   TMP_DIR,
   TMP_DOCS_DIR,
-} from "../../utils/constants.mjs";
+} from "../../utils/constants/index.mjs";
 
 describe("constants", () => {
   describe("DEFAULT_INCLUDE_PATTERNS", () => {

package/tests/utils/d2-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/index.mjs";
 import {
   beforePublishHook,
   checkContent,