quickbase-js 0.1.0-beta.10 → 0.1.0-beta.12

package/tests/playwright/qb/auth/getAppWithTempTokenConcurrency.test.ts

@@ -0,0 +1,208 @@
+// tests/playwright/qb/auth/getAppWithTempTokenConcurrency.test.ts
+import { test, expect } from "@playwright/test";
+import { quickbase } from "../../../../src/quickbaseClient.ts"; // Keep .ts for now
+import dotenv from "dotenv";
+
+dotenv.config();
+
+const loginToQuickbase = async (
+  page: import("@playwright/test").Page,
+  quickbaseUrl: string,
+  username: string,
+  password: string
+): Promise<boolean> => {
+  let loginSuccess = false;
+  const maxLoginAttempts = 3;
+  let loginAttempt = 0;
+
+  while (!loginSuccess && loginAttempt < maxLoginAttempts) {
+    try {
+      loginAttempt++;
+      if (loginAttempt > 1) console.log(`Login attempt ${loginAttempt}`);
+
+      await page.goto(quickbaseUrl, { timeout: 60000 });
+      await page.waitForSelector("input[name='loginid']", { timeout: 60000 });
+      await page.fill("input[name='loginid']", username);
+      await page.fill("input[name='password']", password);
+      await page.click("#signin");
+      await page.waitForURL(`https://*.quickbase.com/**`, {
+        waitUntil: "networkidle",
+        timeout: 60000,
+      });
+
+      const loginError = await page.$(".login-error");
+      if (loginError) {
+        throw new Error("Login failed. Please check your credentials.");
+      }
+
+      console.log("Signed In to QuickBase.");
+      loginSuccess = true;
+    } catch (error) {
+      console.error(
+        `Login attempt ${loginAttempt} failed: ${(error as Error).message}`
+      );
+      if (loginAttempt >= maxLoginAttempts) {
+        console.error("Max login attempts reached. Exiting.");
+        await page.context().browser()!.close();
+        return false;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 5000));
+    }
+  }
+  return loginSuccess;
+};
+
+test.describe("QuickbaseClient Integration - getApp with Temporary Token Concurrency", () => {
+  test("handles concurrent getApp requests with a single token fetch", async ({
+    page,
+  }) => {
+    const realm = process.env.QB_REALM;
+    const appId = process.env.QB_APP_ID;
+    const username = process.env.QB_USERNAME;
+    const password = process.env.QB_PASSWORD;
+
+    if (!realm) throw new Error("QB_REALM is not defined in .env");
+    if (!appId) throw new Error("QB_APP_ID is not defined in .env");
+    if (!username) throw new Error("QB_USERNAME is not defined in .env");
+    if (!password) throw new Error("QB_PASSWORD is not defined in .env");
+
+    const fetchInits: { url: string; init: RequestInit }[] = [];
+
+    const quickbaseUrl = `https://${realm}.quickbase.com/db/main?a=SignIn`;
+    const loginSuccess = await loginToQuickbase(
+      page,
+      quickbaseUrl,
+      username,
+      password
+    );
+    if (!loginSuccess) {
+      throw new Error("Failed to log in to QuickBase after max attempts.");
+    }
+
+    await page.goto(`https://${realm}.quickbase.com/db/${appId}`, {
+      waitUntil: "networkidle",
+      timeout: 60000,
+    });
+
+    const client = quickbase({
+      realm,
+      useTempTokens: true,
+      debug: true, // Enable debug logs to verify concurrency behavior
+      fetchApi: async (url: RequestInfo | URL, init?: RequestInit) => {
+        const effectiveInit = init || {};
+        fetchInits.push({ url: String(url), init: effectiveInit });
+        const response = await page.evaluate(
+          async (args: [string, RequestInit]) => {
+            const [fetchUrl, fetchInit] = args;
+            const res = await fetch(fetchUrl, fetchInit);
+            const body = await res.text();
+            const headersObj: Record<string, string> = {};
+            res.headers.forEach((value, key) => {
+              headersObj[key] = value;
+            });
+            return {
+              ok: res.ok,
+              status: res.status,
+              statusText: res.statusText,
+              headers: headersObj,
+              body,
+            };
+          },
+          [String(url), effectiveInit] as [string, RequestInit]
+        );
+
+        const fetchResponse = new Response(response.body || null, {
+          status: response.status,
+          statusText: response.statusText,
+          headers: new Headers(response.headers),
+        });
+
+        fetchResponse.json = async () => {
+          if (!response.body) {
+            throw new Error("Empty response body from API");
+          }
+          try {
+            return JSON.parse(response.body);
+          } catch (e) {
+            throw new SyntaxError(`Invalid JSON response: ${response.body}`);
+          }
+        };
+
+        return fetchResponse;
+      },
+    });
+
+    // Make three concurrent getApp requests
+    const concurrentRequests = [
+      client.getApp({ appId }),
+      client.getApp({ appId }),
+      client.getApp({ appId }),
+    ];
+
+    // Wait for all responses to complete
+    await Promise.all([
+      page.waitForResponse(`https://api.quickbase.com/v1/apps/${appId}`, {
+        timeout: 30000,
+      }),
+      page.waitForResponse(`https://api.quickbase.com/v1/apps/${appId}`, {
+        timeout: 30000,
+      }),
+      page.waitForResponse(`https://api.quickbase.com/v1/apps/${appId}`, {
+        timeout: 30000,
+      }),
+    ]);
+
+    const results = await Promise.all(concurrentRequests);
+
+    // Expected app data (based on your previous test)
+    const expectedAppData = {
+      id: appId,
+      name: "qb-copy",
+      created: expect.any(Date),
+      updated: expect.any(Date),
+      description: "",
+      timeZone: "(UTC-08:00) Pacific Time (US & Canada)",
+      dateFormat: "MM-DD-YYYY",
+      hasEveryoneOnTheInternet: false,
+      memoryInfo: { estMemory: 0, estMemoryInclDependentApps: 0 },
+      securityProperties: {
+        allowClone: false,
+        allowExport: true,
+        enableAppTokens: true,
+        hideFromPublic: false,
+        mustBeRealmApproved: false,
+        useIPFilter: false,
+      },
+      ancestorId: undefined,
+      dataClassification: undefined,
+      variables: [{ name: "TestVar", value: "TestValue" }],
+    };
+
+    // Assert all results match the expected data
+    expect(results).toHaveLength(3);
+    results.forEach((result) => {
+      expect(result).toEqual(expectedAppData);
+    });
+
+    // Verify token fetch behavior
+    const tokenFetchInits = fetchInits.filter((entry) =>
+      entry.url.includes(`/auth/temporary/${appId}`)
+    );
+    expect(tokenFetchInits).toHaveLength(1); // Only one token fetch should occur
+    expect(tokenFetchInits[0].init.credentials).toBe("include");
+
+    const appFetchInits = fetchInits.filter((entry) =>
+      entry.url.includes(`/apps/${appId}`)
+    );
+    expect(appFetchInits).toHaveLength(3); // Three getApp requests
+    appFetchInits.forEach((init) => {
+      expect(init.init.credentials).toBe("omit");
+      expect(init.init.headers).toHaveProperty("Authorization");
+      expect(
+        (init.init.headers as Record<string, string>)["Authorization"]
+      ).toMatch(/^QB-TEMP-TOKEN .+$/);
+    });
+
+    console.log("Test completed. Check debug logs for concurrency details.");
+  });
+});

package/tests/vitest/qb/ThrottleBucket.test.ts

@@ -0,0 +1,77 @@
+// tests/vitest/qb/ThrottleBucket.test.ts
+import { describe, it, expect } from "vitest";
+import { quickbase } from "../../../src/quickbaseClient";
+
+describe("QuickbaseClient with ConcurrentThrottleBucket Integration Tests", () => {
+  it("handles concurrent API calls with burst and rate limiting in strict order", async () => {
+    const mockFetch = async (
+      url: string,
+      options: RequestInit
+    ): Promise<Response> => {
+      await new Promise((resolve) => setTimeout(resolve, 500));
+      return new Response(JSON.stringify({ id: "mock-app" }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    };
+
+    const qbClient = quickbase({
+      realm: "test",
+      userToken: "mock-token",
+      throttle: { rate: 5, burst: 3 },
+      fetchApi: mockFetch,
+      debug: true,
+    });
+
+    const throttleTimes: number[] = [];
+    const startTimes: number[] = new Array(6).fill(0);
+    const completionTimes: number[] = [];
+    const recordTime = async (index: number) => {
+      const preThrottle = Date.now();
+      throttleTimes[index] = preThrottle;
+      await qbClient.getApp({
+        appId: "mock-app-id",
+        startTime: startTimes[index],
+      });
+      completionTimes[index] = Date.now();
+      startTimes[index] = startTimes[index] || Date.now() - 500;
+    };
+
+    const startTime = Date.now();
+    const promises = [];
+    for (let i = 0; i < 6; i++) {
+      promises.push(recordTime(i));
+      await new Promise((resolve) => setTimeout(resolve, 1));
+    }
+    await Promise.all(promises);
+
+    const relativeThrottleTimes = throttleTimes.map((t) => t - startTime);
+    const relativeStartTimes = startTimes.map((t) => t - startTime);
+    const durations = completionTimes.map((t) => t - startTime);
+    const timings = completionTimes.map((t, i) => t - startTimes[i]);
+
+    console.log("Relative Throttle Times:", relativeThrottleTimes);
+    console.log("Relative Start Times (post-throttle):", relativeStartTimes);
+    console.log("Durations (completion times):", durations);
+    console.log("Timings (fetch durations):", timings);
+    console.log("Total Duration:", Date.now() - startTime);
+
+    const totalDuration = Date.now() - startTime;
+    expect(totalDuration).toBeGreaterThanOrEqual(1000);
+    expect(totalDuration).toBeLessThan(1200); // Adjusted back to ~1100ms
+
+    expect(durations.length).toBe(6);
+    expect(durations.slice(0, 3).every((d) => d >= 500 && d < 550)).toBe(true);
+
+    // Sort durations to handle out-of-order completion
+    const sortedDurations = [...durations].sort((a, b) => a - b);
+    expect(sortedDurations[3]).toBeGreaterThanOrEqual(650);
+    expect(sortedDurations[3]).toBeLessThan(750);
+    expect(sortedDurations[4]).toBeGreaterThanOrEqual(850);
+    expect(sortedDurations[4]).toBeLessThan(950);
+    expect(sortedDurations[5]).toBeGreaterThanOrEqual(1050);
+    expect(sortedDurations[5]).toBeLessThan(1150);
+
+    expect(timings.every((t) => t >= 500 && t < 550)).toBe(true);
+  });
+});

package/tests/vitest/qb/auth/ssoTokenConcurrency.test.ts

@@ -0,0 +1,68 @@
+// tests/vitest/qb/auth/ssoTokenConcurrency.test.ts
+import { test, expect, vi } from "vitest";
+import { quickbase } from "../../../../src/quickbaseClient";
+import { startMockQuickbaseServer } from "./mockQuickbaseServer";
+import { QB_APP_ID, QB_REALM } from "@tests/setup.ts";
+
+test(
+  "QuickbaseClient Integration - getApp with SsoTokenStrategy Concurrency",
+  async () => {
+    const mockServer = startMockQuickbaseServer(3000);
+
+    // Spy on console.log before any actions
+    const consoleSpy = vi.spyOn(console, "log");
+
+    try {
+      const client = quickbase({
+        realm: QB_REALM,
+        useSso: true,
+        samlToken: "mock-saml-token",
+        debug: true,
+        baseUrl: "http://localhost:3000/v1",
+      });
+
+      const concurrentRequests = [
+        client.getApp({ appId: QB_APP_ID }),
+        client.getApp({ appId: QB_APP_ID }),
+        client.getApp({ appId: QB_APP_ID }),
+      ];
+
+      const results = await Promise.all(concurrentRequests);
+
+      expect(results).toHaveLength(3);
+      results.forEach((result) =>
+        expect(result).toEqual({
+          id: QB_APP_ID,
+          name: "Mock App",
+          created: expect.any(Date),
+          updated: expect.any(Date),
+        })
+      );
+
+      // Verify token fetch and waits using console logs
+      const logs = consoleSpy.mock.calls;
+      const tokenFetchLogs = logs.filter((call) =>
+        call[0].includes("[fetchSsoToken] Fetched token")
+      );
+      expect(tokenFetchLogs).toHaveLength(1); // Single fetch with synchronization
+
+      const waitLogs = logs.filter((call) =>
+        call[0].includes("Waiting for existing SSO fetch")
+      );
+      expect(waitLogs.length).toBeGreaterThanOrEqual(2); // At least two waits
+
+      const appRequestLogs = logs.filter((call) =>
+        call[0].includes("Received getApp request")
+      );
+      expect(appRequestLogs).toHaveLength(3);
+
+      console.log(
+        "SsoTokenStrategy: Single token fetch with concurrent waits confirmed."
+      );
+    } finally {
+      mockServer.close();
+      consoleSpy.mockRestore();
+    }
+  },
+  { timeout: 20000 }
+);

package/tests/vitest/qb/auth/userTokenConcurrency.test.ts

@@ -0,0 +1,63 @@
+// tests/vitest/qb/auth/userTokenConcurrency.test.ts
+import { test, expect } from "vitest";
+import { quickbase } from "../../../../src/quickbaseClient";
+
+test(
+  "QuickbaseClient Integration - getApp with UserToken Concurrency",
+  async () => {
+    const realm = process.env.QB_REALM || "";
+    const appId = process.env.QB_APP_ID || "";
+    const userToken = process.env.QB_USER_TOKEN || "";
+
+    if (!realm || !appId || !userToken) {
+      throw new Error(
+        "QB_REALM, QB_APP_ID, and QB_USER_TOKEN must be set in .env"
+      );
+    }
+
+    const client = quickbase({
+      realm,
+      userToken,
+      debug: true,
+    });
+
+    const concurrentRequests = [
+      client.getApp({ appId }),
+      client.getApp({ appId }),
+      client.getApp({ appId }),
+    ];
+
+    const results = await Promise.all(concurrentRequests);
+
+    const expectedAppData = {
+      id: appId,
+      name: "qb-copy",
+      created: expect.any(Date),
+      updated: expect.any(Date),
+      description: "",
+      timeZone: "(UTC-08:00) Pacific Time (US & Canada)",
+      dateFormat: "MM-DD-YYYY",
+      hasEveryoneOnTheInternet: false,
+      memoryInfo: { estMemory: 0, estMemoryInclDependentApps: 0 },
+      securityProperties: {
+        allowClone: false,
+        allowExport: true,
+        enableAppTokens: true,
+        hideFromPublic: false,
+        mustBeRealmApproved: false,
+        useIPFilter: false,
+      },
+      ancestorId: undefined,
+      dataClassification: undefined,
+      variables: [{ name: "TestVar", value: "TestValue" }],
+    };
+
+    expect(results).toHaveLength(3);
+    results.forEach((result) => expect(result).toEqual(expectedAppData));
+
+    console.log(
+      "UserTokenStrategy: All concurrent requests used static token."
+    );
+  },
+  { timeout: 20000 }
+);

package/tests/vitest/qb/fields/getFieldsUsage.test.ts

@@ -28,7 +28,7 @@ describe("QuickbaseClient Integration - getFieldsUsage", () => {
     console.log(
       `Retrieved ${response.length} field usage entries for table ${QB_TABLE_ID_1}`
     );
-  }, 15000); // 15-second timeout
+  }, 30000); // 15-second timeout
 
   it("retrieves field usage with skip and top parameters", async () => {
     console.log(
@@ -73,5 +73,5 @@ describe("QuickbaseClient Integration - getFieldsUsage", () => {
       ),
     });
     console.log(`Confirmed 401 for invalid table ID ${invalidTableId}`);
-  }, 15000); // 15-second timeout
+  }, 30000); // 15-second timeout
 });

package/tests/vitest/unit/ThrottleBucket.test.ts

@@ -1,23 +1,29 @@
+// test/vitest/unit/ThrottleBucket.test.ts
 import { describe, it, expect, vi } from "vitest";
-import { ThrottleBucket } from "@/ThrottleBucket"; // Adjust path as needed
+import { ConcurrentThrottleBucket } from "@/ThrottleBucket"; // Should work with your alias
 
-describe("ThrottleBucket Unit Tests", () => {
+describe("ConcurrentThrottleBucket Unit Tests", () => {
   it("allows burst capacity immediately", async () => {
-    const bucket = new ThrottleBucket(5, 3); // rate: 5, burst: 3
+    const bucket = new ConcurrentThrottleBucket(5, 3); // rate: 5, burst: 3
     const startTime = Date.now();
 
-    await Promise.all([bucket.acquire(), bucket.acquire(), bucket.acquire()]);
+    await Promise.all([
+      bucket.acquire().then(() => bucket.release()),
+      bucket.acquire().then(() => bucket.release()),
+      bucket.acquire().then(() => bucket.release()),
+    ]);
 
     const duration = Date.now() - startTime;
     expect(duration).toBeLessThan(50); // All 3 should be instant (within 50ms)
   });
 
   it("delays calls beyond burst at correct rate", async () => {
-    const bucket = new ThrottleBucket(5, 3); // rate: 5 tokens/sec, burst: 3
+    const bucket = new ConcurrentThrottleBucket(5, 3); // rate: 5 tokens/sec, burst: 3
     const timings: number[] = [];
     const recordTime = async () => {
       await bucket.acquire();
       timings.push(Date.now());
+      bucket.release(); // Release slot
     };
 
     const startTime = Date.now();
@@ -38,11 +44,12 @@ describe("ThrottleBucket Unit Tests", () => {
   });
 
   it("maintains rate over sustained calls", async () => {
-    const bucket = new ThrottleBucket(2, 2); // rate: 2 tokens/sec, burst: 2
+    const bucket = new ConcurrentThrottleBucket(2, 2); // rate: 2 tokens/sec, burst: 2
     const timings: number[] = [];
     const recordTime = async () => {
       await bucket.acquire();
       timings.push(Date.now());
+      bucket.release(); // Release slot
     };
 
     const startTime = Date.now();
@@ -67,11 +74,12 @@ describe("ThrottleBucket Unit Tests", () => {
   });
 
   it("handles high concurrency without exceeding burst", async () => {
-    const bucket = new ThrottleBucket(5, 3); // rate: 5, burst: 3
+    const bucket = new ConcurrentThrottleBucket(5, 3); // rate: 5, burst: 3
     const timings: number[] = [];
     const recordTime = async () => {
       await bucket.acquire();
       timings.push(Date.now());
+      bucket.release(); // Release slot
     };
 
     const startTime = Date.now();
@@ -83,9 +91,7 @@ describe("ThrottleBucket Unit Tests", () => {
 
     const durations = timings.map((t) => t - startTime);
     expect(durations.length).toBe(10);
-    // First 3 should be instant
-    expect(durations.slice(0, 3).every((d) => d < 50)).toBe(true);
-    // Next calls should be staggered at ~200ms intervals
+    expect(durations.slice(0, 3).every((d) => d < 50)).toBe(true); // First 3 instant
     for (let i = 3; i < 10; i++) {
       const expectedDelay = (i - 2) * 200; // After burst, 200ms per token
       expect(durations[i]).toBeGreaterThanOrEqual(expectedDelay - 50);

package/tests/vitest/unit/apps/getAppConcurrency.test.ts

@@ -0,0 +1,151 @@
+// tests/vitest/unit/apps/getAppConcurrency.test.ts
+
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { createClient, mockFetch, QB_APP_ID, QB_REALM } from "@tests/setup.ts";
+
+describe("QuickbaseClient Unit - getApp Concurrency with Temp Tokens", () => {
+  let client: ReturnType<typeof createClient>;
+
+  beforeEach(() => {
+    mockFetch.mockClear();
+    // Reset client before each test
+    client = createClient(mockFetch, {
+      realm: QB_REALM,
+      useTempTokens: true, // Use TempTokenStrategy
+      debug: true,
+    });
+  });
+
+  it("handles concurrent getApp requests with a single token fetch", async () => {
+    // Mock the token fetch response
+    const tempTokenResponse = {
+      temporaryAuthorization: "temp-token-123",
+    };
+    mockFetch.mockImplementation((url: string, options: RequestInit) => {
+      if (url.includes(`/auth/temporary/${QB_APP_ID}`)) {
+        return Promise.resolve({
+          ok: true,
+          status: 200,
+          json: () => Promise.resolve(tempTokenResponse),
+        });
+      }
+      // Mock the getApp response
+      return Promise.resolve({
+        ok: true,
+        status: 200,
+        json: () =>
+          Promise.resolve({
+            id: QB_APP_ID,
+            name: "test-app",
+            created: "2025-02-13T18:22:33Z",
+            updated: "2025-03-04T04:25:51Z",
+          }),
+      });
+    });
+
+    // Simulate concurrent getApp requests
+    const concurrentRequests = [
+      client.getApp({ appId: QB_APP_ID }),
+      client.getApp({ appId: QB_APP_ID }),
+      client.getApp({ appId: QB_APP_ID }),
+    ];
+
+    const results = await Promise.all(concurrentRequests);
+
+    // Assertions
+    expect(results).toHaveLength(3); // All requests completed
+    results.forEach((result) => {
+      expect(result).toEqual({
+        id: QB_APP_ID,
+        name: "test-app",
+        created: expect.any(Date), // Assuming convertDates is true
+        updated: expect.any(Date),
+      });
+    });
+
+    // Verify token fetch was called exactly once
+    const tokenFetchCalls = mockFetch.mock.calls.filter((call) =>
+      call[0].includes(`/auth/temporary/${QB_APP_ID}`)
+    );
+    expect(tokenFetchCalls).toHaveLength(1); // Only one token fetch despite 3 requests
+
+    // Verify getApp calls were made with the temp token
+    const getAppCalls = mockFetch.mock.calls.filter((call) =>
+      call[0].includes(`/apps/${QB_APP_ID}`)
+    );
+    expect(getAppCalls).toHaveLength(3); // Three getApp requests
+    getAppCalls.forEach((call) => {
+      expect(call[1].headers).toMatchObject({
+        Authorization: `QB-TEMP-TOKEN ${tempTokenResponse.temporaryAuthorization}`,
+        "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+        "Content-Type": "application/json",
+      });
+    });
+  });
+
+  it("handles concurrent getApp requests with cached token", async () => {
+    // Pre-populate the token cache by making an initial request
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: () =>
+        Promise.resolve({ temporaryAuthorization: "cached-token-456" }),
+    });
+    await client.getApp({ appId: QB_APP_ID }); // This caches the token
+
+    // Reset mock to clear initial call tracking
+    mockFetch.mockClear();
+
+    // Mock only the getApp response now (no token fetch needed)
+    mockFetch.mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: () =>
+        Promise.resolve({
+          id: QB_APP_ID,
+          name: "test-app",
+          created: "2025-02-13T18:22:33Z",
+          updated: "2025-03-04T04:25:51Z",
+        }),
+    });
+
+    // Simulate concurrent getApp requests with cached token
+    const concurrentRequests = [
+      client.getApp({ appId: QB_APP_ID }),
+      client.getApp({ appId: QB_APP_ID }),
+      client.getApp({ appId: QB_APP_ID }),
+    ];
+
+    const results = await Promise.all(concurrentRequests);
+
+    // Assertions
+    expect(results).toHaveLength(3); // All requests completed
+    results.forEach((result) => {
+      expect(result).toEqual({
+        id: QB_APP_ID,
+        name: "test-app",
+        created: expect.any(Date),
+        updated: expect.any(Date),
+      });
+    });
+
+    // Verify no token fetches occurred (cache was used)
+    const tokenFetchCalls = mockFetch.mock.calls.filter((call) =>
+      call[0].includes(`/auth/temporary/${QB_APP_ID}`)
+    );
+    expect(tokenFetchCalls).toHaveLength(0); // No token fetches
+
+    // Verify getApp calls were made with the cached token
+    const getAppCalls = mockFetch.mock.calls.filter((call) =>
+      call[0].includes(`/apps/${QB_APP_ID}`)
+    );
+    expect(getAppCalls).toHaveLength(3); // Three getApp requests
+    getAppCalls.forEach((call) => {
+      expect(call[1].headers).toMatchObject({
+        Authorization: `QB-TEMP-TOKEN cached-token-456`,
+        "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+        "Content-Type": "application/json",
+      });
+    });
+  });
+});

package/tests/vitest/unit/auth/fetchTempToken401.test.ts

@@ -42,7 +42,7 @@ describe("QuickbaseClient Unit - 401 with fetchTempToken 401", () => {
           json: () => Promise.resolve({ message: "Temp token fetch failed" }),
         });
       }
-      return Promise.reject(new Error(`Unexpected fetch call: ${url}`));
+      throw new Error(`Unexpected fetch call: ${url}`); // Use throw to stop further retries
     });
 
     const consoleSpy = vi.spyOn(console, "log");
@@ -52,8 +52,26 @@ describe("QuickbaseClient Unit - 401 with fetchTempToken 401", () => {
     );
 
     expect(mockFetch).toHaveBeenCalledTimes(3);
+    expect(mockFetch).toHaveBeenNthCalledWith(
+      1,
+      `https://api.quickbase.com/v1/auth/temporary/${QB_TABLE_ID_1}`,
+      expect.any(Object)
+    );
+    expect(mockFetch).toHaveBeenNthCalledWith(
+      2,
+      `https://api.quickbase.com/v1/fields?tableId=${QB_TABLE_ID_1}`,
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          Authorization: `QB-TEMP-TOKEN ${mockToken}`,
+        }),
+      })
+    );
+    expect(mockFetch).toHaveBeenNthCalledWith(
+      3,
+      `https://api.quickbase.com/v1/auth/temporary/${QB_TABLE_ID_1}`,
+      expect.any(Object)
+    );
 
-    // Updated to match the single-argument log from handleError
     expect(consoleSpy).toHaveBeenCalledWith(
       "Authorization error for getFields (temp token), refreshing token:"
     );