@zapier/zapier-sdk 0.4.1 → 0.5.0

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

@@ -0,0 +1,709 @@
+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";
+import type { App } from "../../api/types";
+
+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,
+};
+
+const mockSlackApp = {
+  data: {
+    id: 1,
+    key: "slack",
+    title: "Slack",
+    hex_color: "#000000",
+    age_in_days: "100",
+    api_docs_url: "https://slack.com/api-docs",
+    app_profile_url: "https://slack.com",
+    banner: "https://slack.com/banner.png",
+    categories: [],
+    canonical_id: "slack",
+    zap_usage_count: 100,
+    zap_usage_count_last_updated: "2021-01-01",
+    zap_usage_count_last_updated_by: "user1",
+    zap_usage_count_last_updated_by_id: 123,
+    current_implementation_id: "SlackCLIAPI@1.21.1",
+  } as Partial<App> as App,
+};
+
+describe("listAuthentications plugin", () => {
+  let mockApiClient: ApiClient;
+  let mockGetApp: any;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockApiClient = {
+      get: vi.fn().mockResolvedValue(mockAuthenticationsResponse),
+    } as Partial<ApiClient> as ApiClient;
+
+    mockGetApp = vi.fn().mockResolvedValue(mockSlackApp);
+  });
+
+  function createTestSdk() {
+    return createSdk(
+      { getApp: mockGetApp }, // Provide getApp in SDK
+      { api: mockApiClient, meta: {} },
+    ).addPlugin(listAuthenticationsPlugin as any);
+  }
+
+  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 account_id type", () => {
+      const sdk = createTestSdk();
+      expect(() => {
+        sdk.listAuthentications({
+          account_id: 123,
+        });
+      }).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 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",
+        search: "workspace",
+        title: "My Slack Workspace",
+        account_id: "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 account_id filter to API", async () => {
+      const sdk = createTestSdk();
+      await sdk.listAuthentications({ account_id: "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",
+          }),
+        }),
+      );
+    });
+  });
+
+  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 () => {
+      const appWithoutImplementation = {
+        data: {
+          id: 123,
+          key: "slack",
+          title: "Slack",
+          current_implementation_id: undefined,
+        } as Partial<App> as App,
+      };
+
+      mockGetApp.mockResolvedValue(appWithoutImplementation);
+
+      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 () => {
+      const appWithVersionedApi = {
+        data: {
+          id: 123,
+          key: "slack",
+          title: "Slack",
+          current_implementation_id: "SlackCLIAPI@2.1.3",
+        } as Partial<App> as App,
+      };
+
+      mockGetApp.mockResolvedValue(appWithVersionedApi);
+
+      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();
+    });
+  });
+});