webflow-api 1.2.1 → 1.3.0

package/tests/api/user.test.ts

@@ -0,0 +1,139 @@
+import MockAdapter from "axios-mock-adapter";
+import axios from "axios";
+import { UserFixture } from "../fixtures";
+import { User } from "../../src/api";
+
+describe("Users", () => {
+  const mock = new MockAdapter(axios);
+  const client = axios.create();
+
+  describe("Static Methods", () => {
+    it("should respond with a list of users", async () => {
+      const { response, parameters } = UserFixture.list;
+      const { siteId } = parameters;
+      const path = `/sites/${siteId}/users`;
+
+      mock.onGet(path).reply(200, response);
+      const { data } = await User.list(parameters, client);
+
+      expect(data).toBeDefined();
+      expect(data.users.length).toBe(response.users.length);
+      expect(data.users[0]).toMatchObject(response.users[0]);
+    });
+
+    it("should respond with a single user", async () => {
+      const { response, parameters } = UserFixture.getOne;
+      const { siteId, userId } = parameters;
+      const path = `/sites/${siteId}/users/${userId}`;
+
+      mock.onGet(path).reply(200, response);
+      const { data } = await User.getOne(parameters, client);
+
+      expect(data).toBeDefined();
+      expect(data._id).toBe(response._id);
+    });
+
+    it("should invite a user", async () => {
+      const { response, parameters } = UserFixture.invite;
+      const { siteId } = parameters;
+      const path = `/sites/${siteId}/users/invite`;
+
+      mock.onPost(path).reply(200, response);
+      const { data } = await User.invite(parameters, client);
+
+      expect(data).toBeDefined();
+      expect(data.data).toBeDefined();
+      expect(data._id).toBe(response._id);
+      expect(data.data).toMatchObject(response.data);
+    });
+
+    it("should update a user", async () => {
+      const { response, parameters } = UserFixture.update;
+      const { siteId, userId } = parameters;
+      const path = `/sites/${siteId}/users/${userId}`;
+
+      mock.onPatch(path).reply(200, response);
+      const { data } = await User.update(parameters, client);
+
+      expect(data).toBeDefined();
+      expect(data._id).toBe(response._id);
+      expect(data.data).toBeDefined();
+      expect(data.data).toMatchObject(response.data);
+    });
+
+    it("should remove a user", async () => {
+      const { response, parameters } = UserFixture.delete;
+      const { siteId, userId } = parameters;
+      const path = `/sites/${siteId}/users/${userId}`;
+
+      mock.onDelete(path).reply(200, response);
+      const { data } = await User.remove(parameters, client);
+
+      expect(data).toBeDefined();
+      expect(data.deleted).toBe(response.deleted);
+    });
+
+    it("should respond with a list of access groups", async () => {
+      const { response, parameters } = UserFixture.accessGroups;
+      const { siteId } = parameters;
+      const path = `/sites/${siteId}/accessgroups`;
+
+      mock.onGet(path).reply(200, response);
+      const { data } = await User.accessGroups(parameters, client);
+
+      expect(data).toBeDefined();
+      expect(data.accessGroups.length).toBe(response.accessGroups.length);
+      expect(data.accessGroups[0]).toMatchObject(response.accessGroups[0]);
+    });
+  });
+
+  describe("Instance Methods", () => {
+    const { parameters, response } = UserFixture.getOne;
+    const res = {
+      data: {},
+      status: 200,
+      statusText: "",
+      headers: {},
+      config: {},
+    };
+    const user = new User(client, res, response, { siteId: parameters.siteId });
+
+    it("should update a user", async () => {
+      const { response, parameters } = UserFixture.update;
+      const { siteId, userId, data } = parameters;
+
+      const path = `/sites/${siteId}/users/${userId}`;
+      mock.onPatch(path).reply(200, response);
+      const spy = jest.spyOn(User, "update");
+
+      const result = await user.update(data);
+
+      const _params = { data, siteId, userId };
+      expect(spy).toHaveBeenCalledWith(_params, client);
+
+      expect(result).toBeDefined();
+      expect(result._id).toBe(response._id);
+
+      expect(result.data).toBeDefined();
+
+      // user wrapper functions
+      expect(typeof result.update).toBe("function");
+      expect(typeof result.remove).toBe("function");
+    });
+
+    it("should remove a user", async () => {
+      const { response, parameters } = UserFixture.delete;
+      const { siteId, userId } = parameters;
+
+      const path = `/sites/${siteId}/users/${userId}`;
+      mock.onDelete(path).reply(200, response);
+      const spy = jest.spyOn(User, "remove");
+
+      const result = await user.remove();
+
+      expect(spy).toHaveBeenCalledWith({ siteId, userId }, client);
+
+      expect(result).toBeDefined();
+    });
+  });
+});

package/tests/api/webhook.test.ts

@@ -0,0 +1,82 @@
+import MockAdapter from "axios-mock-adapter";
+import axios from "axios";
+import { WebhookFixture } from "../fixtures";
+import { Webhook } from "../../src/api";
+
+describe("Webhooks", () => {
+  const mock = new MockAdapter(axios);
+  const client = axios.create();
+
+  describe("Static Methods", () => {
+    it("should respond with a list of webhooks", async () => {
+      const { parameters, response } = WebhookFixture.list;
+      const { siteId } = parameters;
+      const path = `/sites/${siteId}/webhooks`;
+
+      mock.onGet(path).reply(200, response);
+      const { data } = await Webhook.list(parameters, client);
+
+      expect(data).toBeDefined();
+      expect(data.length).toEqual(response.length);
+      expect(data[0]).toEqual(response[0]);
+    });
+
+    it("should respond with a single webhook", async () => {
+      const { parameters, response } = WebhookFixture.getOne;
+      const { siteId, webhookId } = parameters;
+
+      const path = `/sites/${siteId}/webhooks/${webhookId}`;
+      mock.onGet(path).reply(200, response);
+      const { data } = await Webhook.getOne(parameters, client);
+
+      expect(data).toBeDefined();
+      expect(data._id).toBe(response._id);
+    });
+
+    it("should create a webhook", async () => {
+      const { parameters, response } = WebhookFixture.create;
+      const { siteId } = parameters;
+
+      const path = `/sites/${siteId}/webhooks`;
+      mock.onPost(path).reply(200, response);
+      const { data } = await Webhook.create(parameters, client);
+
+      expect(data).toBeDefined();
+      expect(data._id).toBe(response._id);
+    });
+
+    it("should remove a webhook", async () => {
+      const { parameters, response } = WebhookFixture.delete;
+      const { siteId, webhookId } = parameters;
+
+      const path = `/sites/${siteId}/webhooks/${webhookId}`;
+      mock.onDelete(path).reply(200, response);
+      const { data } = await Webhook.remove(parameters, client);
+
+      expect(data).toBeDefined();
+      expect(data.deleted).toEqual(response.deleted);
+    });
+  });
+
+  describe("Instance Methods", () => {
+    const res = { data: {}, status: 200, statusText: "", headers: {}, config: {} };
+    const webhook = new Webhook(client, res, WebhookFixture.getOne.response);
+
+    it("should remove a webhook", async () => {
+      const { parameters, response } = WebhookFixture.delete;
+      const { siteId, webhookId } = parameters;
+
+      const path = `/sites/${siteId}/webhooks/${webhookId}`;
+      mock.onDelete(path).reply(200, response);
+      const spy = jest.spyOn(Webhook, "remove");
+
+      const result = await webhook.remove();
+
+      const _params = { siteId, webhookId, params: undefined };
+      expect(spy).toBeCalledWith(_params, client);
+
+      expect(result).toBeDefined();
+      expect(result.deleted).toBe(response.deleted);
+    });
+  });
+});

package/tests/core/error.test.ts

@@ -0,0 +1,19 @@
+import { ArgumentError, requireArgs } from "../../src/core/error";
+import MockAdapter from "axios-mock-adapter";
+import axios from "axios";
+
+describe("Error", () => {
+  const mock = new MockAdapter(axios);
+
+  it("should throw an ArgumentError", () => {
+    expect(() => {
+      throw new ArgumentError("name");
+    }).toThrow("Argument 'name' is required but was not present");
+  });
+
+  it("should throw an ArgumentError for required args", () => {
+    expect(() => {
+      requireArgs({ name: undefined });
+    }).toThrow("Argument 'name' is required but was not present");
+  });
+});

package/tests/core/response.test.ts

@@ -0,0 +1,36 @@
+import axios, { AxiosResponse } from "axios";
+import { WebflowRecord, MetaResponse } from "../../src/core/response";
+
+describe("Response", () => {
+  const client = axios.create();
+  const response: AxiosResponse = {
+    status: 200,
+    statusText: "OK",
+    headers: {
+      "x-ratelimit-limit": "100",
+      "x-ratelimit-remaining": "99",
+    },
+    config: {},
+    data: {},
+  };
+
+  it("should create a MetaResponse", () => {
+    const meta = new MetaResponse(response);
+    expect(meta.rateLimit.limit).toBe(100);
+    expect(meta.rateLimit.remaining).toBe(99);
+  });
+
+  it("should create a WebflowRecord", () => {
+    const record = new WebflowRecord(client, response, { id: "123" });
+
+    // confirm client
+    expect(record.client).toBe(client);
+
+    // confirm response
+    expect(record.response).toBe(response);
+
+    // confirm meta records
+    expect(record._meta.rateLimit.limit).toBe(100);
+    expect(record._meta.rateLimit.remaining).toBe(99);
+  });
+});