webflow-api 1.2.2 → 1.3.0

package/tests/api/collection.test.ts

@@ -0,0 +1,147 @@
+import MockAdapter from "axios-mock-adapter";
+import axios from "axios";
+import { ItemFixture, CollectionFixture } from "../fixtures";
+import { Collection, Item } from "../../src/api";
+
+describe("Collection", () => {
+  const mock = new MockAdapter(axios);
+  const client = axios.create();
+
+  describe("Static Methods", () => {
+    it("should respond with a list of site collections", async () => {
+      const { parameters, response } = CollectionFixture.list;
+      const { siteId } = parameters;
+      const path = `/sites/${siteId}/collections`;
+
+      mock.onGet(path).reply(200, response);
+      const { data } = await Collection.list(parameters, client);
+
+      expect(data).toBeDefined();
+      expect(data.length).toBe(response.length);
+      expect(data[0]).toMatchObject(response[0]);
+    });
+
+    it("should respond with a single site collection", async () => {
+      const { parameters, response } = CollectionFixture.getOne;
+      const { collectionId } = parameters;
+      const path = `/collections/${collectionId}`;
+
+      mock.onGet(path).reply(200, response);
+      const { data } = await Collection.getOne(parameters, client);
+
+      expect(data).toBeDefined();
+      expect(data._id).toBe(response._id);
+    });
+  });
+
+  describe("Instance Methods", () => {
+    const res = { data: {}, status: 200, statusText: "", headers: {}, config: {} };
+    const collection = new Collection(client, res, CollectionFixture.getOne.response);
+
+    it("should respond with a list of items", async () => {
+      const { parameters, response } = ItemFixture.list;
+      const { collectionId } = parameters;
+
+      const path = `/collections/${collectionId}/items`;
+      mock.onGet(path).reply(200, response);
+      const spy = jest.spyOn(Item, "list");
+
+      const result = await collection.items();
+
+      const _params = { params: undefined, collectionId };
+      expect(spy).toBeCalledWith(_params, client);
+
+      expect(result).toBeDefined();
+      expect(result.length).toBe(response.items.length);
+
+      expect(result[0]._id).toBe(response.items[0]._id);
+
+      // item wrapper functions
+      expect(typeof result[0].update).toBe("function");
+      expect(typeof result[0].remove).toBe("function");
+    });
+
+    it("should respond with a single item", async () => {
+      const { parameters, response } = ItemFixture.getOne;
+      const { collectionId, itemId } = parameters;
+
+      const path = `/collections/${collectionId}/items/${itemId}`;
+      mock.onGet(path).reply(200, response);
+      const spy = jest.spyOn(Item, "getOne");
+
+      const result = await collection.item({ itemId });
+
+      const _params = { params: undefined, collectionId, itemId };
+      expect(spy).toBeCalledWith(_params, client);
+
+      expect(result).toBeDefined();
+      expect(result._id).toBe(response.items[0]._id);
+
+      // item wrapper functions
+      expect(typeof result.update).toBe("function");
+      expect(typeof result.remove).toBe("function");
+    });
+
+    it("should create an item", async () => {
+      const { parameters, response } = ItemFixture.create;
+      const { collectionId, fields } = parameters;
+
+      const path = `/collections/${collectionId}/items`;
+      mock.onPost(path).reply(200, response);
+      const spy = jest.spyOn(Item, "create");
+
+      const result = await collection.createItem(fields);
+
+      const _params = { params: undefined, collectionId, fields };
+      expect(spy).toBeCalledWith(_params, client);
+
+      expect(result).toBeDefined();
+      expect(result._id).toBe(response._id);
+
+      // item wrapper functions
+      expect(typeof result.update).toBe("function");
+      expect(typeof result.remove).toBe("function");
+    });
+
+    it("should update an item", async () => {
+      const { parameters, response } = ItemFixture.update;
+      const { collectionId, itemId, fields } = parameters;
+
+      const path = `/collections/${collectionId}/items/${itemId}`;
+      mock.onPut(path).reply(200, response);
+      const spy = jest.spyOn(Item, "update");
+
+      const result = await collection.updateItem({
+        itemId,
+        fields,
+      });
+
+      const _params = { params: undefined, collectionId, itemId, fields };
+      expect(spy).toBeCalledWith(_params, client);
+
+      expect(result).toBeDefined();
+      expect(result._id).toBe(response._id);
+
+      // item wrapper functions
+      expect(typeof result.update).toBe("function");
+      expect(typeof result.remove).toBe("function");
+    });
+
+    it("should remove an item", async () => {
+      const { parameters, response } = ItemFixture.remove;
+      const { collectionId, itemId } = parameters;
+
+      const path = `/collections/${collectionId}/items/${itemId}`;
+      mock.onDelete(path).reply(200, response);
+      const spy = jest.spyOn(Item, "remove");
+
+      const result = await collection.removeItem({ itemId });
+
+      const _params = { params: undefined, collectionId, itemId };
+      expect(spy).toBeCalledWith(_params, client);
+
+      expect(result).toBeDefined();
+      expect(result.deleted).toBe(response.deleted);
+    });
+  });
+});

package/tests/api/item.test.ts

@@ -0,0 +1,180 @@
+import MockAdapter from "axios-mock-adapter";
+import axios from "axios";
+import { ItemFixture } from "../fixtures";
+import { Item } from "../../src/api";
+
+describe("Items", () => {
+  const mock = new MockAdapter(axios);
+  const client = axios.create();
+
+  describe("Static Methods", () => {
+    it("should respond with a list of items", async () => {
+      const { parameters, response } = ItemFixture.list;
+      const { collectionId } = parameters;
+      const path = `/collections/${collectionId}/items`;
+
+      mock.onGet(path).reply(200, response);
+      const { data } = await Item.list(parameters, client);
+
+      expect(data).toBeDefined();
+      expect(data.items.length).toBe(response.items.length);
+      expect(data.items[0]).toMatchObject(response.items[0]);
+    });
+
+    it("should respond with a single item", async () => {
+      const { parameters, response } = ItemFixture.getOne;
+      const { collectionId, itemId } = parameters;
+      const path = `/collections/${collectionId}/items/${itemId}`;
+
+      mock.onGet(path).reply(200, response);
+      const { data } = await Item.getOne(parameters, client);
+
+      expect(data).toBeDefined();
+      expect(data.items[0]._id).toBe(response.items[0]._id);
+    });
+
+    it("should create an item", async () => {
+      const { parameters, response } = ItemFixture.create;
+      const { collectionId } = parameters;
+
+      const path = `/collections/${collectionId}/items`;
+
+      mock.onPost(path).reply(200, response);
+      const { data } = await Item.create(parameters, client);
+
+      expect(data).toBeDefined();
+      expect(data._id).toBe(response._id);
+    });
+
+    it("should update an item", async () => {
+      const { parameters, response } = ItemFixture.update;
+      const { collectionId, itemId } = parameters;
+      const path = `/collections/${collectionId}/items/${itemId}`;
+
+      mock.onPut(path).reply(200, response);
+      const { data } = await Item.update(parameters, client);
+
+      expect(data).toBeDefined();
+      expect(data._id).toBe(response._id);
+    });
+
+    it("should patch an item", async () => {
+      const { parameters, response } = ItemFixture.update;
+      const { collectionId, itemId } = parameters;
+      const path = `/collections/${collectionId}/items/${itemId}`;
+
+      mock.onPatch(path).reply(200, response);
+      const { data } = await Item.patch(parameters, client);
+
+      expect(data).toBeDefined();
+      expect(data._id).toBe(response._id);
+    });
+
+    it("should remove an item", async () => {
+      const { parameters, response } = ItemFixture.remove;
+      const { collectionId, itemId } = parameters;
+      const path = `/collections/${collectionId}/items/${itemId}`;
+
+      mock.onDelete(path).reply(200, response);
+      const { data } = await Item.remove(parameters, client);
+
+      expect(data).toBeDefined();
+      expect(data.deleted).toBe(response.deleted);
+    });
+
+    it("should unpublish multiple items", async () => {
+      const { parameters, response } = ItemFixture.unpublish;
+      const { collectionId, itemIds } = parameters;
+      const path = `/collections/${collectionId}/items`;
+
+      mock.onDelete(path).reply(200, response);
+      const { data } = await Item.unpublish(parameters, client);
+
+      expect(data).toBeDefined();
+      expect(data.deletedItemIds.length).toBe(itemIds.length);
+      expect(data.deletedItemIds[0]).toBe(itemIds[0]);
+    });
+
+    it("should live unpublish multiple items", async () => {
+      const { parameters, response } = ItemFixture.unpublish;
+      const { collectionId, itemIds } = parameters;
+      const path = `/collections/${collectionId}/items?live=true`;
+
+      mock.onDelete(path).reply(200, response);
+      const { data } = await Item.unpublish(parameters, client);
+
+      expect(data).toBeDefined();
+      expect(data.deletedItemIds.length).toBe(itemIds.length);
+      expect(data.deletedItemIds[0]).toBe(itemIds[0]);
+    });
+
+    it("should publish multiple items", async () => {
+      const { parameters, response } = ItemFixture.publish;
+      const { collectionId, itemIds } = parameters;
+      const path = `/collections/${collectionId}/items/publish`;
+
+      mock.onPut(path).reply(200, response);
+      const { data } = await Item.publish(parameters, client);
+
+      expect(data).toBeDefined();
+      expect(data.publishedItemIds.length).toBe(itemIds.length);
+      expect(data.publishedItemIds[0]).toBe(itemIds[0]);
+    });
+
+    it("should live publish multiple items", async () => {
+      const { parameters, response } = ItemFixture.publish;
+      const { collectionId, itemIds } = parameters;
+      const path = `/collections/${collectionId}/items/publish?live=true`;
+
+      mock.onPut(path).reply(200, response);
+      const { data } = await Item.publish(parameters, client);
+
+      expect(data).toBeDefined();
+      expect(data.publishedItemIds.length).toBe(itemIds.length);
+      expect(data.publishedItemIds[0]).toBe(itemIds[0]);
+    });
+  });
+
+  describe("Instance Methods", () => {
+    const res = { data: {}, status: 200, statusText: "", headers: {}, config: {} };
+    const item = new Item(client, res, ItemFixture.getOne.response.items[0]);
+
+    it("should update an item", async () => {
+      const { parameters, response } = ItemFixture.update;
+      const { collectionId, itemId, fields } = parameters;
+
+      const path = `/collections/${collectionId}/items/${itemId}`;
+      mock.onPut(path).reply(200, response);
+      const spy = jest.spyOn(Item, "update");
+
+      const result = await item.update(fields);
+
+      const _params = { params: undefined, collectionId, itemId, fields };
+      expect(spy).toBeCalledWith(_params, client);
+
+      expect(result).toBeDefined();
+      expect(result._id).toBe(response._id);
+
+      // item wrapper functions
+      expect(typeof result.update).toBe("function");
+      expect(typeof result.remove).toBe("function");
+    });
+
+    it("should remove an item", async () => {
+      const { parameters, response } = ItemFixture.remove;
+      const { collectionId, itemId } = parameters;
+
+      const path = `/collections/${collectionId}/items/${itemId}`;
+      mock.onDelete(path).reply(200, response);
+      const spy = jest.spyOn(Item, "remove");
+
+      const result = await item.remove();
+
+      const _params = { params: undefined, collectionId, itemId };
+      expect(spy).toBeCalledWith(_params, client);
+
+      expect(result).toBeDefined();
+      expect(result.deleted).toBe(response.deleted);
+    });
+  });
+});

package/tests/api/meta.test.ts

@@ -0,0 +1,38 @@
+import MockAdapter from "axios-mock-adapter";
+import axios from "axios";
+import { MetaFixture } from "../fixtures";
+import { Meta } from "../../src/api";
+
+describe("Meta", () => {
+  const mock = new MockAdapter(axios);
+  const client = axios.create();
+
+  it("should get info", async () => {
+    const { response } = MetaFixture.info;
+    const path = `/info`;
+
+    mock.onGet(path).reply(200, response);
+    const { data } = await Meta.info(client);
+
+    expect(data).toBeDefined();
+    expect(data.users).toEqual(response.users);
+    expect(data.sites).toEqual(response.sites);
+    expect(data.workspaces).toEqual(response.workspaces);
+    expect(data.application).toEqual(response.application);
+  });
+
+  it("should get info about the user", async () => {
+    const { response } = MetaFixture.installer;
+
+    const path = `/user`;
+    mock.onGet(path).reply(200, response);
+    const { data } = await Meta.user(client);
+
+    expect(data).toBeDefined();
+    expect(data.user).toBeDefined();
+    expect(data.user._id).toEqual(response.user._id);
+    expect(data.user.email).toEqual(response.user.email);
+    expect(data.user.firstName).toEqual(response.user.firstName);
+    expect(data.user.lastName).toEqual(response.user.lastName);
+  });
+});

package/tests/api/oauth.test.ts

@@ -0,0 +1,44 @@
+import MockAdapter from "axios-mock-adapter";
+import axios from "axios";
+import { OAuthFixture } from "../fixtures";
+import { OAuth } from "../../src/api";
+
+describe("OAuth", () => {
+  const mock = new MockAdapter(axios);
+  const client = axios.create();
+
+  it("should generate an authorization url", () => {
+    const { parameters } = OAuthFixture.authorize;
+    const { client_id, state, response_type } = parameters;
+
+    const baseURL = "https://api.test.com";
+    const instance = axios.create({ baseURL });
+    const url = OAuth.authorizeUrl({ client_id, state }, instance);
+    const query = new URLSearchParams({ response_type, client_id, state });
+
+    expect(url).toBeDefined();
+    expect(url).toBe(`${baseURL.replace("api.", "")}/oauth/authorize?${query.toString()}`);
+  });
+
+  it("should generate an access token", async () => {
+    const { parameters, response } = OAuthFixture.access_token;
+    const path = `/oauth/access_token`;
+
+    mock.onPost(path).reply(200, response);
+    const { data } = await OAuth.accessToken(parameters, client);
+
+    expect(data).toBeDefined();
+    expect(data.access_token).toBe(response.access_token);
+  });
+
+  it("should revoke an access token", async () => {
+    const { parameters, response } = OAuthFixture.revoke_token;
+    const path = `/oauth/revoke_authorization`;
+
+    mock.onPost(path).reply(200, response);
+    const { data } = await OAuth.revokeToken(parameters, client);
+
+    expect(data).toBeDefined();
+    expect(data.didRevoke).toBe(true);
+  });
+});

package/tests/api/site.test.ts

@@ -0,0 +1,202 @@
+import MockAdapter from "axios-mock-adapter";
+import axios from "axios";
+import { CollectionFixture, SiteFixture, WebhookFixture } from "../fixtures";
+import { Site, Collection, Webhook } from "../../src/api";
+
+describe("Sites", () => {
+  const mock = new MockAdapter(axios);
+  const client = axios.create();
+  describe("Static Methods", () => {
+    it("should respond with a list of sites", async () => {
+      const { response } = SiteFixture.list;
+      const path = "/sites";
+
+      mock.onGet(path).reply(200, response);
+      const { data } = await Site.list(client);
+
+      expect(data).toBeDefined();
+      expect(data.length).toBe(response.length);
+      expect(data[0]).toMatchObject(response[0]);
+    });
+
+    it("should respond with a single site", async () => {
+      const { parameters, response } = SiteFixture.getOne;
+      const { siteId } = parameters;
+      const path = `/sites/${siteId}`;
+
+      mock.onGet(path).reply(200, response);
+      const { data } = await Site.getOne(parameters, client);
+
+      expect(data).toBeDefined();
+      expect(data._id).toBe(siteId);
+    });
+
+    it("should respond with a list of domains", async () => {
+      const { parameters, response } = SiteFixture.domains;
+      const { siteId } = parameters;
+      const path = `/sites/${siteId}/domains`;
+
+      mock.onGet(path).reply(200, response);
+      const { data } = await Site.domains(parameters, client);
+
+      expect(data).toBeDefined();
+      expect(data.length).toBe(response.length);
+      expect(data[0]).toMatchObject(response[0]);
+    });
+
+    it("should publish a site", async () => {
+      const { parameters, response } = SiteFixture.publish;
+      const { siteId } = parameters;
+      const path = `/sites/${siteId}/publish`;
+
+      mock.onPost(path).reply(200, response);
+      const { data } = await Site.publish(parameters, client);
+
+      expect(data).toBeDefined();
+      expect(data.queued).toBe(true);
+    });
+  });
+
+  describe("Instance Methods", () => {
+    const res = { data: {}, status: 200, statusText: "", headers: {}, config: {} };
+    const site = new Site(client, res, SiteFixture.getOne.response);
+
+    it("should respond with a list of collections", async () => {
+      const { parameters, response } = CollectionFixture.list;
+      const { siteId } = parameters;
+
+      const path = `/sites/${siteId}/collections`;
+      mock.onGet(path).reply(200, response);
+      const spy = jest.spyOn(Collection, "list");
+
+      const result = await site.collections();
+
+      expect(spy).toHaveBeenCalledWith({ siteId }, client);
+
+      expect(result).toBeDefined();
+      expect(result.length).toBe(response.length);
+
+      const [first] = result;
+      expect(first._id).toBe(response[0]._id);
+
+      // collection wrapper functions
+      expect(typeof first.item).toBe("function");
+      expect(typeof first.items).toBe("function");
+      expect(typeof first.removeItem).toBe("function");
+      expect(typeof first.createItem).toBe("function");
+      expect(typeof first.updateItem).toBe("function");
+    });
+
+    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 spy = jest.spyOn(Webhook, "list");
+
+      const result = await site.webhooks();
+
+      expect(spy).toHaveBeenCalledWith({ siteId }, client);
+
+      expect(result).toBeDefined();
+      expect(result.length).toBe(response.length);
+
+      const [first] = result;
+      expect(first._id).toBe(response[0]._id);
+
+      // webhook wrapper functions
+      expect(typeof first.remove).toBe("function");
+    });
+
+    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 spy = jest.spyOn(Webhook, "getOne");
+
+      const result = await site.webhook({ webhookId });
+
+      expect(spy).toHaveBeenCalledWith({ siteId, webhookId }, client);
+
+      expect(result).toBeDefined();
+      expect(result._id).toBe(response._id);
+
+      // webhook wrapper functions
+      expect(typeof result.remove).toBe("function");
+    });
+
+    it("should create a webhook", async () => {
+      const { parameters, response } = WebhookFixture.create;
+      const { siteId } = parameters;
+
+      const path = `/sites/${siteId}/webhooks`;
+      const spy = jest.spyOn(Webhook, "create");
+      mock.onPost(path).reply(200, response);
+
+      const result = await site.createWebhook(parameters);
+
+      expect(spy).toHaveBeenCalledWith(parameters, client);
+
+      expect(result).toBeDefined();
+      expect(result._id).toBe(response._id);
+
+      // webhook wrapper functions
+      expect(typeof result.remove).toBe("function");
+    });
+
+    it("should remove a webhook", async () => {
+      const { parameters, response } = WebhookFixture.delete;
+      const { siteId, webhookId } = parameters;
+
+      const path = `/sites/${siteId}/webhooks/${webhookId}`;
+      const spy = jest.spyOn(Webhook, "remove");
+      mock.onDelete(path).reply(200, response);
+
+      const result = await site.removeWebhook(parameters);
+
+      expect(spy).toHaveBeenCalledWith(parameters, client);
+
+      expect(result).toBeDefined();
+      expect(result.deleted).toEqual(response.deleted);
+    });
+
+    it("should respond with a list of domains", async () => {
+      const { parameters, response } = SiteFixture.domains;
+      const { siteId } = parameters;
+
+      const path = `/sites/${siteId}/domains`;
+      const spy = jest.spyOn(Site, "domains");
+      mock.onGet(path).reply(200, response);
+
+      const result = await site.domains();
+
+      expect(spy).toHaveBeenCalledWith(parameters, client);
+
+      expect(result).toBeDefined();
+      expect(result.length).toBe(response.length);
+
+      const [first] = result;
+      expect(first._id).toBe(response[0]._id);
+      expect(first.name).toBe(response[0].name);
+    });
+
+    it("should publish a site", async () => {
+      const { parameters, response } = SiteFixture.publish;
+      const { siteId, domains } = parameters;
+
+      const path = `/sites/${siteId}/publish`;
+      const spy = jest.spyOn(Site, "publish");
+      mock.onPost(path).reply(200, response);
+
+      const result = await site.publishSite(domains);
+
+      expect(spy).toHaveBeenCalledWith(parameters, client);
+
+      expect(result).toBeDefined();
+      expect(result.queued).toBe(true);
+    });
+  });
+});