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

package/tests/utils/deploy.test.mjs

@@ -1,25 +1,44 @@
 import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from "bun:test";
 import * as openModule from "open";
-import * as blockletModule from "../../utils/blocklet.mjs";
+import * as authUtilsModule from "../../utils/auth-utils.mjs";
 
-// Import the real utils module and deploy function
+// Import the deploy function
 import { deploy } from "../../utils/deploy.mjs";
-import * as utils from "../../utils/utils.mjs";
+import * as utilsModule from "../../utils/utils.mjs";
+
+const TEST_HOME_URL = "https_home_test_url";
+const TEST_APP_URL = "https_app_test_url";
+const TEST_DASHBOARD_URL = "https_dashboard_test_url";
+const TEST_SUBSCRIPTION_URL = "https_subscription_test_url";
+
+// Mock BrokerClient
+const mockBrokerClient = {
+  deploy: mock(),
+};
+
+const mockBrokerClientConstructor = mock(() => mockBrokerClient);
+
+// Mock the payment broker client module
+mock.module("@blocklet/payment-broker-client/node", () => ({
+  BrokerClient: mockBrokerClientConstructor,
+  STEPS: {
+    PAYMENT_PENDING: "PAYMENT_PENDING",
+    INSTALLATION_STARTING: "INSTALLATION_STARTING",
+    SERVICE_STARTING: "SERVICE_STARTING",
+    ACCESS_PREPARING: "ACCESS_PREPARING",
+    ACCESS_READY: "ACCESS_READY",
+  },
+}));
 
 describe("deploy", () => {
-  let originalFetch;
   let originalConsole;
   let consoleOutput;
+  let getOfficialAccessTokenSpy;
   let saveValueToConfigSpy;
-  let originalSetTimeout;
-  let getComponentInfoWithMountPointSpy;
-  let getComponentInfoSpy;
   let openDefaultSpy;
 
-  beforeEach(async () => {
-    // Reset environment
-    process.env.DOC_SMITH_BASE_URL = "https://test.example.com";
-    process.env.NODE_ENV = "test";
+  beforeEach(() => {
+    // Note: DOC_SMITH_BASE_URL is not set, so BASE_URL will be empty string
 
     // Mock console to capture output
     consoleOutput = [];
@@ -30,433 +49,358 @@ describe("deploy", () => {
     console.log = (...args) => consoleOutput.push({ type: "log", args });
     console.error = (...args) => consoleOutput.push({ type: "error", args });
 
-    // Mock setTimeout to make tests run instantly
-    originalSetTimeout = global.setTimeout;
-    global.setTimeout = (callback, _delay) => {
-      // Call immediately in tests
-      return originalSetTimeout(callback, 0);
-    };
-
-    // Mock fetch
-    originalFetch = global.fetch;
-
-    // Use spyOn to mock saveValueToConfig without affecting other tests
-    saveValueToConfigSpy = spyOn(utils, "saveValueToConfig").mockResolvedValue();
-
-    // Spy on blocklet module functions
-    getComponentInfoWithMountPointSpy = spyOn(
-      blockletModule,
-      "getComponentInfoWithMountPoint",
-    ).mockResolvedValue({
-      mountPoint: "/payment",
-      PAYMENT_LINK_ID: "test-payment-id",
-    });
-
-    getComponentInfoSpy = spyOn(blockletModule, "getComponentInfo").mockResolvedValue({
-      status: "running",
-    });
-
-    // Spy on open module
+    // Mock dependencies
+    getOfficialAccessTokenSpy = spyOn(authUtilsModule, "getOfficialAccessToken").mockResolvedValue(
+      "mock-auth-token",
+    );
+    saveValueToConfigSpy = spyOn(utilsModule, "saveValueToConfig").mockResolvedValue();
     openDefaultSpy = spyOn(openModule, "default").mockResolvedValue();
+
+    // Reset mocks
+    mockBrokerClientConstructor.mockClear();
+    mockBrokerClient.deploy.mockClear();
   });
 
   afterEach(() => {
-    // Restore originals
-    global.fetch = originalFetch;
-    global.setTimeout = originalSetTimeout;
+    // Restore console
     console.log = originalConsole.log;
     console.error = originalConsole.error;
 
     // Restore all spies
+    getOfficialAccessTokenSpy?.mockRestore();
     saveValueToConfigSpy?.mockRestore();
-    getComponentInfoWithMountPointSpy?.mockRestore();
-    getComponentInfoSpy?.mockRestore();
     openDefaultSpy?.mockRestore();
 
-    // Reset environment
+    // Clean up environment
     delete process.env.NODE_ENV;
   });
 
   test("successful deployment flow", async () => {
-    // Mock API responses for the complete flow
-    let callCount = 0;
-    global.fetch = mock(async (url) => {
-      callCount++;
-
-      // Step 1: Create payment session
-      if (url.includes("/api/checkout-sessions/start")) {
-        return {
-          ok: true,
-          status: 200,
-          json: async () => ({
-            checkoutSession: { id: "checkout-123" },
-            paymentUrl: "https://payment.test/checkout-123",
-          }),
-        };
-      }
-
-      // Step 2-4: Poll payment/installation/service status
-      if (url.includes("/api/vendors/order/checkout-123/status")) {
-        if (callCount <= 2) {
-          // First call: payment completed, installation in progress
-          return {
-            ok: true,
-            status: 200,
-            json: async () => ({
-              payment_status: "paid",
-              vendors: [{ id: "vendor-1", progress: 50, appUrl: null }],
-            }),
-          };
-        } else {
-          // Subsequent calls: installation complete
-          return {
-            ok: true,
-            status: 200,
-            json: async () => ({
-              payment_status: "paid",
-              vendors: [{ id: "vendor-1", progress: 100, appUrl: "https://app.test" }],
-            }),
-          };
-        }
-      }
-
-      // Step 5: Get order details
-      if (url.includes("/api/vendors/order/checkout-123/detail")) {
-        return {
-          ok: true,
-          status: 200,
-          json: async () => ({
-            vendors: [
-              {
-                appUrl: "https://app.test",
-                dashboardUrl: "https://dashboard.test",
-                homeUrl: "https://home.test",
-                token: "auth-token-123",
-              },
-            ],
-          }),
-        };
-      }
+    // Mock successful deployment result
+    const mockResult = {
+      appUrl: TEST_APP_URL,
+      homeUrl: TEST_HOME_URL,
+      dashboardUrl: TEST_DASHBOARD_URL,
+      subscriptionUrl: TEST_SUBSCRIPTION_URL,
+      vendors: [{ token: "auth-token-123" }],
+    };
 
-      throw new Error(`Unexpected URL: ${url}`);
-    });
+    mockBrokerClient.deploy.mockResolvedValue(mockResult);
 
     const result = await deploy();
 
-    // Verify result
+    // Verify BrokerClient was constructed with correct config
+    expect(mockBrokerClientConstructor).toHaveBeenCalledWith({
+      baseUrl: "",
+      authToken: "mock-auth-token",
+      paymentLinkKey: "PAYMENT_LINK_ID",
+      timeout: 300000,
+      polling: {
+        interval: 3000,
+        maxAttempts: 100,
+        backoffStrategy: "linear",
+      },
+    });
+
+    // Verify deploy was called with correct parameters
+    expect(mockBrokerClient.deploy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        cachedCheckoutId: undefined,
+        cachedPaymentUrl: undefined,
+        pageInfo: expect.objectContaining({
+          successMessage: expect.objectContaining({
+            en: expect.stringContaining("Congratulations"),
+            zh: expect.stringContaining("恭喜您"),
+          }),
+        }),
+        hooks: expect.objectContaining({
+          PAYMENT_PENDING: expect.any(Function),
+          INSTALLATION_STARTING: expect.any(Function),
+          SERVICE_STARTING: expect.any(Function),
+          ACCESS_PREPARING: expect.any(Function),
+          ACCESS_READY: expect.any(Function),
+        }),
+        onError: expect.any(Function),
+      }),
+    );
+
+    // Verify result transformation
     expect(result).toEqual({
-      appUrl: "https://app.test",
-      homeUrl: "https://home.test",
+      appUrl: TEST_APP_URL,
+      homeUrl: TEST_HOME_URL,
+      dashboardUrl: TEST_DASHBOARD_URL,
+      subscriptionUrl: TEST_SUBSCRIPTION_URL,
       token: "auth-token-123",
     });
 
-    // Verify saveValueToConfig was called
-    expect(saveValueToConfigSpy).toHaveBeenCalledWith(
-      "checkoutId",
-      "checkout-123",
-      "Checkout ID for document deployment website",
-    );
-    expect(saveValueToConfigSpy).toHaveBeenCalledWith(
-      "paymentUrl",
-      expect.stringContaining("payment"),
-      "Payment URL for document deployment website",
+    // Verify console output
+    const logs = consoleOutput.filter((o) => o.type === "log").map((o) => o.args.join(" "));
+    expect(logs.some((log) => log.includes("🚀 Starting deployment..."))).toBe(true);
+  });
+
+  test("successful deployment with cached parameters", async () => {
+    const mockResult = {
+      appUrl: TEST_APP_URL,
+      homeUrl: TEST_HOME_URL,
+      vendors: [{ token: "auth-token-123" }],
+    };
+
+    mockBrokerClient.deploy.mockResolvedValue(mockResult);
+
+    const result = await deploy("cached-checkout-id", "https://cached-payment.url");
+
+    // Verify deploy was called with cached parameters
+    expect(mockBrokerClient.deploy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        cachedCheckoutId: "cached-checkout-id",
+        cachedPaymentUrl: "https://cached-payment.url",
+      }),
     );
 
-    // Verify console output shows progress
-    const logs = consoleOutput.filter((o) => o.type === "log").map((o) => o.args.join(" "));
-    expect(logs.some((log) => log.includes("Step 1/4: Waiting for payment"))).toBe(true);
-    expect(logs.some((log) => log.includes("Step 2/4: Installing Website"))).toBe(true);
-    expect(logs.some((log) => log.includes("Step 3/4: Starting Website"))).toBe(true);
-    expect(logs.some((log) => log.includes("Step 4/4: Getting Website URL"))).toBe(true);
-    expect(logs.some((log) => log.includes("Your website is available at"))).toBe(true);
+    expect(result.appUrl).toBe(TEST_APP_URL);
+    expect(result.token).toBe("auth-token-123");
   });
 
-  test("successful deployment flow with subscription", async () => {
-    // Mock API responses for the complete flow
-    let callCount = 0;
-    global.fetch = mock(async (url) => {
-      callCount++;
-
-      // Step 1: Create payment session
-      if (url.includes("/api/checkout-sessions/start")) {
-        return {
-          ok: true,
-          status: 200,
-          json: async () => ({
-            checkoutSession: { id: "checkout-123" },
-            paymentUrl: "https://payment.test/checkout-123",
-          }),
-        };
-      }
-
-      // Step 2-4: Poll payment/installation/service status
-      if (url.includes("/api/vendors/order/checkout-123/status")) {
-        if (callCount <= 2) {
-          // First call: payment completed, installation in progress
-          return {
-            ok: true,
-            status: 200,
-            json: async () => ({
-              payment_status: "paid",
-              vendors: [{ id: "vendor-1", progress: 50, appUrl: null }],
-            }),
-          };
-        } else {
-          // Subsequent calls: installation complete
-          return {
-            ok: true,
-            status: 200,
-            json: async () => ({
-              payment_status: "paid",
-              vendors: [{ id: "vendor-1", progress: 100, appUrl: "https://app.test" }],
-            }),
-          };
-        }
-      }
-
-      // Step 5: Get order details
-      if (url.includes("/api/vendors/order/checkout-123/detail")) {
-        return {
-          ok: true,
-          status: 200,
-          json: async () => ({
-            vendors: [
-              {
-                appUrl: "https://app.test",
-                dashboardUrl: "https://dashboard.test",
-                homeUrl: "https://home.test",
-                token: "auth-token-123",
-              },
-            ],
-            subscriptionUrl: "https://subscription.test",
-          }),
-        };
-      }
+  test("handles missing auth token", async () => {
+    getOfficialAccessTokenSpy.mockResolvedValue(null);
+
+    await expect(deploy()).rejects.toThrow("Failed to get official access token");
 
-      throw new Error(`Unexpected URL: ${url}`);
+    // Verify BrokerClient was not created
+    expect(mockBrokerClientConstructor).not.toHaveBeenCalled();
+  });
+
+  test("handles BrokerClient deployment failure", async () => {
+    const deployError = new Error("Deployment failed");
+    mockBrokerClient.deploy.mockRejectedValue(deployError);
+
+    await expect(deploy()).rejects.toThrow("Deployment failed");
+
+    // Verify BrokerClient was created and deploy was called
+    expect(mockBrokerClientConstructor).toHaveBeenCalled();
+    expect(mockBrokerClient.deploy).toHaveBeenCalled();
+  });
+
+  test("PAYMENT_PENDING hook functionality", async () => {
+    let paymentPendingHook;
+
+    mockBrokerClient.deploy.mockImplementation(async (config) => {
+      paymentPendingHook = config.hooks.PAYMENT_PENDING;
+      return {
+        appUrl: TEST_APP_URL,
+        vendors: [{ token: "test-token" }],
+      };
     });
 
-    const result = await deploy();
+    await deploy();
 
-    // Verify result
-    expect(result).toEqual({
-      appUrl: "https://app.test",
-      homeUrl: "https://home.test",
-      token: "auth-token-123",
+    // Test the PAYMENT_PENDING hook
+    await paymentPendingHook({
+      sessionId: "session-123",
+      paymentUrl: "https://payment.test/session-123",
+      isResuming: false,
     });
 
     // Verify saveValueToConfig was called
     expect(saveValueToConfigSpy).toHaveBeenCalledWith(
       "checkoutId",
-      "checkout-123",
+      "session-123",
       "Checkout ID for document deployment website",
     );
     expect(saveValueToConfigSpy).toHaveBeenCalledWith(
       "paymentUrl",
-      expect.stringContaining("payment"),
+      "https://payment.test/session-123",
       "Payment URL for document deployment website",
     );
 
-    // Verify console output shows progress
-    const logs = consoleOutput.filter((o) => o.type === "log").map((o) => o.args.join(" "));
+    // Verify browser was opened
+    expect(openDefaultSpy).toHaveBeenCalledWith("https://payment.test/session-123");
 
-    expect(logs.some((log) => log.includes("Step 1/4: Waiting for payment"))).toBe(true);
-    expect(logs.some((log) => log.includes("Step 2/4: Installing Website"))).toBe(true);
-    expect(logs.some((log) => log.includes("Step 3/4: Starting Website"))).toBe(true);
-    expect(logs.some((log) => log.includes("Step 4/4: Getting Website URL"))).toBe(true);
-    expect(logs.some((log) => log.includes("Your website is available at"))).toBe(true);
-    expect(logs.some((log) => log.includes("Your subscription management URL"))).toBe(true);
+    // Verify console output
+    const logs = consoleOutput.filter((o) => o.type === "log").map((o) => o.args.join(" "));
+    expect(logs.some((log) => log.includes("⏳ Step 1/4: Waiting for payment..."))).toBe(true);
+    expect(logs.some((log) => log.includes("🔗 Payment link:"))).toBe(true);
   });
 
-  test("handles missing payment link ID", async () => {
-    getComponentInfoWithMountPointSpy.mockResolvedValue({
-      mountPoint: "/payment",
-      PAYMENT_LINK_ID: null,
+  test("PAYMENT_PENDING hook with isResuming=true", async () => {
+    let paymentPendingHook;
+
+    mockBrokerClient.deploy.mockImplementation(async (config) => {
+      paymentPendingHook = config.hooks.PAYMENT_PENDING;
+      return {
+        appUrl: TEST_APP_URL,
+        vendors: [{ token: "test-token" }],
+      };
     });
 
-    await expect(deploy()).rejects.toThrow("Payment link ID not found");
-  });
+    await deploy();
 
-  test("handles payment session creation failure", async () => {
-    global.fetch = mock(async (url) => {
-      if (url.includes("/api/checkout-sessions/start")) {
-        return {
-          ok: false,
-          status: 400,
-          json: async () => ({ error: "Payment creation failed" }),
-        };
-      }
+    // Test the PAYMENT_PENDING hook with isResuming=true
+    await paymentPendingHook({
+      sessionId: "session-123",
+      paymentUrl: "https://payment.test/session-123",
+      isResuming: true,
     });
 
-    await expect(deploy()).rejects.toThrow("Failed to create payment session");
+    // Verify browser was NOT opened when resuming
+    expect(openDefaultSpy).not.toHaveBeenCalled();
 
-    const errors = consoleOutput.filter((o) => o.type === "error");
-    expect(errors.length).toBeGreaterThan(0);
+    // But saveValueToConfig should still be called
+    expect(saveValueToConfigSpy).toHaveBeenCalledWith(
+      "checkoutId",
+      "session-123",
+      "Checkout ID for document deployment website",
+    );
   });
 
-  test("handles network errors gracefully", async () => {
-    global.fetch = mock(async () => {
-      throw new Error("Network connection failed");
+  test("other hooks functionality", async () => {
+    let hooks;
+
+    mockBrokerClient.deploy.mockImplementation(async (config) => {
+      hooks = config.hooks;
+      return {
+        appUrl: TEST_APP_URL,
+        vendors: [{ token: "test-token" }],
+      };
     });
 
-    await expect(deploy()).rejects.toThrow("Failed to create payment session");
-  });
+    await deploy();
 
-  test("handles browser opening failure gracefully", async () => {
-    // Mock successful API flow
-    global.fetch = mock(async (url) => {
-      if (url.includes("/api/checkout-sessions/start")) {
-        return {
-          ok: true,
-          status: 200,
-          json: async () => ({
-            checkoutSession: { id: "checkout-123" },
-            paymentUrl: "https://payment.test/checkout-123",
-          }),
-        };
-      }
-
-      if (url.includes("/status")) {
-        return {
-          ok: true,
-          status: 200,
-          json: async () => ({
-            payment_status: "paid",
-            vendors: [{ id: "vendor-1", progress: 100, appUrl: "https://app.test" }],
-          }),
-        };
-      }
-
-      if (url.includes("/detail")) {
-        return {
-          ok: true,
-          status: 200,
-          json: async () => ({
-            vendors: [
-              {
-                appUrl: "https://app.test",
-                homeUrl: "https://home.test",
-                token: "auth-token-123",
-              },
-            ],
-          }),
-        };
-      }
+    // Test INSTALLATION_STARTING hook
+    hooks.INSTALLATION_STARTING();
+    let logs = consoleOutput.filter((o) => o.type === "log").map((o) => o.args.join(" "));
+    expect(logs.some((log) => log.includes("📦 Step 2/4: Installing Website..."))).toBe(true);
+
+    // Test SERVICE_STARTING hook
+    hooks.SERVICE_STARTING();
+    logs = consoleOutput.filter((o) => o.type === "log").map((o) => o.args.join(" "));
+    expect(logs.some((log) => log.includes("🚀 Step 3/4: Starting Website..."))).toBe(true);
+
+    // Test ACCESS_PREPARING hook
+    hooks.ACCESS_PREPARING();
+    logs = consoleOutput.filter((o) => o.type === "log").map((o) => o.args.join(" "));
+    expect(logs.some((log) => log.includes("🌐 Step 4/4: Getting Website URL..."))).toBe(true);
+
+    // Test ACCESS_READY hook without subscription
+    await hooks.ACCESS_READY({
+      appUrl: TEST_APP_URL,
+      homeUrl: TEST_HOME_URL,
+    });
+    logs = consoleOutput.filter((o) => o.type === "log").map((o) => o.args.join(" "));
+    expect(logs.some((log) => log.includes("🔗 Your website is available at:"))).toBe(true);
+    expect(logs.some((log) => log.includes(TEST_HOME_URL))).toBe(true);
+
+    // Test ACCESS_READY hook with subscription
+    await hooks.ACCESS_READY({
+      appUrl: TEST_APP_URL,
+      homeUrl: TEST_HOME_URL,
+      subscriptionUrl: TEST_SUBSCRIPTION_URL,
     });
+    logs = consoleOutput.filter((o) => o.type === "log").map((o) => o.args.join(" "));
+    expect(logs.some((log) => log.includes("🔗 Your subscription management URL:"))).toBe(true);
+    expect(logs.some((log) => log.includes(TEST_SUBSCRIPTION_URL))).toBe(true);
+  });
 
-    // Mock open to fail
-    openDefaultSpy.mockRejectedValue(new Error("Cannot open browser"));
+  test("handles missing vendors in result", async () => {
+    const mockResult = {
+      appUrl: TEST_APP_URL,
+      homeUrl: TEST_HOME_URL,
+      vendors: null,
+    };
+
+    mockBrokerClient.deploy.mockResolvedValue(mockResult);
 
-    // Call deploy without cached parameters - should still succeed
     const result = await deploy();
 
-    // Should still complete successfully despite browser opening failure
-    expect(result.appUrl).toBe("https://app.test");
-    expect(result.homeUrl).toBe("https://home.test");
-    expect(result.token).toBe("auth-token-123");
+    expect(result.token).toBeUndefined();
+    expect(result.appUrl).toBe(TEST_APP_URL);
+    expect(result.homeUrl).toBe(TEST_HOME_URL);
   });
 
-  test("handles cached checkout ID", async () => {
-    // Mock successful status check for cached ID
-    global.fetch = mock(async (url) => {
-      if (url.includes("/status")) {
-        return {
-          ok: true,
-          status: 200,
-          json: async () => ({
-            payment_status: "paid",
-            vendors: [{ id: "vendor-1", progress: 100, appUrl: "https://app.test" }],
-          }),
-        };
-      }
-
-      if (url.includes("/detail")) {
-        return {
-          ok: true,
-          status: 200,
-          json: async () => ({
-            vendors: [
-              {
-                appUrl: "https://app.test",
-                homeUrl: "https://home.test",
-                token: "auth-token-123",
-              },
-            ],
-          }),
-        };
-      }
-    });
+  test("handles empty vendors array in result", async () => {
+    const mockResult = {
+      appUrl: TEST_APP_URL,
+      homeUrl: TEST_HOME_URL,
+      vendors: [],
+    };
 
-    const result = await deploy("existing-checkout-id", "https://cached-payment.url");
+    mockBrokerClient.deploy.mockResolvedValue(mockResult);
 
-    expect(result.appUrl).toBe("https://app.test");
+    const result = await deploy();
 
-    // Should not call open since using cached checkout
-    expect(openDefaultSpy).not.toHaveBeenCalled();
+    expect(result.token).toBeUndefined();
+    expect(result.appUrl).toBe(TEST_APP_URL);
+    expect(result.homeUrl).toBe(TEST_HOME_URL);
   });
 
-  test("clears checkout ID when cache check fails", async () => {
-    // Mock successful responses for the complete flow after cache check fails
-    let callCount = 0;
-    global.fetch = mock(async (url) => {
-      callCount++;
-
-      // First call: cache check fails
-      if (callCount === 1 && url.includes("/status")) {
-        throw new Error("Network error during cache check");
-      }
-
-      // Create payment session
-      if (url.includes("/api/checkout-sessions/start")) {
-        return {
-          ok: true,
-          status: 200,
-          json: async () => ({
-            checkoutSession: { id: "new-checkout-123" },
-            paymentUrl: "https://payment.test/new-checkout-123",
-          }),
-        };
-      }
-
-      // Subsequent status checks and detail calls
-      if (url.includes("/status")) {
-        return {
-          ok: true,
-          status: 200,
-          json: async () => ({
-            payment_status: "paid",
-            vendors: [{ id: "vendor-1", progress: 100, appUrl: "https://app.test" }],
-          }),
-        };
-      }
-
-      if (url.includes("/detail")) {
-        return {
-          ok: true,
-          status: 200,
-          json: async () => ({
-            vendors: [
-              {
-                appUrl: "https://app.test",
-                homeUrl: "https://home.test",
-                token: "auth-token-123",
-              },
-            ],
-          }),
-        };
-      }
-    });
+  test("uses default BASE_URL when not set", async () => {
+    delete process.env.DOC_SMITH_BASE_URL;
 
-    // Call deploy with invalid cached checkout ID - should clear it and create new one
-    const result = await deploy("invalid-checkout-id");
+    const mockResult = {
+      appUrl: TEST_APP_URL,
+      vendors: [{ token: "test-token" }],
+    };
 
-    expect(result.appUrl).toBe("https://app.test");
+    mockBrokerClient.deploy.mockResolvedValue(mockResult);
 
-    // Verify that checkoutId was cleared due to cache check failure
-    expect(saveValueToConfigSpy).toHaveBeenCalledWith(
-      "checkoutId",
-      "",
-      "Checkout ID for document deployment website",
+    await deploy();
+
+    // Verify BrokerClient was constructed with empty baseUrl
+    expect(mockBrokerClientConstructor).toHaveBeenCalledWith(
+      expect.objectContaining({
+        baseUrl: "",
+      }),
     );
   });
+
+  test("handles browser opening failure", async () => {
+    openDefaultSpy.mockRejectedValue(new Error("Cannot open browser"));
+
+    let paymentPendingHook;
+    mockBrokerClient.deploy.mockImplementation(async (config) => {
+      paymentPendingHook = config.hooks.PAYMENT_PENDING;
+      return {
+        appUrl: TEST_APP_URL,
+        vendors: [{ token: "test-token" }],
+      };
+    });
+
+    await deploy();
+
+    // The hook should throw when browser opening fails (expected behavior)
+    await expect(
+      paymentPendingHook({
+        sessionId: "session-123",
+        paymentUrl: "https://payment.test/session-123",
+        isResuming: false,
+      }),
+    ).rejects.toThrow("Cannot open browser");
+
+    // Config should still be saved
+    expect(saveValueToConfigSpy).toHaveBeenCalled();
+  });
+
+  test("handles saveValueToConfig failure", async () => {
+    saveValueToConfigSpy.mockRejectedValue(new Error("Config save failed"));
+
+    let paymentPendingHook;
+    mockBrokerClient.deploy.mockImplementation(async (config) => {
+      paymentPendingHook = config.hooks.PAYMENT_PENDING;
+      return {
+        appUrl: TEST_APP_URL,
+        vendors: [{ token: "test-token" }],
+      };
+    });
+
+    await deploy();
+
+    // The hook should throw when config saving fails (expected behavior)
+    await expect(
+      paymentPendingHook({
+        sessionId: "session-123",
+        paymentUrl: "https://payment.test/session-123",
+        isResuming: false,
+      }),
+    ).rejects.toThrow("Config save failed");
+  });
 });