@zapier/zapier-sdk 0.13.6 → 0.13.8

package/src/plugins/listAuthentications/index.test.ts

@@ -1,739 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import {
-  ZapierValidationError,
-  ZapierAuthenticationError,
-} from "../../types/errors";
-import { listAuthenticationsPlugin } from "./index";
-import { createSdk } from "../../sdk";
-import type { ApiClient } from "../../api";
-
-const mockAuthenticationsResponse = {
-  results: [
-    {
-      id: 123,
-      date: "2021-01-01",
-      account_id: 456 as any,
-      selected_api: "SlackCLIAPI@1.21.1",
-      is_invite_only: false,
-      is_private: false,
-      shared_with_all: false,
-      is_stale: "false",
-      marked_stale_at: null,
-      label: "My Slack Workspace",
-      title: "My Slack Workspace",
-    },
-    {
-      id: 789,
-      date: "2021-02-01",
-      account_id: 456 as any,
-      selected_api: "GitHubAPI@2.1.0",
-      is_invite_only: false,
-      is_private: false,
-      shared_with_all: true,
-      is_stale: "true",
-      marked_stale_at: "2021-06-01",
-      label: "GitHub Integration",
-      title: "GitHub Integration",
-    },
-  ],
-  count: 2,
-  next: null,
-  previous: null,
-};
-
-describe("listAuthentications plugin", () => {
-  let mockApiClient: ApiClient;
-  let mockGetVersionedImplementationId: any;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockApiClient = {
-      get: vi.fn().mockResolvedValue(mockAuthenticationsResponse),
-    } as Partial<ApiClient> as ApiClient;
-
-    mockGetVersionedImplementationId = vi
-      .fn()
-      .mockResolvedValue("SlackCLIAPI@1.21.1");
-  });
-
-  const apiPlugin = () => ({
-    context: {
-      api: mockApiClient,
-    },
-  });
-
-  const mockResolveAppKeys = vi.fn().mockResolvedValue([]);
-
-  const manifestPlugin = () => ({
-    context: {
-      manifest: null,
-      getVersionedImplementationId: mockGetVersionedImplementationId,
-      resolveAppKeys: mockResolveAppKeys,
-      updateManifestEntry: vi
-        .fn()
-        .mockResolvedValue(["test-key", {}, { apps: {} }]),
-    },
-  });
-
-  function createTestSdk() {
-    return createSdk()
-      .addPlugin(apiPlugin)
-      .addPlugin(manifestPlugin)
-      .addPlugin(listAuthenticationsPlugin);
-  }
-
-  describe("schema validation", () => {
-    it("should pass validation with empty options", async () => {
-      const sdk = createTestSdk();
-      const result = await sdk.listAuthentications({});
-      expect(result.data).toHaveLength(2);
-    });
-
-    it("should handle undefined options", async () => {
-      const sdk = createTestSdk();
-      const result = await sdk.listAuthentications();
-      expect(result.data).toHaveLength(2);
-      expect(result.data[0]).toMatchObject({
-        id: 123,
-      });
-    });
-
-    it("should throw validation error for invalid appKey type", () => {
-      const sdk = createTestSdk();
-      expect(() => {
-        sdk.listAuthentications({
-          appKey: 123 as any,
-        });
-      }).toThrow(ZapierValidationError);
-    });
-
-    it("should throw validation error for invalid search type", () => {
-      const sdk = createTestSdk();
-      expect(() => {
-        sdk.listAuthentications({
-          search: 123 as any,
-        });
-      }).toThrow(ZapierValidationError);
-    });
-
-    it("should throw validation error for invalid title type", () => {
-      const sdk = createTestSdk();
-      expect(() => {
-        sdk.listAuthentications({
-          title: 123 as any,
-        });
-      }).toThrow(ZapierValidationError);
-    });
-
-    it("should throw validation error for invalid accountId type", () => {
-      const sdk = createTestSdk();
-      expect(() => {
-        sdk.listAuthentications({
-          accountId: 123 as any,
-        });
-      }).toThrow(ZapierValidationError);
-    });
-
-    it("should throw validation error for invalid owner type", () => {
-      const sdk = createTestSdk();
-      expect(() => {
-        sdk.listAuthentications({
-          owner: 123 as any,
-        });
-      }).toThrow(ZapierValidationError);
-    });
-
-    it("should throw validation error for invalid authenticationIds type", () => {
-      const sdk = createTestSdk();
-      expect(() => {
-        sdk.listAuthentications({
-          authenticationIds: "123" as any, // Should be array of strings
-        });
-      }).toThrow(ZapierValidationError);
-
-      expect(() => {
-        sdk.listAuthentications({
-          authenticationIds: [123] as any, // Should be array of strings, not numbers
-        });
-      }).toThrow(ZapierValidationError);
-    });
-
-    it("should throw validation error for invalid pageSize", () => {
-      const sdk = createTestSdk();
-      expect(() => {
-        sdk.listAuthentications({
-          pageSize: 0, // Should be >= 1
-        });
-      }).toThrow(ZapierValidationError);
-
-      expect(() => {
-        sdk.listAuthentications({
-          pageSize: -5, // Should be >= 1
-        });
-      }).toThrow(ZapierValidationError);
-    });
-
-    it("should throw validation error for invalid maxItems", () => {
-      const sdk = createTestSdk();
-      expect(() => {
-        sdk.listAuthentications({
-          maxItems: 0 as any, // Should be >= 1
-        });
-      }).toThrow(ZapierValidationError);
-
-      expect(() => {
-        sdk.listAuthentications({
-          maxItems: -10 as any, // Should be >= 1
-        });
-      }).toThrow(ZapierValidationError);
-    });
-
-    it("should pass validation with all valid fields", async () => {
-      const sdk = createTestSdk();
-      const result = await sdk.listAuthentications({
-        appKey: "slack",
-        authenticationIds: ["123", "456"],
-        search: "workspace",
-        title: "My Slack Workspace",
-        accountId: "acc_123",
-        owner: "me",
-        pageSize: 10,
-        maxItems: 50,
-      });
-
-      expect(result.data).toBeDefined();
-    });
-  });
-
-  describe("data mapping", () => {
-    it("should map is_stale to is_expired and marked_stale_at to expired_at", async () => {
-      const sdk = createTestSdk();
-      const result = await sdk.listAuthentications();
-
-      expect(result.data[0].is_expired).toBe("false");
-      expect(result.data[0].expired_at).toBe(null);
-      expect(result.data[1].is_expired).toBe("true");
-      expect(result.data[1].expired_at).toBe("2021-06-01");
-    });
-
-    it("should coerce title from label when title is missing", async () => {
-      const responseWithoutTitle = {
-        ...mockAuthenticationsResponse,
-        results: [
-          {
-            ...mockAuthenticationsResponse.results[0],
-            title: undefined,
-            label: "Label Only Auth",
-          },
-        ],
-      };
-
-      mockApiClient.get = vi.fn().mockResolvedValue(responseWithoutTitle);
-
-      const sdk = createTestSdk();
-      const result = await sdk.listAuthentications({});
-
-      expect(result.data[0].title).toBe("Label Only Auth");
-    });
-
-    it("should handle authentications with neither title nor label", async () => {
-      const responseWithoutTitleOrLabel = {
-        ...mockAuthenticationsResponse,
-        results: [
-          {
-            ...mockAuthenticationsResponse.results[0],
-            title: undefined,
-            label: undefined,
-          },
-        ],
-      };
-
-      mockApiClient.get = vi
-        .fn()
-        .mockResolvedValue(responseWithoutTitleOrLabel);
-
-      const sdk = createTestSdk();
-      const result = await sdk.listAuthentications({});
-
-      expect(result.data[0].title).toBeUndefined();
-    });
-  });
-
-  describe("filtering", () => {
-    it("should filter by exact title match", async () => {
-      const sdk = createTestSdk();
-      const result = await sdk.listAuthentications({
-        title: "My Slack Workspace",
-      });
-
-      // Should filter to exact match
-      expect(result.data).toHaveLength(1);
-      expect(result.data[0].title).toBe("My Slack Workspace");
-    });
-
-    it("should use search parameter when provided", async () => {
-      const sdk = createTestSdk();
-      await sdk.listAuthentications({ search: "workspace" });
-
-      expect(mockApiClient.get).toHaveBeenCalledWith(
-        "/api/v4/authentications/",
-        expect.objectContaining({
-          searchParams: expect.objectContaining({
-            search: "workspace",
-          }),
-        }),
-      );
-    });
-
-    it("should use title as search when search not provided", async () => {
-      const sdk = createTestSdk();
-      await sdk.listAuthentications({ title: "My Slack Workspace" });
-
-      expect(mockApiClient.get).toHaveBeenCalledWith(
-        "/api/v4/authentications/",
-        expect.objectContaining({
-          searchParams: expect.objectContaining({
-            search: "My Slack Workspace",
-          }),
-        }),
-      );
-    });
-
-    it("should prefer search over title when both provided", async () => {
-      const sdk = createTestSdk();
-      await sdk.listAuthentications({
-        search: "explicit search",
-        title: "My Title",
-      });
-
-      expect(mockApiClient.get).toHaveBeenCalledWith(
-        "/api/v4/authentications/",
-        expect.objectContaining({
-          searchParams: expect.objectContaining({
-            search: "explicit search",
-          }),
-        }),
-      );
-    });
-
-    it("should pass accountId filter to API", async () => {
-      const sdk = createTestSdk();
-      await sdk.listAuthentications({ accountId: "acc_123" });
-
-      expect(mockApiClient.get).toHaveBeenCalledWith(
-        "/api/v4/authentications/",
-        expect.objectContaining({
-          searchParams: expect.objectContaining({
-            account_id: "acc_123",
-          }),
-        }),
-      );
-    });
-
-    it("should pass owner filter to API", async () => {
-      const sdk = createTestSdk();
-      await sdk.listAuthentications({ owner: "me" });
-
-      expect(mockApiClient.get).toHaveBeenCalledWith(
-        "/api/v4/authentications/",
-        expect.objectContaining({
-          searchParams: expect.objectContaining({
-            owner: "me",
-          }),
-        }),
-      );
-    });
-
-    it("should pass authenticationIds as ids parameter to API", async () => {
-      const sdk = createTestSdk();
-      await sdk.listAuthentications({
-        authenticationIds: ["123", "456", "789"],
-      });
-
-      expect(mockApiClient.get).toHaveBeenCalledWith(
-        "/api/v4/authentications/",
-        expect.objectContaining({
-          searchParams: expect.objectContaining({
-            ids: "123,456,789",
-          }),
-        }),
-      );
-    });
-
-    it("should not include ids parameter when authenticationIds is empty", async () => {
-      const sdk = createTestSdk();
-      await sdk.listAuthentications({
-        authenticationIds: [],
-      });
-
-      expect(mockApiClient.get).toHaveBeenCalledWith(
-        "/api/v4/authentications/",
-        expect.objectContaining({
-          searchParams: expect.not.objectContaining({
-            ids: expect.anything(),
-          }),
-        }),
-      );
-    });
-  });
-
-  describe("pagination", () => {
-    it("should handle pagination with maxItems by collecting all items", async () => {
-      // Mock multiple pages - first page has 2 items, second page has 1 item
-      mockApiClient.get = vi
-        .fn()
-        .mockResolvedValueOnce({
-          results: mockAuthenticationsResponse.results,
-          count: 3,
-          next: "http://example.com/api/v4/authentications/?offset=2",
-        })
-        .mockResolvedValueOnce({
-          results: [
-            {
-              id: 999,
-              date: "2021-03-01",
-              account_id: 456 as any,
-              selected_api: "DropboxAPI@3.0.0",
-              is_invite_only: false,
-              is_private: false,
-              shared_with_all: false,
-              is_stale: "false",
-              marked_stale_at: null,
-              title: "Dropbox Integration",
-            },
-          ],
-          count: 3,
-          next: null,
-        });
-
-      const sdk = createTestSdk();
-      // Collect all items using the items() iterator
-      const items = [];
-      for await (const item of sdk
-        .listAuthentications({ maxItems: 3 })
-        .items()) {
-        items.push(item);
-      }
-
-      expect(items).toHaveLength(3); // Should stop at maxItems
-      expect(mockApiClient.get).toHaveBeenCalledTimes(2); // Should fetch both pages
-    });
-
-    it("should return first page when awaited", async () => {
-      mockApiClient.get = vi.fn().mockResolvedValue({
-        results: mockAuthenticationsResponse.results,
-        count: 2,
-        next: null, // No more pages to prevent automatic fetching
-      });
-
-      const sdk = createTestSdk();
-      const result = await sdk.listAuthentications({});
-
-      // Await returns first page only
-      expect(result.data).toHaveLength(2);
-      expect(mockApiClient.get).toHaveBeenCalledTimes(1);
-    });
-
-    it("should support async iteration over pages", async () => {
-      mockApiClient.get = vi
-        .fn()
-        .mockResolvedValueOnce({
-          results: mockAuthenticationsResponse.results.slice(0, 1),
-          count: 2,
-          next: "http://example.com/api/v4/authentications/?offset=1",
-        })
-        .mockResolvedValueOnce({
-          results: mockAuthenticationsResponse.results.slice(1, 2),
-          count: 2,
-          next: null,
-        });
-
-      const sdk = createTestSdk();
-      const pages = [];
-      for await (const page of sdk.listAuthentications({ pageSize: 1 })) {
-        pages.push(page);
-        if (pages.length >= 2) break;
-      }
-
-      expect(pages).toHaveLength(2);
-      expect(pages[0].data).toHaveLength(1);
-      expect(pages[1].data).toHaveLength(1);
-      expect(pages[0].data[0].id).toBe(123);
-      expect(pages[1].data[0].id).toBe(789);
-    });
-
-    it("should support async iteration over individual items", async () => {
-      const sdk = createTestSdk();
-      const items = [];
-      for await (const item of sdk
-        .listAuthentications({ maxItems: 2 })
-        .items()) {
-        items.push(item);
-      }
-
-      expect(items).toHaveLength(2);
-      expect(items[0].id).toBe(123);
-      expect(items[1].id).toBe(789);
-    });
-
-    it("should set appropriate pageSize for API calls", async () => {
-      const sdk = createTestSdk();
-      await sdk.listAuthentications({ pageSize: 1 });
-
-      expect(mockApiClient.get).toHaveBeenCalledWith(
-        "/api/v4/authentications/",
-        expect.objectContaining({
-          searchParams: expect.objectContaining({
-            limit: "1",
-          }),
-        }),
-      );
-    });
-  });
-
-  describe("API integration", () => {
-    it("should call the correct API endpoint", async () => {
-      const sdk = createTestSdk();
-      await sdk.listAuthentications({});
-
-      expect(mockApiClient.get).toHaveBeenCalledWith(
-        "/api/v4/authentications/",
-        expect.any(Object),
-      );
-    });
-
-    it("should pass pageSize as limit parameter", async () => {
-      const sdk = createTestSdk();
-      await sdk.listAuthentications({ pageSize: 25 });
-
-      expect(mockApiClient.get).toHaveBeenCalledWith(
-        "/api/v4/authentications/",
-        expect.objectContaining({
-          searchParams: expect.objectContaining({
-            limit: "25",
-          }),
-        }),
-      );
-    });
-
-    it("should handle cursor-based pagination internally", async () => {
-      mockApiClient.get = vi
-        .fn()
-        .mockResolvedValueOnce({
-          results: mockAuthenticationsResponse.results.slice(0, 1),
-          count: 2,
-          next: "http://example.com/api/v4/authentications/?offset=1",
-        })
-        .mockResolvedValueOnce({
-          results: mockAuthenticationsResponse.results.slice(1, 2),
-          count: 2,
-          next: null,
-        });
-
-      const sdk = createTestSdk();
-      // Test that the function can handle multiple pages
-      let pageCount = 0;
-      for await (const _page of sdk.listAuthentications({ pageSize: 1 })) {
-        pageCount++;
-        if (pageCount >= 2) break;
-      }
-
-      expect(pageCount).toBe(2);
-      expect(mockApiClient.get).toHaveBeenCalledTimes(2);
-      // The second call should include the offset from the cursor
-      expect(mockApiClient.get).toHaveBeenNthCalledWith(
-        2,
-        "/api/v4/authentications/",
-        expect.objectContaining({
-          searchParams: expect.objectContaining({
-            offset: "1",
-          }),
-        }),
-      );
-    });
-  });
-
-  describe("error handling", () => {
-    it("should throw ZapierAuthenticationError for 401 responses", async () => {
-      const customErrorHandler = vi
-        .fn()
-        .mockReturnValue(
-          new ZapierAuthenticationError(
-            "Authentication failed. Your token may not have permission to access authentications or may be expired. (HTTP 401)",
-            { statusCode: 401 },
-          ),
-        );
-
-      mockApiClient.get = vi.fn().mockImplementation(() => {
-        const error = customErrorHandler({ status: 401 });
-        throw error;
-      });
-
-      const sdk = createTestSdk();
-      await expect(sdk.listAuthentications({})).rejects.toThrow(
-        ZapierAuthenticationError,
-      );
-    });
-
-    it("should throw ZapierAuthenticationError for 403 responses", async () => {
-      const customErrorHandler = vi
-        .fn()
-        .mockReturnValue(
-          new ZapierAuthenticationError(
-            "Access forbidden. Your token may not have the required scopes to list authentications. (HTTP 403)",
-            { statusCode: 403 },
-          ),
-        );
-
-      mockApiClient.get = vi.fn().mockImplementation(() => {
-        const error = customErrorHandler({ status: 403 });
-        throw error;
-      });
-
-      const sdk = createTestSdk();
-      await expect(sdk.listAuthentications({})).rejects.toThrow(
-        ZapierAuthenticationError,
-      );
-    });
-
-    it("should handle empty results", async () => {
-      const emptyResponse = {
-        results: [],
-        count: 0,
-        next: null,
-      };
-
-      mockApiClient.get = vi.fn().mockResolvedValue(emptyResponse);
-
-      const sdk = createTestSdk();
-      const result = await sdk.listAuthentications({});
-
-      expect(result.data).toHaveLength(0);
-      expect(Array.isArray(result.data)).toBe(true);
-    });
-
-    it("should handle missing results field", async () => {
-      const responseWithoutResults = {
-        count: 0,
-        next: null,
-      };
-
-      mockApiClient.get = vi.fn().mockResolvedValue(responseWithoutResults);
-
-      const sdk = createTestSdk();
-      const result = await sdk.listAuthentications({});
-
-      expect(result.data).toHaveLength(0);
-      expect(Array.isArray(result.data)).toBe(true);
-    });
-  });
-
-  describe("app key integration", () => {
-    it("should handle app without current_implementation_id", async () => {
-      mockGetVersionedImplementationId.mockResolvedValue(null);
-
-      const sdk = createTestSdk();
-      await sdk.listAuthentications({ appKey: "slack" });
-
-      // Should not add versionless_selected_api parameter
-      expect(mockApiClient.get).toHaveBeenCalledWith(
-        "/api/v4/authentications/",
-        expect.objectContaining({
-          searchParams: expect.not.objectContaining({
-            versionless_selected_api: expect.any(String),
-          }),
-        }),
-      );
-    });
-
-    it("should extract versionless API from versioned implementation ID", async () => {
-      mockGetVersionedImplementationId.mockResolvedValue("SlackCLIAPI@2.1.3");
-
-      const sdk = createTestSdk();
-      await sdk.listAuthentications({ appKey: "slack" });
-
-      expect(mockApiClient.get).toHaveBeenCalledWith(
-        "/api/v4/authentications/",
-        expect.objectContaining({
-          searchParams: expect.objectContaining({
-            versionless_selected_api: "SlackCLIAPI",
-          }),
-        }),
-      );
-    });
-  });
-
-  describe("response transformation", () => {
-    it("should preserve all original authentication fields", async () => {
-      const authWithAllFields = {
-        results: [
-          {
-            id: 123,
-            date: "2021-01-01",
-            lastchanged: "2021-01-02",
-            account_id: 456 as any,
-            customuser_id: 789,
-            selected_api: "SlackCLIAPI@1.21.1",
-            destination_selected_api: "SlackDestAPI@1.0.0",
-            is_invite_only: true,
-            is_private: true,
-            shared_with_all: false,
-            is_stale: "true",
-            is_shared: "false",
-            marked_stale_at: "2021-06-01",
-            label: "Auth Label",
-            title: "Auth Title",
-            identifier: "auth-identifier",
-            url: "https://example.com",
-            groups: "group1,group2",
-            members: "user1,user2",
-            permissions: { read: true, write: false },
-          },
-        ],
-        count: 1,
-      };
-
-      mockApiClient.get = vi.fn().mockResolvedValue(authWithAllFields);
-
-      const sdk = createTestSdk();
-      const result = await sdk.listAuthentications({});
-      const auth = result.data[0];
-
-      // Verify original fields are preserved
-      expect(auth.id).toBe(123);
-      expect(auth.date).toBe("2021-01-01");
-      expect(auth.lastchanged).toBe("2021-01-02");
-      expect(auth.account_id).toBe(456);
-      expect(auth.user_id).toBe(789);
-      expect(auth.implementation_id).toBe("SlackCLIAPI@1.21.1");
-      expect(auth.destination_selected_api).toBe("SlackDestAPI@1.0.0");
-      expect(auth.is_invite_only).toBe(true);
-      expect(auth.is_private).toBe(true);
-      expect(auth.shared_with_all).toBe(false);
-      expect(auth.is_shared).toBe("false");
-      expect(auth.label).toBe("Auth Label");
-      expect(auth.title).toBe("Auth Title");
-      expect(auth.identifier).toBe("auth-identifier");
-      expect(auth.url).toBe("https://example.com");
-      expect(auth.groups).toBe("group1,group2");
-      expect(auth.members).toBe("user1,user2");
-      expect(auth.permissions).toEqual({ read: true, write: false });
-
-      // Verify mapped fields
-      expect(auth.is_expired).toBe("true");
-      expect(auth.expired_at).toBe("2021-06-01");
-    });
-  });
-
-  describe("context and metadata", () => {
-    it("should provide context with meta information", () => {
-      const sdk = createTestSdk();
-      const context = sdk.getContext();
-
-      expect((context.meta as any).listAuthentications).toBeDefined();
-      expect(
-        (context.meta as any).listAuthentications.inputSchema,
-      ).toBeDefined();
-    });
-  });
-});