quickbase-js 0.1.0-beta.8 → 0.1.0-beta.9

package/tests/vitest/qb/tables/updateRelationship.test.ts

@@ -1,4 +1,6 @@
-import { describe, it, expect, beforeAll, afterAll, beforeEach } from "vitest";
+// tests/vitest/qb/tables/updateRelationship.test.ts
+
+import { describe, it, expect } from "vitest";
 import {
   createClient,
   QB_REALM,
@@ -19,35 +21,23 @@ describe("QuickbaseClient Integration - updateRelationship", () => {
   let generatedLookupFieldId: number | undefined;
   let generatedSummaryFieldId: number | undefined;
 
-  beforeAll(async () => {
-    client = createClient(fetch, {
-      realm: QB_REALM,
-      userToken: QB_USER_TOKEN,
-      debug: true,
-    });
+  // No beforeAll/afterAll since we'll create and delete within the test
 
+  it("creates, updates, deletes, and verifies a relationship", async () => {
+    // Validate environment variables
     if (!QB_REALM) throw new Error("QB_REALM is not defined in .env");
     if (!QB_USER_TOKEN) throw new Error("QB_USER_TOKEN is not defined in .env");
+    if (!QB_TABLE_ID_1) throw new Error("QB_TABLE_ID_1 is not defined in .env");
+    if (!QB_TABLE_ID_2) throw new Error("QB_TABLE_ID_2 is not defined in .env");
 
-    const relationshipsResponse = await client.getRelationships({
-      tableId: QB_TABLE_ID_2,
-      skip: 0,
+    // Initialize client
+    client = createClient(fetch, {
+      realm: QB_REALM,
+      userToken: QB_USER_TOKEN,
+      debug: true,
     });
-    console.log(
-      "Initial relationships response:",
-      JSON.stringify(relationshipsResponse, null, 2)
-    );
-    const relationship = relationshipsResponse.relationships.find(
-      (r) => r.parentTableId === QB_TABLE_ID_1
-    );
-    if (!relationship) {
-      throw new Error(
-        `No relationship found between parent ${QB_TABLE_ID_1} and child ${QB_TABLE_ID_2}`
-      );
-    }
-    relationshipId = relationship.id;
-    console.log(`Identified relationshipId: ${relationshipId}`);
 
+    // Step 1: Create fields for the relationship update
     const lookupFieldRequest: CreateFieldRequest = {
       label: `Test Lookup Field_${Date.now()}`,
       fieldType: "text",
@@ -80,103 +70,40 @@ describe("QuickbaseClient Integration - updateRelationship", () => {
       `Created child field with ID ${newChildFieldId} in child table ${QB_TABLE_ID_2}`
     );
 
-    console.log(
-      `Setup complete: relationshipId=${relationshipId}, lookupFieldId=${newLookupFieldId}, childFieldId=${newChildFieldId}`
-    );
-  }, 30000);
-
-  afterAll(async () => {
-    if (newLookupFieldId) {
-      try {
-        const deleteLookupResponse = await client.deleteFields({
-          tableId: QB_TABLE_ID_1,
-          body: { fieldIds: [newLookupFieldId] },
-        });
-        console.log(
-          `Deleted original lookup field ${newLookupFieldId} from ${QB_TABLE_ID_1}:`,
-          JSON.stringify(deleteLookupResponse, null, 2)
-        );
-      } catch (error) {
-        console.error(
-          `Failed to delete original lookup field ${newLookupFieldId}:`,
-          error
-        );
-        throw error;
-      }
-    }
-    if (newChildFieldId) {
-      try {
-        const deleteChildResponse = await client.deleteFields({
-          tableId: QB_TABLE_ID_2,
-          body: { fieldIds: [newChildFieldId] },
-        });
-        console.log(
-          `Deleted original child field ${newChildFieldId} from ${QB_TABLE_ID_2}:`,
-          JSON.stringify(deleteChildResponse, null, 2)
-        );
-      } catch (error) {
-        console.error(
-          `Failed to delete original child field ${newChildFieldId}:`,
-          error
-        );
-        throw error;
-      }
-    }
-    if (generatedLookupFieldId) {
-      try {
-        const deleteGeneratedLookupResponse = await client.deleteFields({
-          tableId: QB_TABLE_ID_2,
-          body: { fieldIds: [generatedLookupFieldId] },
-        });
-        console.log(
-          `Deleted generated lookup field ${generatedLookupFieldId} from ${QB_TABLE_ID_2}:`,
-          JSON.stringify(deleteGeneratedLookupResponse, null, 2)
-        );
-      } catch (error) {
-        console.error(
-          `Failed to delete generated lookup field ${generatedLookupFieldId}:`,
-          error
-        );
-        throw error;
-      }
-    }
-    if (generatedSummaryFieldId) {
-      try {
-        const deleteGeneratedSummaryResponse = await client.deleteFields({
-          tableId: QB_TABLE_ID_1,
-          body: { fieldIds: [generatedSummaryFieldId] },
-        });
-        console.log(
-          `Deleted generated summary field ${generatedSummaryFieldId} from ${QB_TABLE_ID_1}:`,
-          JSON.stringify(deleteGeneratedSummaryResponse, null, 2)
-        );
-      } catch (error) {
-        console.error(
-          `Failed to delete generated summary field ${generatedSummaryFieldId}:`,
-          error
-        );
-        throw error;
-      }
-    }
-  }, 30000);
+    // Step 2: Create a new relationship
+    const uniqueLabel = `TestRelationship_${Date.now()}`;
+    const createRequestBody = {
+      parentTableId: QB_TABLE_ID_1,
+      foreignKeyField: { label: uniqueLabel },
+      lookupFieldIds: [6], // Assuming field 6 exists in QB_TABLE_ID_1
+      summaryFields: [
+        {
+          summaryFid: 6, // Assuming field 6 in QB_TABLE_ID_2 is numeric
+          label: `Sum_${uniqueLabel}`,
+          accumulationType: "SUM",
+        },
+      ],
+    };
 
-  beforeEach(async () => {
-    const relationshipsResponse = await client.getRelationships({
+    console.log("Creating relationship with:", createRequestBody);
+    const createResponse = await client.createRelationship({
       tableId: QB_TABLE_ID_2,
+      body: createRequestBody,
     });
-    const relationship = relationshipsResponse.relationships.find(
-      (r) => r.id === relationshipId
-    );
-    if (!relationship) {
-      throw new Error(`Relationship ${relationshipId} not found before test`);
-    }
     console.log(
-      "Relationship state before test:",
-      JSON.stringify(relationship, null, 2)
+      "Created relationship response:",
+      JSON.stringify(createResponse, null, 2)
     );
-  }, 30000);
 
-  it("adds a lookup field to the relationship", async ({ expect }) => {
+    expect(createResponse).toBeDefined();
+    expect(createResponse.id).toBeDefined();
+    expect(createResponse.parentTableId).toBe(QB_TABLE_ID_1);
+    expect(createResponse.childTableId).toBe(QB_TABLE_ID_2);
+    expect(createResponse.foreignKeyField?.label).toBe(uniqueLabel);
+
+    relationshipId = createResponse.id;
+
+    // Step 3: Update the relationship - Add a lookup field
     const tableId = QB_TABLE_ID_2;
     const initialResponse = await client.getRelationships({ tableId });
     const initialRelationship = initialResponse.relationships.find(
@@ -187,22 +114,25 @@ describe("QuickbaseClient Integration - updateRelationship", () => {
     );
     console.log("Current lookupFields before update:", currentLookupFields);
 
-    const request: UpdateRelationshipRequest = {
+    const updateLookupRequest: UpdateRelationshipRequest = {
       lookupFieldIds: [newLookupFieldId!],
     };
     console.log(
       "Adding lookup field request:",
-      JSON.stringify(request, null, 2)
+      JSON.stringify(updateLookupRequest, null, 2)
     );
 
-    const updateResponse = await client.updateRelationship({
+    const updateLookupResponse = await client.updateRelationship({
       tableId,
       relationshipId,
-      body: request,
+      body: updateLookupRequest,
     });
-    console.log("Update response:", JSON.stringify(updateResponse, null, 2));
+    console.log(
+      "Update lookup response:",
+      JSON.stringify(updateLookupResponse, null, 2)
+    );
 
-    const newLookup = updateResponse.lookupFields.find(
+    const newLookup = updateLookupResponse.lookupFields.find(
       (f) =>
         f.label.includes("Test Lookup Field") &&
         !currentLookupFields.includes(f.id)
@@ -212,29 +142,22 @@ describe("QuickbaseClient Integration - updateRelationship", () => {
       `Captured generated lookup field ID: ${generatedLookupFieldId}`
     );
 
-    expect(updateResponse.id).toBe(relationshipId);
-    expect(updateResponse.childTableId).toBe(QB_TABLE_ID_2);
-    expect(updateResponse.parentTableId).toBe(QB_TABLE_ID_1);
+    expect(updateLookupResponse.id).toBe(relationshipId);
+    expect(updateLookupResponse.childTableId).toBe(QB_TABLE_ID_2);
+    expect(updateLookupResponse.parentTableId).toBe(QB_TABLE_ID_1);
     expect(
-      updateResponse.lookupFields.some((f) =>
+      updateLookupResponse.lookupFields.some((f) =>
         f.label.includes("Test Lookup Field")
       )
     ).toBe(true);
-    expect(updateResponse.lookupFields.some((f) => f.id === 19)).toBe(true);
-  }, 30000);
 
-  it("adds a summary field to the parent table", async ({ expect }) => {
-    const tableId = QB_TABLE_ID_2;
-    const initialResponse = await client.getRelationships({ tableId });
-    const initialRelationship = initialResponse.relationships.find(
-      (r) => r.id === relationshipId
-    );
-    const currentSummaryFields = (initialRelationship?.summaryFields || []).map(
+    // Step 4: Update the relationship - Add a summary field
+    const currentSummaryFields = (updateLookupResponse.summaryFields || []).map(
       (f) => f.id
     );
     console.log("Current summaryFields before update:", currentSummaryFields);
 
-    const request: UpdateRelationshipRequest = {
+    const updateSummaryRequest: UpdateRelationshipRequest = {
       summaryFields: [
         {
           summaryFid: newChildFieldId!,
@@ -245,17 +168,20 @@ describe("QuickbaseClient Integration - updateRelationship", () => {
     };
     console.log(
       "Adding summary field request:",
-      JSON.stringify(request, null, 2)
+      JSON.stringify(updateSummaryRequest, null, 2)
     );
 
-    const updateResponse = await client.updateRelationship({
+    const updateSummaryResponse = await client.updateRelationship({
       tableId,
       relationshipId,
-      body: request,
+      body: updateSummaryRequest,
     });
-    console.log("Update response:", JSON.stringify(updateResponse, null, 2));
+    console.log(
+      "Update summary response:",
+      JSON.stringify(updateSummaryResponse, null, 2)
+    );
 
-    const newSummary = updateResponse.summaryFields.find(
+    const newSummary = updateSummaryResponse.summaryFields.find(
       (f) =>
         f.label.includes("Test Summary Field") &&
         !currentSummaryFields.includes(f.id)
@@ -265,13 +191,60 @@ describe("QuickbaseClient Integration - updateRelationship", () => {
       `Captured generated summary field ID: ${generatedSummaryFieldId}`
     );
 
-    expect(updateResponse.id).toBe(relationshipId);
-    expect(updateResponse.childTableId).toBe(QB_TABLE_ID_2);
-    expect(updateResponse.parentTableId).toBe(QB_TABLE_ID_1);
+    expect(updateSummaryResponse.id).toBe(relationshipId);
+    expect(updateSummaryResponse.childTableId).toBe(QB_TABLE_ID_2);
+    expect(updateSummaryResponse.parentTableId).toBe(QB_TABLE_ID_1);
     expect(
-      updateResponse.summaryFields.some((f) =>
+      updateSummaryResponse.summaryFields.some((f) =>
         f.label.includes("Test Summary Field")
       )
     ).toBe(true);
-  }, 30000);
+
+    // Step 5: Delete the relationship
+    console.log("Deleting relationship with ID:", relationshipId);
+    const deleteResponse = await client.deleteRelationship({
+      tableId: QB_TABLE_ID_2,
+      relationshipId,
+    });
+    console.log(
+      "Delete relationship response:",
+      JSON.stringify(deleteResponse, null, 2)
+    );
+
+    expect(deleteResponse).toBeDefined();
+    expect(deleteResponse.relationshipId).toBe(relationshipId);
+
+    // Step 6: Verify deletion
+    const relationships = await client.getRelationships({
+      tableId: QB_TABLE_ID_2,
+    });
+    console.log(
+      "Relationships after deletion:",
+      JSON.stringify(relationships, null, 2)
+    );
+    const deletedRelationship = relationships.relationships.find(
+      (r) => r.id === relationshipId
+    );
+    expect(deletedRelationship).toBeUndefined(); // Confirm relationship is gone
+
+    // Cleanup remaining fields from setup
+    if (newLookupFieldId) {
+      await client.deleteFields({
+        tableId: QB_TABLE_ID_1,
+        body: { fieldIds: [newLookupFieldId] },
+      });
+      console.log(
+        `Deleted lookup field ${newLookupFieldId} from ${QB_TABLE_ID_1}`
+      );
+    }
+    if (newChildFieldId) {
+      await client.deleteFields({
+        tableId: QB_TABLE_ID_2,
+        body: { fieldIds: [newChildFieldId] },
+      });
+      console.log(
+        `Deleted child field ${newChildFieldId} from ${QB_TABLE_ID_2}`
+      );
+    }
+  }, 60000);
 });

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

@@ -0,0 +1,95 @@
+import { describe, it, expect, vi } from "vitest";
+import { ThrottleBucket } from "@/ThrottleBucket"; // Adjust path as needed
+
+describe("ThrottleBucket Unit Tests", () => {
+  it("allows burst capacity immediately", async () => {
+    const bucket = new ThrottleBucket(5, 3); // rate: 5, burst: 3
+    const startTime = Date.now();
+
+    await Promise.all([bucket.acquire(), bucket.acquire(), bucket.acquire()]);
+
+    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 timings: number[] = [];
+    const recordTime = async () => {
+      await bucket.acquire();
+      timings.push(Date.now());
+    };
+
+    const startTime = Date.now();
+    await Promise.all([
+      recordTime(),
+      recordTime(),
+      recordTime(),
+      recordTime(), // 4th call should delay
+    ]);
+
+    const durations = timings.map((t) => t - startTime);
+    expect(durations.length).toBe(4);
+    expect(durations[0]).toBeLessThan(50); // 1st call instant
+    expect(durations[1]).toBeLessThan(50); // 2nd call instant
+    expect(durations[2]).toBeLessThan(50); // 3rd call instant
+    expect(durations[3]).toBeGreaterThanOrEqual(180); // 4th call delayed ~200ms
+    expect(durations[3]).toBeLessThan(250); // Shouldn’t exceed 250ms
+  });
+
+  it("maintains rate over sustained calls", async () => {
+    const bucket = new ThrottleBucket(2, 2); // rate: 2 tokens/sec, burst: 2
+    const timings: number[] = [];
+    const recordTime = async () => {
+      await bucket.acquire();
+      timings.push(Date.now());
+    };
+
+    const startTime = Date.now();
+    await Promise.all([
+      recordTime(),
+      recordTime(),
+      recordTime(),
+      recordTime(),
+      recordTime(), // 5 calls total
+    ]);
+
+    const durations = timings.map((t) => t - startTime);
+    expect(durations.length).toBe(5);
+    expect(durations[0]).toBeLessThan(50); // 1st instant
+    expect(durations[1]).toBeLessThan(50); // 2nd instant
+    expect(durations[2]).toBeGreaterThanOrEqual(450); // 3rd delayed ~500ms (1/2 sec)
+    expect(durations[2]).toBeLessThan(550);
+    expect(durations[3]).toBeGreaterThanOrEqual(950); // 4th delayed ~1000ms
+    expect(durations[3]).toBeLessThan(1050);
+    expect(durations[4]).toBeGreaterThanOrEqual(1450); // 5th delayed ~1500ms
+    expect(durations[4]).toBeLessThan(1550);
+  });
+
+  it("handles high concurrency without exceeding burst", async () => {
+    const bucket = new ThrottleBucket(5, 3); // rate: 5, burst: 3
+    const timings: number[] = [];
+    const recordTime = async () => {
+      await bucket.acquire();
+      timings.push(Date.now());
+    };
+
+    const startTime = Date.now();
+    await Promise.all(
+      Array(10)
+        .fill(null)
+        .map(() => recordTime())
+    ); // 10 concurrent calls
+
+    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
+    for (let i = 3; i < 10; i++) {
+      const expectedDelay = (i - 2) * 200; // After burst, 200ms per token
+      expect(durations[i]).toBeGreaterThanOrEqual(expectedDelay - 50);
+      expect(durations[i]).toBeLessThan(expectedDelay + 50);
+    }
+  });
+});

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

@@ -1,5 +1,3 @@
-// tests/vitest/unit/apps/copyApp.test.ts
-
 import { describe, it, expect, beforeEach } from "vitest";
 import {
   createClient,
@@ -45,8 +43,8 @@ describe("QuickbaseClient Unit - copyApp", () => {
       id: "bpqe82s1",
       name: "Copied App",
       description: "A copy of the original app",
-      created: new Date("2025-03-11T10:00:00Z"), // Expect Date object
-      updated: new Date("2025-03-11T10:00:00Z"), // Expect Date object
+      created: new Date("2025-03-11T10:00:00Z"),
+      updated: new Date("2025-03-11T10:00:00Z"),
       dateFormat: "MM-DD-YYYY",
       timeZone: "(UTC-08:00) Pacific Time (US & Canada)",
       hasEveryoneOnTheInternet: false,
@@ -97,8 +95,8 @@ describe("QuickbaseClient Unit - copyApp", () => {
       id: "bpqe82s1",
       name: "Copied App",
       description: "A copy of the original app",
-      created: "2025-03-11T10:00:00Z", // Expect string
-      updated: "2025-03-11T10:00:00Z", // Expect string
+      created: "2025-03-11T10:00:00Z",
+      updated: "2025-03-11T10:00:00Z",
       dateFormat: "MM-DD-YYYY",
       timeZone: "(UTC-08:00) Pacific Time (US & Canada)",
       hasEveryoneOnTheInternet: false,
@@ -149,8 +147,8 @@ describe("QuickbaseClient Unit - copyApp", () => {
       id: "bpqe82s2",
       name: "Copied App with Temp Token",
       description: "A copy using temp token",
-      created: new Date("2025-03-11T11:00:00Z"), // Expect Date object
-      updated: new Date("2025-03-11T11:00:00Z"), // Expect Date object
+      created: new Date("2025-03-11T11:00:00Z"),
+      updated: new Date("2025-03-11T11:00:00Z"),
       dateFormat: "MM-DD-YYYY",
       timeZone: "(UTC-08:00) Pacific Time (US & Canada)",
       hasEveryoneOnTheInternet: true,
@@ -178,27 +176,15 @@ describe("QuickbaseClient Unit - copyApp", () => {
     expect(mockFetch).toHaveBeenNthCalledWith(
       1,
       `https://api.quickbase.com/v1/auth/temporary/${QB_APP_ID}`,
-      expect.objectContaining({
-        method: "GET",
-        headers: expect.objectContaining({
-          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
-          "Content-Type": "application/json",
-        }),
-        credentials: "include",
-      })
+      expect.any(Object)
     );
     expect(mockFetch).toHaveBeenNthCalledWith(
       2,
       `https://api.quickbase.com/v1/apps/${QB_APP_ID}/copy`,
       expect.objectContaining({
-        method: "POST",
         headers: expect.objectContaining({
-          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
           Authorization: "QB-TEMP-TOKEN temp_token",
-          "Content-Type": "application/json",
         }),
-        credentials: "omit",
-        body: JSON.stringify(request),
       })
     );
   });
@@ -225,8 +211,8 @@ describe("QuickbaseClient Unit - copyApp", () => {
       id: "bpqe82s2",
       name: "Copied App with Temp Token",
       description: "A copy using temp token",
-      created: "2025-03-11T11:00:00Z", // Expect string
-      updated: "2025-03-11T11:00:00Z", // Expect string
+      created: "2025-03-11T11:00:00Z",
+      updated: "2025-03-11T11:00:00Z",
       dateFormat: "MM-DD-YYYY",
       timeZone: "(UTC-08:00) Pacific Time (US & Canada)",
       hasEveryoneOnTheInternet: true,
@@ -254,27 +240,15 @@ describe("QuickbaseClient Unit - copyApp", () => {
     expect(mockFetch).toHaveBeenNthCalledWith(
       1,
       `https://api.quickbase.com/v1/auth/temporary/${QB_APP_ID}`,
-      expect.objectContaining({
-        method: "GET",
-        headers: expect.objectContaining({
-          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
-          "Content-Type": "application/json",
-        }),
-        credentials: "include",
-      })
+      expect.any(Object)
     );
     expect(mockFetch).toHaveBeenNthCalledWith(
       2,
       `https://api.quickbase.com/v1/apps/${QB_APP_ID}/copy`,
       expect.objectContaining({
-        method: "POST",
         headers: expect.objectContaining({
-          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
           Authorization: "QB-TEMP-TOKEN temp_token",
-          "Content-Type": "application/json",
         }),
-        credentials: "omit",
-        body: JSON.stringify(request),
       })
     );
   });
@@ -297,8 +271,8 @@ describe("QuickbaseClient Unit - copyApp", () => {
       id: "bpqe82s3",
       name: "Retry Copied App",
       description: "Retry after 401",
-      created: new Date("2025-03-11T12:00:00Z"), // Expect Date object
-      updated: new Date("2025-03-11T12:00:00Z"), // Expect Date object
+      created: new Date("2025-03-11T12:00:00Z"),
+      updated: new Date("2025-03-11T12:00:00Z"),
       dateFormat: "MM-DD-YYYY",
       timeZone: "(UTC-08:00) Pacific Time (US & Canada)",
       hasEveryoneOnTheInternet: false,
@@ -386,8 +360,8 @@ describe("QuickbaseClient Unit - copyApp", () => {
       id: "bpqe82s3",
       name: "Retry Copied App",
       description: "Retry after 401",
-      created: "2025-03-11T12:00:00Z", // Expect string
-      updated: "2025-03-11T12:00:00Z", // Expect string
+      created: "2025-03-11T12:00:00Z",
+      updated: "2025-03-11T12:00:00Z",
       dateFormat: "MM-DD-YYYY",
       timeZone: "(UTC-08:00) Pacific Time (US & Canada)",
       hasEveryoneOnTheInternet: false,
@@ -485,4 +459,123 @@ describe("QuickbaseClient Unit - copyApp", () => {
       })
     );
   });
+
+  it("exhausts default maxRetries (3) with temp token and throws error", async () => {
+    client = createClient(mockFetch, { useTempTokens: true, debug: true }); // No explicit maxRetries, uses default 3
+
+    const request: CopyAppRequest = {
+      name: "Fail App",
+      description: "Test retry limit",
+      properties: {
+        keepData: false,
+        excludeFiles: true,
+        usersAndRoles: false,
+        assignUserToken: true,
+      },
+    };
+
+    mockFetch
+      .mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        json: () => Promise.resolve({ temporaryAuthorization: "token_1" }),
+      })
+      .mockResolvedValueOnce({
+        ok: false,
+        status: 401,
+        json: () => Promise.resolve({ message: "Unauthorized 1" }),
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        json: () => Promise.resolve({ temporaryAuthorization: "token_2" }),
+      })
+      .mockResolvedValueOnce({
+        ok: false,
+        status: 401,
+        json: () => Promise.resolve({ message: "Unauthorized 2" }),
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        json: () => Promise.resolve({ temporaryAuthorization: "token_3" }),
+      })
+      .mockResolvedValueOnce({
+        ok: false,
+        status: 401,
+        json: () => Promise.resolve({ message: "Unauthorized 3" }),
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        status: 200,
+        json: () => Promise.resolve({ temporaryAuthorization: "token_4" }),
+      })
+      .mockResolvedValueOnce({
+        ok: false,
+        status: 401,
+        json: () => Promise.resolve({ message: "Unauthorized 4" }),
+      });
+
+    await expect(
+      client.copyApp({ appId: QB_APP_ID, body: request })
+    ).rejects.toThrow("API Error: Unauthorized 4 (Status: 401)");
+
+    expect(mockFetch).toHaveBeenCalledTimes(8); // 4 token fetches + 4 API attempts
+    expect(mockFetch).toHaveBeenNthCalledWith(
+      1,
+      `https://api.quickbase.com/v1/auth/temporary/${QB_APP_ID}`,
+      expect.any(Object)
+    );
+    expect(mockFetch).toHaveBeenNthCalledWith(
+      2,
+      `https://api.quickbase.com/v1/apps/${QB_APP_ID}/copy`,
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          Authorization: "QB-TEMP-TOKEN token_1",
+        }),
+      })
+    );
+    expect(mockFetch).toHaveBeenNthCalledWith(
+      3,
+      `https://api.quickbase.com/v1/auth/temporary/${QB_APP_ID}`,
+      expect.any(Object)
+    );
+    expect(mockFetch).toHaveBeenNthCalledWith(
+      4,
+      `https://api.quickbase.com/v1/apps/${QB_APP_ID}/copy`,
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          Authorization: "QB-TEMP-TOKEN token_2",
+        }),
+      })
+    );
+    expect(mockFetch).toHaveBeenNthCalledWith(
+      5,
+      `https://api.quickbase.com/v1/auth/temporary/${QB_APP_ID}`,
+      expect.any(Object)
+    );
+    expect(mockFetch).toHaveBeenNthCalledWith(
+      6,
+      `https://api.quickbase.com/v1/apps/${QB_APP_ID}/copy`,
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          Authorization: "QB-TEMP-TOKEN token_3",
+        }),
+      })
+    );
+    expect(mockFetch).toHaveBeenNthCalledWith(
+      7,
+      `https://api.quickbase.com/v1/auth/temporary/${QB_APP_ID}`,
+      expect.any(Object)
+    );
+    expect(mockFetch).toHaveBeenNthCalledWith(
+      8,
+      `https://api.quickbase.com/v1/apps/${QB_APP_ID}/copy`,
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          Authorization: "QB-TEMP-TOKEN token_4",
+        }),
+      })
+    );
+  });
 });