Merge pull request #65 from railsware/contact-lists-api

Contact lists api

Author: narekhovhannisyan

README.md

@@ -63,6 +63,10 @@ Refer to the [`examples`](examples) folder for the source code of this and other
 
  - [Contacts](examples/contacts/everything.ts)
 
+### Contact Lists API
+
+ - [Contact Lists](examples/contact-lists/everything.ts)
+
 ### Sending API
 
  - [Advanced](examples/sending/everything.ts)

examples/contact-lists/everything.ts

@@ -0,0 +1,35 @@
+import { MailtrapClient } from "mailtrap";
+
+const TOKEN = "<YOUR-TOKEN-HERE>";
+const ACCOUNT_ID = "<YOUR-ACCOUNT-ID-HERE>"
+
+const client = new MailtrapClient({
+  token: TOKEN,
+  accountId: ACCOUNT_ID,
+});
+
+async function contactListsFlow() {
+  // Create a new contact list
+  await client.contactLists.create({
+    name: "Test List",
+  });
+
+  // Get all contact lists
+  const all = await client.contactLists.getList();
+  console.log("All contact lists:", all);
+
+  // Get a specific contact list
+  const one = await client.contactLists.get(all[0].id);
+  console.log("One contact list:", one);
+
+  // Update a contact list
+  const updated = await client.contactLists.update(all[0].id, {
+    name: "Updated Test List",
+  });
+  console.log("Updated contact list:", updated);
+
+  // Delete a contact list
+  await client.contactLists.delete(all[0].id);
+}
+
+contactListsFlow();

src/__tests__/lib/api/ContactLists.test.ts

@@ -0,0 +1,20 @@
+import axios from "axios";
+
+import ContactLists from "../../../lib/api/ContactLists";
+
+describe("lib/api/ContactLists: ", () => {
+  const accountId = 100;
+  const contactListsAPI = new ContactLists(axios, accountId);
+
+  describe("class ContactLists(): ", () => {
+    describe("init: ", () => {
+      it("initalizes with all necessary params.", () => {
+        expect(contactListsAPI).toHaveProperty("create");
+        expect(contactListsAPI).toHaveProperty("getList");
+        expect(contactListsAPI).toHaveProperty("get");
+        expect(contactListsAPI).toHaveProperty("update");
+        expect(contactListsAPI).toHaveProperty("delete");
+      });
+    });
+  });
+});

src/__tests__/lib/api/resources/ContactLists.test.ts

@@ -0,0 +1,237 @@
+import axios from "axios";
+import AxiosMockAdapter from "axios-mock-adapter";
+
+import ContactListsApi from "../../../../lib/api/resources/ContactLists";
+import handleSendingError from "../../../../lib/axios-logger";
+import MailtrapError from "../../../../lib/MailtrapError";
+import { ContactList, ContactLists } from "../../../../types/api/contactlist";
+
+import CONFIG from "../../../../config";
+
+const { CLIENT_SETTINGS } = CONFIG;
+const { GENERAL_ENDPOINT } = CLIENT_SETTINGS;
+
+describe("lib/api/resources/ContactLists: ", () => {
+  let mock: AxiosMockAdapter;
+  const accountId = 100;
+  const contactListsAPI = new ContactListsApi(axios, accountId);
+
+  const createListRequest = {
+    name: "Test List",
+  };
+
+  const createListResponse: ContactList = {
+    id: 1,
+    name: "Test List",
+  };
+
+  const updateListRequest = {
+    name: "Updated Test List",
+  };
+
+  const updateListResponse: ContactList = {
+    id: 1,
+    name: "Updated Test List",
+  };
+
+  describe("class ContactListsApi(): ", () => {
+    describe("init: ", () => {
+      it("initializes with all necessary params.", () => {
+        expect(contactListsAPI).toHaveProperty("create");
+        expect(contactListsAPI).toHaveProperty("update");
+        expect(contactListsAPI).toHaveProperty("delete");
+        expect(contactListsAPI).toHaveProperty("get");
+        expect(contactListsAPI).toHaveProperty("getList");
+      });
+    });
+  });
+
+  beforeAll(() => {
+    axios.interceptors.response.use(
+      (response) => response.data,
+      handleSendingError
+    );
+    mock = new AxiosMockAdapter(axios);
+  });
+
+  afterEach(() => {
+    mock.reset();
+  });
+
+  describe("getAll(): ", () => {
+    it("successfully gets all contact lists.", async () => {
+      const endpoint = `${GENERAL_ENDPOINT}/api/accounts/${accountId}/contacts/lists`;
+      const expectedResponseData: ContactLists = [
+        { id: 1, name: "Test List 1" },
+        { id: 2, name: "Test List 2" },
+      ];
+
+      expect.assertions(2);
+
+      mock.onGet(endpoint).reply(200, expectedResponseData);
+      const result = await contactListsAPI.getList();
+
+      expect(mock.history.get[0].url).toEqual(endpoint);
+      expect(result).toEqual(expectedResponseData);
+    });
+
+    it("fails with error.", async () => {
+      const endpoint = `${GENERAL_ENDPOINT}/api/accounts/${accountId}/contacts/lists`;
+      const expectedErrorMessage = "Request failed with status code 400";
+
+      expect.assertions(2);
+
+      mock.onGet(endpoint).reply(400, { error: expectedErrorMessage });
+
+      try {
+        await contactListsAPI.getList();
+      } catch (error) {
+        expect(error).toBeInstanceOf(MailtrapError);
+        if (error instanceof MailtrapError) {
+          expect(error.message).toEqual(expectedErrorMessage);
+        }
+      }
+    });
+  });
+
+  describe("get(): ", () => {
+    it("successfully gets a contact list by ID.", async () => {
+      const listId = 1;
+      const endpoint = `${GENERAL_ENDPOINT}/api/accounts/${accountId}/contacts/lists/${listId}`;
+      const expectedResponseData: ContactList = {
+        id: listId,
+        name: "Test List",
+      };
+
+      expect.assertions(2);
+
+      mock.onGet(endpoint).reply(200, expectedResponseData);
+      const result = await contactListsAPI.get(listId);
+
+      expect(mock.history.get[0].url).toEqual(endpoint);
+      expect(result).toEqual(expectedResponseData);
+    });
+
+    it("fails with error when getting a contact list.", async () => {
+      const listId = 999;
+      const endpoint = `${GENERAL_ENDPOINT}/api/accounts/${accountId}/contacts/lists/${listId}`;
+      const expectedErrorMessage = "Contact list not found";
+
+      expect.assertions(2);
+
+      mock.onGet(endpoint).reply(404, { error: expectedErrorMessage });
+
+      try {
+        await contactListsAPI.get(listId);
+      } catch (error) {
+        expect(error).toBeInstanceOf(MailtrapError);
+        if (error instanceof MailtrapError) {
+          expect(error.message).toEqual(expectedErrorMessage);
+        }
+      }
+    });
+  });
+
+  describe("create(): ", () => {
+    it("successfully creates a contact list.", async () => {
+      const endpoint = `${GENERAL_ENDPOINT}/api/accounts/${accountId}/contacts/lists`;
+      const expectedResponseData = createListResponse;
+
+      expect.assertions(2);
+
+      mock.onPost(endpoint, createListRequest).reply(200, expectedResponseData);
+      const result = await contactListsAPI.create(createListRequest);
+
+      expect(mock.history.post[0].url).toEqual(endpoint);
+      expect(result).toEqual(expectedResponseData);
+    });
+
+    it("fails with error.", async () => {
+      const endpoint = `${GENERAL_ENDPOINT}/api/accounts/${accountId}/contacts/lists`;
+      const expectedErrorMessage = "Request failed with status code 400";
+
+      expect.assertions(2);
+
+      mock.onPost(endpoint).reply(400, { error: expectedErrorMessage });
+
+      try {
+        await contactListsAPI.create(createListRequest);
+      } catch (error) {
+        expect(error).toBeInstanceOf(MailtrapError);
+        if (error instanceof MailtrapError) {
+          expect(error.message).toEqual(expectedErrorMessage);
+        }
+      }
+    });
+  });
+
+  describe("update(): ", () => {
+    const listId = 1;
+
+    it("successfully updates a contact list.", async () => {
+      const endpoint = `${GENERAL_ENDPOINT}/api/accounts/${accountId}/contacts/lists/${listId}`;
+      const expectedResponseData = updateListResponse;
+
+      expect.assertions(2);
+
+      mock
+        .onPatch(endpoint, updateListRequest)
+        .reply(200, expectedResponseData);
+      const result = await contactListsAPI.update(listId, updateListRequest);
+
+      expect(mock.history.patch[0].url).toEqual(endpoint);
+      expect(result).toEqual(expectedResponseData);
+    });
+
+    it("fails with error.", async () => {
+      const endpoint = `${GENERAL_ENDPOINT}/api/accounts/${accountId}/contacts/lists/${listId}`;
+      const expectedErrorMessage = "Request failed with status code 404";
+
+      expect.assertions(2);
+
+      mock.onPatch(endpoint).reply(404, { error: expectedErrorMessage });
+
+      try {
+        await contactListsAPI.update(listId, updateListRequest);
+      } catch (error) {
+        expect(error).toBeInstanceOf(MailtrapError);
+        if (error instanceof MailtrapError) {
+          expect(error.message).toEqual(expectedErrorMessage);
+        }
+      }
+    });
+  });
+
+  describe("delete(): ", () => {
+    const listId = 1;
+
+    it("successfully deletes a contact list.", async () => {
+      const endpoint = `${GENERAL_ENDPOINT}/api/accounts/${accountId}/contacts/lists/${listId}`;
+
+      expect.assertions(1);
+
+      mock.onDelete(endpoint).reply(204);
+      await contactListsAPI.delete(listId);
+
+      expect(mock.history.delete[0].url).toEqual(endpoint);
+    });
+
+    it("fails with error.", async () => {
+      const endpoint = `${GENERAL_ENDPOINT}/api/accounts/${accountId}/contacts/lists/${listId}`;
+      const expectedErrorMessage = "Request failed with status code 404";
+
+      expect.assertions(2);
+
+      mock.onDelete(endpoint).reply(404, { error: expectedErrorMessage });
+
+      try {
+        await contactListsAPI.delete(listId);
+      } catch (error) {
+        expect(error).toBeInstanceOf(MailtrapError);
+        if (error instanceof MailtrapError) {
+          expect(error.message).toEqual(expectedErrorMessage);
+        }
+      }
+    });
+  });
+});

src/__tests__/lib/mailtrap-client.test.ts

@@ -9,6 +9,8 @@ import MailtrapError from "../../lib/MailtrapError";
 import CONFIG from "../../config";
 import GeneralAPI from "../../lib/api/General";
 import TestingAPI from "../../lib/api/Testing";
+import ContactLists from "../../lib/api/ContactLists";
+import Contacts from "../../lib/api/Contacts";
 
 const { ERRORS, CLIENT_SETTINGS } = CONFIG;
 const { TESTING_ENDPOINT, BULK_ENDPOINT, SENDING_ENDPOINT } = CLIENT_SETTINGS;
@@ -704,15 +706,81 @@ describe("lib/mailtrap-client: ", () => {
     });
 
     describe("get general(): ", () => {
-      it("returns testing API object, console warn is called twice.", () => {
+      it("rejects with Mailtrap error, when `accountId` is missing.", () => {
         const client = new MailtrapClient({
           token: "MY_API_TOKEN",
         });
         expect.assertions(1);
 
+        try {
+          client.general;
+        } catch (error) {
+          expect(error).toEqual(new MailtrapError(ACCOUNT_ID_MISSING));
+        }
+      });
+
+      it("returns general API object when accountId is provided.", () => {
+        const client = new MailtrapClient({
+          token: "MY_API_TOKEN",
+          accountId: 10,
+        });
+        expect.assertions(1);
+
         const generalClient = client.general;
         expect(generalClient).toBeInstanceOf(GeneralAPI);
       });
     });
+
+    describe("get contacts(): ", () => {
+      it("rejects with Mailtrap error, when `accountId` is missing.", () => {
+        const client = new MailtrapClient({
+          token: "MY_API_TOKEN",
+        });
+        expect.assertions(1);
+
+        try {
+          client.contacts;
+        } catch (error) {
+          expect(error).toEqual(new MailtrapError(ACCOUNT_ID_MISSING));
+        }
+      });
+
+      it("returns contacts API object when accountId is provided.", () => {
+        const client = new MailtrapClient({
+          token: "MY_API_TOKEN",
+          accountId: 10,
+        });
+        expect.assertions(1);
+
+        const contactsClient = client.contacts;
+        expect(contactsClient).toBeInstanceOf(Contacts);
+      });
+    });
+
+    describe("get contactLists(): ", () => {
+      it("rejects with Mailtrap error, when `accountId` is missing.", () => {
+        const client = new MailtrapClient({
+          token: "MY_API_TOKEN",
+        });
+        expect.assertions(1);
+
+        try {
+          client.contactLists;
+        } catch (error) {
+          expect(error).toEqual(new MailtrapError(ACCOUNT_ID_MISSING));
+        }
+      });
+
+      it("returns contact lists API object when accountId is provided.", () => {
+        const client = new MailtrapClient({
+          token: "MY_API_TOKEN",
+          accountId: 10,
+        });
+        expect.assertions(1);
+
+        const contactListsClient = client.contactLists;
+        expect(contactListsClient).toBeInstanceOf(ContactLists);
+      });
+    });
   });
 });