mailisk 2.0.1 → 2.2.1

package/tests/mocks/axios-mocks.ts

@@ -0,0 +1,108 @@
+// Mock namespace response data
+export const mockNamespacesResponse = {
+  total_count: 1,
+  data: [
+    {
+      id: "0fde5afa-a8a8-41a4-9ca4-21d83efc37d8",
+      namespace: "test-namespace",
+      expires_at: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString(),
+    },
+  ],
+};
+
+// Mock email response data
+export const mockEmailsResponse = {
+  total_count: 1,
+  options: {
+    wait: true,
+  },
+  data: [
+    {
+      id: "1763808382384-m-m-dEmYI7ic5",
+      from: {
+        address: "sender@example.com",
+        name: "Sender",
+      },
+      to: [
+        {
+          address: "recipient@test-namespace.mailisk.net",
+          name: "Recipient",
+        },
+      ],
+      subject: "test",
+      html: "false",
+      text: "test",
+      received_date: "2025-11-22T10:46:22.000Z",
+      received_timestamp: 1763808382,
+      expires_timestamp: 1764672382,
+      spam_score: null,
+    },
+  ],
+};
+
+// Mock attachment response data
+export const mockAttachmentResponse = {
+  data: {
+    id: "b04730be-9c13-4f23-a2b7-a4a9a943cd31",
+    filename: "Sample.png",
+    content_type: "image/png",
+    size: 140551,
+    expires_at: "2025-09-09T10:03:33.000Z",
+    download_url: "url",
+  },
+};
+
+// Mock SMTP settings response
+export const mockSmtpSettingsResponse = {
+  data: {
+    host: "smtp.mailisk.net",
+    port: 587,
+    username: "test-namespace",
+    password: "mock-password",
+  },
+};
+
+// Mock SMS messages response data
+export const mockSmsMessagesResponse = {
+  total_count: 1,
+  options: {
+    limit: 20,
+    offset: 0,
+  },
+  data: [
+    {
+      id: "37a2bc57-c2c7-4c08-a9dc-d143bc17643f",
+      sms_phone_number_id: "ba548be2-bff9-4e3f-a54b-e034c415e906",
+      body: "test newline \\n\\n test2",
+      from_number: "+18777804236",
+      to_number: "+19285639871",
+      provider_message_id: "SMf72eb72b6281a02e60a0114f38e34e36",
+      created_at: "2020-11-24T16:48:22.170Z",
+      direction: "inbound",
+    },
+  ],
+};
+
+// Mock SMS numbers response data
+export const mockSmsNumbersResponse = {
+  total_count: 2,
+  data: [
+    {
+      id: "13c4551e-a5be-4959-9ea5-82931dcfc74d",
+      organisation_id: "c02bdb84-22df-4c18-85ba-2defdd04eccb",
+      status: "requested",
+      country: "US",
+      created_at: "2020-11-22T16:59:25.462Z",
+      updated_at: "2020-11-22T16:59:25.462Z",
+    },
+    {
+      id: "6bf073d6-d333-45c9-b009-c77f0cac7657",
+      organisation_id: "ddec2c7b-b087-45b6-a81d-b195f25d457f",
+      status: "active",
+      country: "US",
+      phone_number: "+19285639871",
+      created_at: "2020-11-22T16:41:40.329Z",
+      updated_at: "2020-11-22T16:41:40.329Z",
+    },
+  ],
+};

package/tests/setup.ts

@@ -0,0 +1,21 @@
+import dotenv from "dotenv";
+import path from "path";
+
+dotenv.config({ path: path.resolve(process.cwd(), ".env.test") });
+
+jest.setTimeout(10000);
+
+process.env.TEST_MODE = "true";
+
+export const createTestClient = (mockResponses = {}) => {
+  const { MailiskClient } = require("../src/mailisk");
+
+  return new MailiskClient({
+    apiKey: "test-api-key",
+    baseUrl: "https://test-api.mailisk.com/",
+  });
+};
+
+afterEach(() => {
+  jest.resetAllMocks();
+});

package/tests/unit/mailisk.test.ts

@@ -0,0 +1,480 @@
+jest.mock("axios");
+jest.mock("nodemailer");
+
+import axios from "axios";
+import nodemailer from "nodemailer";
+import { MailiskClient } from "../../src/mailisk";
+import {
+  mockNamespacesResponse,
+  mockEmailsResponse,
+  mockSmtpSettingsResponse,
+  mockAttachmentResponse,
+  mockSmsMessagesResponse,
+  mockSmsNumbersResponse,
+} from "../mocks/axios-mocks";
+
+const setupMockAxios = () => {
+  jest.clearAllMocks();
+
+  const mockGet = jest.fn();
+  const mockPost = jest.fn();
+  const mockPut = jest.fn();
+  const mockDelete = jest.fn();
+
+  const mockInstance = {
+    get: mockGet,
+    post: mockPost,
+    put: mockPut,
+    delete: mockDelete,
+  };
+
+  (axios.create as jest.Mock).mockReturnValue(mockInstance);
+  (axios.get as jest.Mock).mockImplementation(jest.fn());
+
+  return {
+    mockInstance,
+    mockGet,
+    mockPost,
+    mockPut,
+    mockDelete,
+  };
+};
+
+describe("MailiskClient", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe("constructor", () => {
+    it("should initialize with default baseURL when not provided", () => {
+      setupMockAxios();
+      const client = new MailiskClient({ apiKey: "test-key" });
+      expect(axios.create).toHaveBeenCalledWith({
+        headers: {
+          "X-Api-Key": "test-key",
+        },
+        baseURL: "https://api.mailisk.com/",
+      });
+    });
+
+    it("should initialize with custom baseURL when provided", () => {
+      setupMockAxios();
+      const client = new MailiskClient({
+        apiKey: "test-key",
+        baseUrl: "https://custom-api.mailisk.com/",
+      });
+      expect(axios.create).toHaveBeenCalledWith({
+        headers: {
+          "X-Api-Key": "test-key",
+        },
+        baseURL: "https://custom-api.mailisk.com/",
+      });
+    });
+  });
+
+  describe("listNamespaces", () => {
+    it("should fetch and return namespaces", async () => {
+      const { mockGet } = setupMockAxios();
+      mockGet.mockResolvedValueOnce({ data: mockNamespacesResponse });
+
+      const client = new MailiskClient({ apiKey: "test-key" });
+      const result = await client.listNamespaces();
+
+      expect(mockGet).toHaveBeenCalledWith("api/namespaces");
+      expect(result).toEqual(mockNamespacesResponse);
+    });
+
+    it("should handle errors correctly", async () => {
+      const { mockGet } = setupMockAxios();
+      const error = new Error("API Error");
+      mockGet.mockRejectedValueOnce(error);
+
+      const client = new MailiskClient({ apiKey: "test-key" });
+
+      await expect(client.listNamespaces()).rejects.toThrow("API Error");
+    });
+  });
+
+  describe("getSmtpSettings", () => {
+    it("should fetch and return SMTP settings for a namespace", async () => {
+      const { mockGet } = setupMockAxios();
+      mockGet.mockResolvedValueOnce({ data: mockSmtpSettingsResponse });
+
+      const client = new MailiskClient({ apiKey: "test-key" });
+      const result = await client.getSmtpSettings("test-namespace");
+
+      expect(mockGet).toHaveBeenCalledWith("api/smtp/test-namespace");
+      expect(result).toEqual(mockSmtpSettingsResponse);
+    });
+
+    it("should handle errors correctly", async () => {
+      const { mockGet } = setupMockAxios();
+      const error = new Error("SMTP Settings Error");
+      mockGet.mockRejectedValueOnce(error);
+
+      const client = new MailiskClient({ apiKey: "test-key" });
+
+      await expect(client.getSmtpSettings("test-namespace")).rejects.toThrow("SMTP Settings Error");
+    });
+  });
+
+  describe("getAttachment", () => {
+    it("should fetch and return attachment data", async () => {
+      const { mockGet } = setupMockAxios();
+      mockGet.mockResolvedValueOnce({ data: mockAttachmentResponse });
+
+      const client = new MailiskClient({ apiKey: "test-key" });
+      const result = await client.getAttachment("attachment-123");
+
+      expect(mockGet).toHaveBeenCalledWith("api/attachments/attachment-123");
+      expect(result).toEqual(mockAttachmentResponse);
+    });
+  });
+
+  describe("downloadAttachment", () => {
+    it("should download and return attachment data", async () => {
+      const getAttachmentSpy = jest.spyOn(MailiskClient.prototype, "getAttachment");
+      getAttachmentSpy.mockResolvedValueOnce(mockAttachmentResponse);
+
+      const mockBuffer = Buffer.from("test content");
+      (axios.get as jest.Mock).mockResolvedValueOnce({ data: mockBuffer });
+
+      const client = new MailiskClient({ apiKey: "test-key" });
+      const result = await client.downloadAttachment("attachment-123");
+
+      expect(axios.get).toHaveBeenCalledWith(mockAttachmentResponse.data.download_url, { responseType: "arraybuffer" });
+      expect(result).toEqual(mockBuffer);
+    });
+  });
+
+  describe("searchSmsMessages", () => {
+    it("should fetch and return SMS messages with default parameters", async () => {
+      const { mockGet } = setupMockAxios();
+      mockGet.mockResolvedValueOnce({ data: mockSmsMessagesResponse });
+
+      const client = new MailiskClient({ apiKey: "test-key" });
+      const result = await client.searchSmsMessages("1234567890");
+
+      expect(mockGet).toHaveBeenCalledWith("api/sms/1234567890/messages", {
+        maxRedirects: 99999,
+        timeout: 1000 * 60 * 5,
+        params: {
+          from_date: expect.any(String),
+          wait: true,
+        },
+      });
+
+      expect(result).toEqual(mockSmsMessagesResponse);
+    });
+
+    it("should use custom parameters if provided", async () => {
+      const { mockGet } = setupMockAxios();
+      mockGet.mockResolvedValueOnce({ data: mockSmsMessagesResponse });
+
+      const customParams = {
+        limit: 5,
+        offset: 2,
+        body: "verification",
+        from_number: "+18005550123",
+        from_date: "2023-01-01T00:00:00.000Z",
+        to_date: "2023-02-01T00:00:00.000Z",
+        wait: false,
+      };
+
+      const client = new MailiskClient({ apiKey: "test-key" });
+      const result = await client.searchSmsMessages("+1234567890", customParams);
+
+      const expectedParams = { ...customParams };
+
+      expect(mockGet).toHaveBeenCalledWith("api/sms/+1234567890/messages", {
+        maxRedirects: 99999,
+        params: expectedParams,
+      });
+
+      expect(result).toEqual(mockSmsMessagesResponse);
+    });
+
+    it("should use custom axios config if provided", async () => {
+      const { mockGet } = setupMockAxios();
+      mockGet.mockResolvedValueOnce({ data: mockSmsMessagesResponse });
+
+      const customConfig = {
+        timeout: 10000,
+        maxRedirects: 5,
+      };
+
+      const client = new MailiskClient({ apiKey: "test-key" });
+      const result = await client.searchSmsMessages("+1234567890", undefined, customConfig);
+
+      expect(mockGet).toHaveBeenCalledWith("api/sms/+1234567890/messages", {
+        ...customConfig,
+        params: {
+          from_date: expect.any(String),
+          wait: true,
+        },
+      });
+
+      expect(result).toEqual(mockSmsMessagesResponse);
+    });
+
+    it("should handle errors correctly", async () => {
+      const { mockGet } = setupMockAxios();
+      const error = new Error("Search SMS Error");
+      mockGet.mockRejectedValueOnce(error);
+
+      const client = new MailiskClient({ apiKey: "test-key" });
+
+      await expect(client.searchSmsMessages("+1234567890")).rejects.toThrow("Search SMS Error");
+    });
+  });
+
+  describe("listSmsNumbers", () => {
+    it("should fetch and return SMS numbers", async () => {
+      const { mockGet } = setupMockAxios();
+      mockGet.mockResolvedValueOnce({ data: mockSmsNumbersResponse });
+
+      const client = new MailiskClient({ apiKey: "test-key" });
+      const result = await client.listSmsNumbers();
+
+      expect(mockGet).toHaveBeenCalledWith("api/sms/numbers");
+      expect(result).toEqual(mockSmsNumbersResponse);
+    });
+
+    it("should handle errors correctly", async () => {
+      const { mockGet } = setupMockAxios();
+      const error = new Error("List SMS Numbers Error");
+      mockGet.mockRejectedValueOnce(error);
+
+      const client = new MailiskClient({ apiKey: "test-key" });
+
+      await expect(client.listSmsNumbers()).rejects.toThrow("List SMS Numbers Error");
+    });
+  });
+
+  describe("sendVirtualSms", () => {
+    it("should send an SMS through the API", async () => {
+      const { mockPost } = setupMockAxios();
+      mockPost.mockResolvedValueOnce({ data: {} });
+
+      const smsParams = {
+        from_number: "15551234567",
+        to_number: "15557654321",
+        body: "Test message",
+      };
+
+      const client = new MailiskClient({ apiKey: "test-key" });
+      await client.sendVirtualSms(smsParams);
+
+      expect(mockPost).toHaveBeenCalledWith("api/sms/virtual", smsParams);
+    });
+
+    it("should handle errors when sending SMS", async () => {
+      const { mockPost } = setupMockAxios();
+      const error = new Error("Send SMS Error");
+      mockPost.mockRejectedValueOnce(error);
+
+      const client = new MailiskClient({ apiKey: "test-key" });
+
+      await expect(
+        client.sendVirtualSms({ from_number: "+15551234567", to_number: "+15557654321", body: "Test message" })
+      ).rejects.toThrow("Send SMS Error");
+    });
+  });
+
+  describe("searchInbox", () => {
+    it("should fetch and return emails with default parameters", async () => {
+      const { mockGet } = setupMockAxios();
+      mockGet.mockResolvedValueOnce({ data: mockEmailsResponse });
+
+      const client = new MailiskClient({ apiKey: "test-key" });
+      const result = await client.searchInbox("test-namespace");
+
+      expect(mockGet).toHaveBeenCalledWith("api/emails/test-namespace/inbox", {
+        maxRedirects: 99999,
+        timeout: 1000 * 60 * 5,
+        params: {
+          from_timestamp: expect.any(Number),
+          wait: true,
+        },
+      });
+      expect(result).toEqual(mockEmailsResponse);
+    });
+
+    it("should use custom parameters if provided", async () => {
+      const { mockGet } = setupMockAxios();
+      mockGet.mockResolvedValueOnce({ data: mockEmailsResponse });
+
+      const customParams = {
+        limit: 10,
+        offset: 5,
+        from_timestamp: 1234567890,
+        to_timestamp: 1234567899,
+        to_addr_prefix: "john",
+        from_addr_includes: "@example.com",
+        subject_includes: "test",
+        wait: false,
+      };
+
+      const client = new MailiskClient({ apiKey: "test-key" });
+      const result = await client.searchInbox("test-namespace", customParams);
+
+      expect(mockGet).toHaveBeenCalledWith("api/emails/test-namespace/inbox", {
+        maxRedirects: 99999,
+        params: customParams,
+      });
+      expect(result).toEqual(mockEmailsResponse);
+    });
+
+    it("should use custom axios config if provided", async () => {
+      const { mockGet } = setupMockAxios();
+      mockGet.mockResolvedValueOnce({ data: mockEmailsResponse });
+
+      const customParams = {
+        wait: true,
+      };
+
+      const customConfig = {
+        timeout: 10000,
+        maxRedirects: 5,
+      };
+
+      const client = new MailiskClient({ apiKey: "test-key" });
+      const result = await client.searchInbox("test-namespace", customParams, customConfig);
+
+      expect(mockGet).toHaveBeenCalledWith("api/emails/test-namespace/inbox", {
+        ...customConfig,
+        params: {
+          from_timestamp: expect.any(Number),
+          wait: true,
+        },
+      });
+      expect(result).toEqual(mockEmailsResponse);
+    });
+
+    it("should handle errors correctly", async () => {
+      const { mockGet } = setupMockAxios();
+      const error = new Error("Search Inbox Error");
+      mockGet.mockRejectedValueOnce(error);
+
+      const client = new MailiskClient({ apiKey: "test-key" });
+
+      await expect(client.searchInbox("test-namespace")).rejects.toThrow("Search Inbox Error");
+    });
+  });
+
+  describe("sendVirtualEmail", () => {
+    // Setup for nodemailer mock
+    const mockSendMail = jest.fn();
+    const mockClose = jest.fn();
+    const mockTransport = {
+      sendMail: mockSendMail,
+      close: mockClose,
+    };
+
+    beforeEach(() => {
+      (nodemailer.createTransport as jest.Mock).mockReturnValue(mockTransport);
+      mockSendMail.mockReset().mockResolvedValue({});
+      mockClose.mockReset();
+    });
+
+    it("should send an email using nodemailer", async () => {
+      const { mockGet } = setupMockAxios();
+      mockGet.mockResolvedValueOnce({
+        data: {
+          data: {
+            host: "smtp.mailisk.com",
+            port: 25,
+            username: "test-namespace",
+            password: "mock-password",
+          },
+        },
+      });
+
+      const emailParams = {
+        from: "sender@example.com",
+        to: "recipient@test-namespace.mailisk.net",
+        subject: "Test Subject",
+        text: "Test Content",
+        html: "<p>Test HTML Content</p>",
+        headers: { "X-Custom-Header": "Custom Value" },
+      };
+
+      const client = new MailiskClient({ apiKey: "test-key" });
+      await client.sendVirtualEmail("test-namespace", emailParams);
+
+      expect(mockGet).toHaveBeenCalledWith("api/smtp/test-namespace");
+
+      expect(nodemailer.createTransport).toHaveBeenCalledWith({
+        host: "smtp.mailisk.com",
+        port: 25,
+        secure: false,
+        auth: {
+          user: "test-namespace",
+          pass: "mock-password",
+        },
+      });
+
+      expect(mockSendMail).toHaveBeenCalledWith({
+        from: "sender@example.com",
+        to: "recipient@test-namespace.mailisk.net",
+        subject: "Test Subject",
+        text: "Test Content",
+        html: "<p>Test HTML Content</p>",
+        headers: { "X-Custom-Header": "Custom Value" },
+      });
+
+      expect(mockClose).toHaveBeenCalled();
+    });
+
+    it("should handle errors from SMTP settings fetch", async () => {
+      const { mockGet } = setupMockAxios();
+      const error = new Error("SMTP Settings Error");
+      mockGet.mockRejectedValueOnce(error);
+
+      const emailParams = {
+        from: "sender@example.com",
+        to: "recipient@test-namespace.mailisk.net",
+        subject: "Test Subject",
+        text: "Test Content",
+      };
+
+      const client = new MailiskClient({ apiKey: "test-key" });
+
+      await expect(client.sendVirtualEmail("test-namespace", emailParams)).rejects.toThrow("SMTP Settings Error");
+
+      expect(nodemailer.createTransport).not.toHaveBeenCalled();
+    });
+
+    it("should handle errors from nodemailer sendMail", async () => {
+      const { mockGet } = setupMockAxios();
+      mockGet.mockResolvedValueOnce({
+        data: {
+          data: {
+            host: "smtp.mailisk.com",
+            port: 25,
+            username: "test-namespace",
+            password: "mock-password",
+          },
+        },
+      });
+
+      const sendMailError = new Error("Failed to send email");
+      mockSendMail.mockRejectedValueOnce(sendMailError);
+
+      const emailParams = {
+        from: "sender@example.com",
+        to: "recipient@test-namespace.mailisk.net",
+        subject: "Test Subject",
+        text: "Test Content",
+      };
+
+      const client = new MailiskClient({ apiKey: "test-key" });
+
+      await expect(client.sendVirtualEmail("test-namespace", emailParams)).rejects.toThrow("Failed to send email");
+
+      // In the actual implementation, if sendMail throws an error, close won't be called
+      // We just verify that sendMail was called
+      expect(mockSendMail).toHaveBeenCalled();
+    });
+  });
+});