quickbase-js 1.1.0-beta.0 → 1.1.0-beta.2

package/tests/vitest/unit/records/upsert.test.ts

@@ -1,21 +1,23 @@
 // tests/vitest/unit/records/upsert.test.ts
 import { describe, expect, test, beforeEach } from "vitest";
-import { createClient, mockFetch } from "@tests/setup.ts";
+import {
+  createClient,
+  mockFetch,
+  QB_REALM,
+  QB_USER_TOKEN,
+  QB_TABLE_ID_1,
+} from "@tests/setup.ts";
 import { vi } from "vitest";
 
 // Note: Type augmentation moved to src/types.d.ts
-describe("QuickbaseClient - upsert (Unit)", () => {
+describe("QuickbaseClient Unit - upsert", () => {
   beforeEach(() => {
     vi.resetModules(); // Reset module cache
     mockFetch.mockClear();
   });
 
   test("sends correct POST request and handles successful upsert", async () => {
-    const qb = createClient(mockFetch, {
-      realm: "test-realm",
-      userToken: "test-token",
-      debug: true,
-    });
+    const qb = createClient(mockFetch, { debug: true });
 
     mockFetch.mockResolvedValueOnce({
       ok: true,
@@ -33,10 +35,10 @@ describe("QuickbaseClient - upsert (Unit)", () => {
     });
 
     console.log("[Test] Calling qb.upsert with:", {
-      body: { to: "test-table-id", data: [{ "6": { value: "value1" } }] },
+      body: { to: QB_TABLE_ID_1, data: [{ "6": { value: "value1" } }] },
     });
     const result = await qb.upsert({
-      body: { to: "test-table-id", data: [{ "6": { value: "value1" } }] },
+      body: { to: QB_TABLE_ID_1, data: [{ "6": { value: "value1" } }] },
     });
 
     console.log("[Test] mockFetch calls:", mockFetch.mock.calls);
@@ -45,12 +47,12 @@ describe("QuickbaseClient - upsert (Unit)", () => {
       expect.objectContaining({
         method: "POST",
         headers: expect.objectContaining({
-          "QB-Realm-Hostname": "test-realm.quickbase.com",
-          Authorization: "QB-USER-TOKEN test-token",
+          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+          Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
           "Content-Type": "application/json",
         }),
         body: JSON.stringify({
-          to: "test-table-id",
+          to: QB_TABLE_ID_1,
           data: [{ "6": { value: "value1" } }],
         }),
       })
@@ -68,11 +70,7 @@ describe("QuickbaseClient - upsert (Unit)", () => {
   });
 
   test("handles API error with invalid data", async () => {
-    const qb = createClient(mockFetch, {
-      realm: "test-realm",
-      userToken: "test-token",
-      debug: true,
-    });
+    const qb = createClient(mockFetch, { debug: true });
 
     mockFetch.mockResolvedValueOnce({
       ok: false,
@@ -82,7 +80,7 @@ describe("QuickbaseClient - upsert (Unit)", () => {
 
     await expect(
       qb.upsert({
-        body: { to: "test-table-id", data: [{ "999": { value: "invalid" } }] },
+        body: { to: QB_TABLE_ID_1, data: [{ "999": { value: "invalid" } }] },
       })
     ).rejects.toThrow("API Error: Invalid data format (Status: 400)");
 
@@ -91,12 +89,12 @@ describe("QuickbaseClient - upsert (Unit)", () => {
       expect.objectContaining({
         method: "POST",
         headers: expect.objectContaining({
-          "QB-Realm-Hostname": "test-realm.quickbase.com",
-          Authorization: "QB-USER-TOKEN test-token",
+          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+          Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
           "Content-Type": "application/json",
         }),
         body: JSON.stringify({
-          to: "test-table-id",
+          to: QB_TABLE_ID_1,
           data: [{ "999": { value: "invalid" } }],
         }),
       })
@@ -104,11 +102,7 @@ describe("QuickbaseClient - upsert (Unit)", () => {
   });
 
   test("handles upsert with temp token", async () => {
-    const qb = createClient(mockFetch, {
-      realm: "test-realm",
-      useTempTokens: true,
-      debug: true,
-    });
+    const qb = createClient(mockFetch, { useTempTokens: true, debug: true });
 
     mockFetch
       .mockResolvedValueOnce({
@@ -132,18 +126,18 @@ describe("QuickbaseClient - upsert (Unit)", () => {
       });
 
     const result = await qb.upsert({
-      body: { to: "test-table-id", data: [{ "7": { value: "value2" } }] },
-      dbid: "test-dbid",
+      body: { to: QB_TABLE_ID_1, data: [{ "7": { value: "value2" } }] },
+      dbid: QB_TABLE_ID_1, // Use QB_TABLE_ID_1 as dbid for temp token
     } as any); // Temporary type assertion until types.d.ts is applied
 
     expect(mockFetch).toHaveBeenCalledTimes(2);
     expect(mockFetch).toHaveBeenNthCalledWith(
       1,
-      "https://api.quickbase.com/v1/auth/temporary/test-dbid",
+      `https://api.quickbase.com/v1/auth/temporary/${QB_TABLE_ID_1}`,
       expect.objectContaining({
         method: "GET",
         headers: expect.objectContaining({
-          "QB-Realm-Hostname": "test-realm.quickbase.com",
+          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
           "Content-Type": "application/json",
         }),
         credentials: "include",
@@ -155,12 +149,12 @@ describe("QuickbaseClient - upsert (Unit)", () => {
       expect.objectContaining({
         method: "POST",
         headers: expect.objectContaining({
-          "QB-Realm-Hostname": "test-realm.quickbase.com",
+          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
           Authorization: "QB-TEMP-TOKEN temp-token",
           "Content-Type": "application/json",
         }),
         body: JSON.stringify({
-          to: "test-table-id",
+          to: QB_TABLE_ID_1,
           data: [{ "7": { value: "value2" } }],
         }),
       })
@@ -178,11 +172,7 @@ describe("QuickbaseClient - upsert (Unit)", () => {
   });
 
   test("sends correct POST request with data fields", async () => {
-    const qb = createClient(mockFetch, {
-      realm: "test-realm",
-      userToken: "test-token",
-      debug: true,
-    });
+    const qb = createClient(mockFetch, { debug: true });
 
     mockFetch.mockResolvedValueOnce({
       ok: true,
@@ -200,7 +190,7 @@ describe("QuickbaseClient - upsert (Unit)", () => {
     });
 
     const result = await qb.upsert({
-      body: { to: "test-table-id", data: [{ "6": { value: "value1" } }] },
+      body: { to: QB_TABLE_ID_1, data: [{ "6": { value: "value1" } }] },
     });
 
     expect(mockFetch).toHaveBeenCalledWith(
@@ -208,12 +198,12 @@ describe("QuickbaseClient - upsert (Unit)", () => {
       expect.objectContaining({
         method: "POST",
         headers: expect.objectContaining({
-          "QB-Realm-Hostname": "test-realm.quickbase.com",
-          Authorization: "QB-USER-TOKEN test-token",
+          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+          Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
           "Content-Type": "application/json",
         }),
         body: JSON.stringify({
-          to: "test-table-id",
+          to: QB_TABLE_ID_1,
           data: [{ "6": { value: "value1" } }],
         }),
       })

package/tests/vitest/unit/tables/createTable.test.ts

@@ -1,7 +1,14 @@
-import { describe, it, expect, beforeEach, vi } from "vitest";
-import { createClient, mockFetch } from "@tests/setup.ts";
+// tests/vitest/unit/records/createTable.test.ts
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  createClient,
+  mockFetch,
+  QB_APP_ID,
+  QB_REALM,
+  QB_USER_TOKEN,
+} from "@tests/setup.ts";
 
-describe("QuickbaseClient - createTable (Unit)", () => {
+describe("QuickbaseClient Unit - createTable", () => {
   let client: ReturnType<typeof createClient>;
 
   beforeEach(() => {
@@ -10,7 +17,6 @@ describe("QuickbaseClient - createTable (Unit)", () => {
   });
 
   it("calls createTable successfully with user token", async () => {
-    const appId = "buwai2zpe";
     const mockBody = {
       name: "TestTable",
       description: "Unit test table",
@@ -18,7 +24,7 @@ describe("QuickbaseClient - createTable (Unit)", () => {
       pluralRecordName: "Tests",
     };
     const mockResponse = {
-      id: "buya8h9iz",
+      id: "newly-created-table-id-1234567890", // Changed from "buya8h9iz"
       name: "TestTable",
       alias: "_DBID_TESTTABLE",
       description: "Unit test table",
@@ -42,18 +48,20 @@ describe("QuickbaseClient - createTable (Unit)", () => {
       json: () => Promise.resolve(mockResponse),
     });
 
-    const response = await client.createTable({ appId, body: mockBody });
+    const response = await client.createTable({
+      appId: QB_APP_ID,
+      body: mockBody,
+    });
     expect(response).toEqual(mockResponse);
     expect(mockFetch).toHaveBeenCalledTimes(1);
     expect(mockFetch).toHaveBeenCalledWith(
-      `https://api.quickbase.com/v1/tables?appId=${appId}`,
+      `https://api.quickbase.com/v1/tables?appId=${QB_APP_ID}`,
       expect.objectContaining({
         method: "POST",
         headers: expect.objectContaining({
           "Content-Type": "application/json",
-          "QB-Realm-Hostname": "builderprogram-dbradford6815.quickbase.com",
-          Authorization:
-            "QB-USER-TOKEN b9f3pk_q4jd_0_b4qu5eebyvuix3xs57ysd7zn3",
+          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+          Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
         }),
         body: JSON.stringify(mockBody),
       })

package/tests/vitest/unit/tables/deleteTable.test.ts

@@ -1,7 +1,15 @@
-import { describe, it, expect, beforeEach, vi } from "vitest";
-import { createClient, mockFetch } from "@tests/setup.ts";
+// tests/vitest/unit/records/deleteTable.test.ts
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  createClient,
+  mockFetch,
+  QB_APP_ID,
+  QB_TABLE_ID_1,
+  QB_REALM,
+  QB_USER_TOKEN,
+} from "@tests/setup.ts";
 
-describe("QuickbaseClient - deleteTable (Unit)", () => {
+describe("QuickbaseClient Unit - deleteTable", () => {
   let client: ReturnType<typeof createClient>;
 
   beforeEach(() => {
@@ -10,10 +18,8 @@ describe("QuickbaseClient - deleteTable (Unit)", () => {
   });
 
   it("calls deleteTable successfully with user token", async () => {
-    const appId = "buwai2zpe";
-    const tableId = "buya8h9iz";
     const mockResponse = {
-      deletedTableId: tableId,
+      deletedTableId: QB_TABLE_ID_1,
     };
 
     mockFetch.mockResolvedValueOnce({
@@ -22,27 +28,26 @@ describe("QuickbaseClient - deleteTable (Unit)", () => {
       json: () => Promise.resolve(mockResponse),
     });
 
-    const response = await client.deleteTable({ tableId, appId });
+    const response = await client.deleteTable({
+      tableId: QB_TABLE_ID_1,
+      appId: QB_APP_ID,
+    });
     expect(response).toEqual(mockResponse);
     expect(mockFetch).toHaveBeenCalledTimes(1);
     expect(mockFetch).toHaveBeenCalledWith(
-      `https://api.quickbase.com/v1/tables/${tableId}?appId=${appId}`,
+      `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_1}?appId=${QB_APP_ID}`,
       expect.objectContaining({
         method: "DELETE",
         headers: expect.objectContaining({
           "Content-Type": "application/json",
-          "QB-Realm-Hostname": "builderprogram-dbradford6815.quickbase.com",
-          Authorization:
-            "QB-USER-TOKEN b9f3pk_q4jd_0_b4qu5eebyvuix3xs57ysd7zn3",
+          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+          Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
         }),
       })
     );
   });
 
   it("handles 404 error for non-existent table", async () => {
-    const appId = "buwai2zpe";
-    const tableId = "nonexistent";
-
     mockFetch.mockResolvedValueOnce({
       ok: false,
       status: 404,
@@ -53,15 +58,19 @@ describe("QuickbaseClient - deleteTable (Unit)", () => {
         }),
     });
 
-    await expect(client.deleteTable({ tableId, appId })).rejects.toThrow(
-      "API Error: Invalid DBID (Status: 404)"
-    );
+    await expect(
+      client.deleteTable({ tableId: QB_TABLE_ID_1, appId: QB_APP_ID })
+    ).rejects.toThrow("API Error: Invalid DBID (Status: 404)");
     expect(mockFetch).toHaveBeenCalledTimes(1);
     expect(mockFetch).toHaveBeenCalledWith(
-      `https://api.quickbase.com/v1/tables/${tableId}?appId=${appId}`,
+      `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_1}?appId=${QB_APP_ID}`,
       expect.objectContaining({
         method: "DELETE",
-        headers: expect.any(Object),
+        headers: expect.objectContaining({
+          "Content-Type": "application/json",
+          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+          Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
+        }),
       })
     );
   });

package/tests/vitest/unit/tables/getAppTables.test.ts

@@ -1,7 +1,21 @@
-import { describe, it, expect } from "vitest";
-import { createClient, mockFetch } from "@tests/setup.ts";
+// tests/vitest/unit/tables/getAppTables.test.ts
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  createClient,
+  mockFetch,
+  QB_APP_ID,
+  QB_REALM,
+  QB_USER_TOKEN,
+} from "@tests/setup.ts";
+
+describe("QuickbaseClient Unit - getAppTables", () => {
+  let client: ReturnType<typeof createClient>;
+
+  beforeEach(() => {
+    mockFetch.mockClear();
+    client = createClient(mockFetch, { debug: true }); // Add debug: true for consistency
+  });
 
-describe("QuickbaseClient - getAppTables (Unit)", () => {
   it("calls getAppTables successfully", async () => {
     mockFetch.mockImplementation((url: string, options: any) => {
       console.log("Mock fetch for getAppTables:", url, options);
@@ -11,60 +25,59 @@ describe("QuickbaseClient - getAppTables (Unit)", () => {
         json: () =>
           Promise.resolve([
             {
+              id: "buwai2zr4",
+              name: "Root",
               alias: "_DBID_ROOT",
-              created: "2025-02-13T18:22:33Z",
+              description: "",
+              created: new Date("2025-02-13T18:22:33.000Z"),
+              updated: new Date("2025-02-13T18:22:34.000Z"),
+              nextRecordId: 1,
+              nextFieldId: 6,
               defaultSortFieldId: 2,
               defaultSortOrder: "DESC",
-              description: "",
-              id: "buwai2zr4",
               keyFieldId: 3,
-              name: "Root",
-              nextFieldId: 6,
-              nextRecordId: 1,
-              pluralRecordName: "Roots",
               singleRecordName: "Root",
+              pluralRecordName: "Roots",
               sizeLimit: "500 MB",
-              spaceRemaining: "500 MB",
               spaceUsed: "0 KB",
-              updated: "2025-02-13T18:22:34Z",
+              spaceRemaining: "500 MB",
             },
           ]),
       } as Response);
     });
 
-    const client = createClient(mockFetch);
-    const tablesAppId = process.env.QB_APP_ID;
-    if (!tablesAppId) throw new Error("QB_APP_ID is not defined in .env");
-    const result = await client.getAppTables({ appId: tablesAppId });
+    const result = await client.getAppTables({ appId: QB_APP_ID });
     console.log("getAppTables response:", result);
     expect(result).toEqual(
       expect.arrayContaining([
         expect.objectContaining({
+          id: "buwai2zr4",
+          name: "Root",
           alias: "_DBID_ROOT",
-          created: new Date("2025-02-13T18:22:33Z"),
+          description: "",
+          created: new Date("2025-02-13T18:22:33.000Z"),
+          updated: new Date("2025-02-13T18:22:34.000Z"),
+          nextRecordId: 1,
+          nextFieldId: 6,
           defaultSortFieldId: 2,
           defaultSortOrder: "DESC",
-          description: "",
-          id: "buwai2zr4",
           keyFieldId: 3,
-          name: "Root",
-          nextFieldId: 6,
-          nextRecordId: 1,
-          pluralRecordName: "Roots",
           singleRecordName: "Root",
+          pluralRecordName: "Roots",
           sizeLimit: "500 MB",
-          spaceRemaining: "500 MB",
           spaceUsed: "0 KB",
-          updated: new Date("2025-02-13T18:22:34Z"),
+          spaceRemaining: "500 MB",
         }),
       ])
     );
     expect(mockFetch).toHaveBeenCalledWith(
-      `https://api.quickbase.com/v1/tables?appId=${tablesAppId}`,
+      `https://api.quickbase.com/v1/tables?appId=${QB_APP_ID}`,
       expect.objectContaining({
+        method: "GET",
         headers: expect.objectContaining({
-          Authorization: `QB-USER-TOKEN ${process.env.QB_USER_TOKEN}`,
-          "QB-Realm-Hostname": `${process.env.QB_REALM}.quickbase.com`,
+          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+          Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
+          "Content-Type": "application/json",
         }),
       })
     );

package/tests/vitest/unit/tables/getTable.test.ts

@@ -1,19 +1,26 @@
-import { describe, it, expect, beforeEach, vi } from "vitest";
-import { createClient, mockFetch } from "@tests/setup.ts";
-
-describe("QuickbaseClient - getTable (Unit)", () => {
+// tests/vitest/unit/tables/getTable.test.ts
+import { describe, it, expect, beforeEach } from "vitest";
+import {
+  createClient,
+  mockFetch,
+  QB_APP_ID,
+  QB_TABLE_ID_1,
+  QB_REALM,
+  QB_USER_TOKEN,
+} from "@tests/setup.ts";
+
+describe("QuickbaseClient Unit - getTable", () => {
   let client: ReturnType<typeof createClient>;
 
   beforeEach(() => {
     mockFetch.mockClear();
-    client = createClient(mockFetch, { debug: true });
   });
 
   it("calls getTable successfully with user token", async () => {
-    const mockAppId = "buwai2zpe";
-    const mockTableId = "buwai2zr4";
+    client = createClient(mockFetch, { debug: true });
+
     const mockResponse = {
-      id: mockTableId,
+      id: QB_TABLE_ID_1,
       name: "Root",
       alias: "_DBID_ROOT",
       description: "",
@@ -38,17 +45,17 @@ describe("QuickbaseClient - getTable (Unit)", () => {
     });
 
     const response = await client.getTable({
-      tableId: mockTableId,
-      appId: mockAppId,
+      tableId: QB_TABLE_ID_1,
+      appId: QB_APP_ID,
     });
     expect(response).toEqual(mockResponse);
     expect(mockFetch).toHaveBeenCalledWith(
-      `https://api.quickbase.com/v1/tables/${mockTableId}?appId=${mockAppId}`,
+      `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_1}?appId=${QB_APP_ID}`,
       expect.objectContaining({
         method: "GET",
         headers: expect.objectContaining({
-          Authorization:
-            "QB-USER-TOKEN b9f3pk_q4jd_0_b4qu5eebyvuix3xs57ysd7zn3",
+          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+          Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
         }),
       })
     );
@@ -56,10 +63,9 @@ describe("QuickbaseClient - getTable (Unit)", () => {
 
   it("calls getTable successfully with temp token", async () => {
     client = createClient(mockFetch, { debug: true, useTempTokens: true });
-    const mockAppId = "buwai2zpe";
-    const mockTableId = "buwai2zr4";
+
     const mockResponse = {
-      id: mockTableId,
+      id: QB_TABLE_ID_1,
       name: "Root",
       alias: "_DBID_ROOT",
       description: "",
@@ -90,19 +96,20 @@ describe("QuickbaseClient - getTable (Unit)", () => {
       });
 
     const response = await client.getTable({
-      tableId: mockTableId,
-      appId: mockAppId,
+      tableId: QB_TABLE_ID_1,
+      appId: QB_APP_ID,
     });
     expect(response).toEqual(mockResponse);
     expect(mockFetch).toHaveBeenCalledTimes(2);
     expect(mockFetch).toHaveBeenCalledWith(
-      `https://api.quickbase.com/v1/auth/temporary/${mockTableId}`,
+      `https://api.quickbase.com/v1/auth/temporary/${QB_TABLE_ID_1}`,
       expect.any(Object)
     );
     expect(mockFetch).toHaveBeenCalledWith(
-      `https://api.quickbase.com/v1/tables/${mockTableId}?appId=${mockAppId}`,
+      `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_1}?appId=${QB_APP_ID}`,
       expect.objectContaining({
         headers: expect.objectContaining({
+          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
           Authorization: "QB-TEMP-TOKEN temp_token",
         }),
       })
@@ -111,10 +118,9 @@ describe("QuickbaseClient - getTable (Unit)", () => {
 
   it("retries successfully after 401 with temp token", async () => {
     client = createClient(mockFetch, { debug: true, useTempTokens: true });
-    const mockAppId = "buwai2zpe";
-    const mockTableId = "buwai2zr4";
+
     const mockResponse = {
-      id: mockTableId,
+      id: QB_TABLE_ID_1,
       name: "Root",
       alias: "_DBID_ROOT",
       description: "",
@@ -156,17 +162,23 @@ describe("QuickbaseClient - getTable (Unit)", () => {
       });
 
     const response = await client.getTable({
-      tableId: mockTableId,
-      appId: mockAppId,
+      tableId: QB_TABLE_ID_1,
+      appId: QB_APP_ID,
     });
     expect(response).toEqual(mockResponse);
-    expect(mockFetch).toHaveBeenCalledTimes(4); // Initial token, 401, retry token, success
+    expect(mockFetch).toHaveBeenCalledTimes(4);
+    expect(mockFetch).toHaveBeenCalledWith(
+      `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_1}?appId=${QB_APP_ID}`,
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          Authorization: "QB-TEMP-TOKEN new_token",
+        }),
+      })
+    );
   });
 
   it("handles 401 with failed temp token retry", async () => {
     client = createClient(mockFetch, { debug: true, useTempTokens: true });
-    const mockAppId = "buwai2zpe";
-    const mockTableId = "buwai2zr4";
 
     mockFetch
       .mockResolvedValueOnce({
@@ -188,7 +200,7 @@ describe("QuickbaseClient - getTable (Unit)", () => {
       });
 
     await expect(
-      client.getTable({ tableId: mockTableId, appId: mockAppId })
+      client.getTable({ tableId: QB_TABLE_ID_1, appId: QB_APP_ID })
     ).rejects.toThrow(
       "API Error: Unauthorized in fetchTempToken (Status: 401)"
     );
@@ -196,8 +208,7 @@ describe("QuickbaseClient - getTable (Unit)", () => {
   });
 
   it("handles 404 Not Found", async () => {
-    const mockAppId = "buwai2zpe";
-    const mockTableId = "invalidTableId";
+    client = createClient(mockFetch, { debug: true });
 
     mockFetch.mockResolvedValueOnce({
       ok: false,
@@ -206,7 +217,17 @@ describe("QuickbaseClient - getTable (Unit)", () => {
     });
 
     await expect(
-      client.getTable({ tableId: mockTableId, appId: mockAppId })
+      client.getTable({ tableId: QB_TABLE_ID_1, appId: QB_APP_ID })
     ).rejects.toThrow("API Error: Table not found (Status: 404)");
+    expect(mockFetch).toHaveBeenCalledWith(
+      `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_1}?appId=${QB_APP_ID}`,
+      expect.objectContaining({
+        method: "GET",
+        headers: expect.objectContaining({
+          "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
+          Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
+        }),
+      })
+    );
   });
 });