mailisk 2.1.1 → 2.2.1

package/tests/mocks/axios-mocks.ts

@@ -1,9 +1,10 @@
 // Mock namespace response data
 export const mockNamespacesResponse = {
-  namespaces: [
+  total_count: 1,
+  data: [
     {
-      name: "test-namespace",
-      created_at: new Date().toISOString(),
+      id: "0fde5afa-a8a8-41a4-9ca4-21d83efc37d8",
+      namespace: "test-namespace",
       expires_at: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString(),
     },
   ],
@@ -11,39 +12,97 @@ export const mockNamespacesResponse = {
 
 // Mock email response data
 export const mockEmailsResponse = {
-  emails: [
+  total_count: 1,
+  options: {
+    wait: true,
+  },
+  data: [
     {
-      id: "email-123",
-      from: { address: "sender@example.com", name: "Sender" },
-      to: [{ address: "recipient@test-namespace.mailisk.net", name: "Recipient" }],
-      subject: "Test Email",
-      html: "<p>Test content</p>",
-      text: "Test content",
-      received_date: new Date().toISOString(),
-      received_timestamp: Math.floor(Date.now() / 1000),
-      expires_timestamp: Math.floor(Date.now() / 1000) + 30 * 24 * 60 * 60,
+      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,
     },
   ],
-  count: 1,
 };
 
 // Mock attachment response data
 export const mockAttachmentResponse = {
-  id: "attachment-123",
-  filename: "test.txt",
-  content_type: "text/plain",
-  size: 100,
-  expires_at: "Fri, 23 Jun 2025 02:29:13 GMT",
-  download_url: "https://example.com/attachment-123.txt",
+  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 = {
-  host: "smtp.mailisk.com",
-  port: 25,
-  secure: false,
-  auth: {
-    user: "test-namespace",
-    pass: "mock-password",
+  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/unit/mailisk.test.ts

@@ -9,6 +9,8 @@ import {
   mockEmailsResponse,
   mockSmtpSettingsResponse,
   mockAttachmentResponse,
+  mockSmsMessagesResponse,
+  mockSmsNumbersResponse,
 } from "../mocks/axios-mocks";
 
 const setupMockAxios = () => {
@@ -132,7 +134,7 @@ describe("MailiskClient", () => {
   describe("downloadAttachment", () => {
     it("should download and return attachment data", async () => {
       const getAttachmentSpy = jest.spyOn(MailiskClient.prototype, "getAttachment");
-      getAttachmentSpy.mockResolvedValueOnce({ data: mockAttachmentResponse });
+      getAttachmentSpy.mockResolvedValueOnce(mockAttachmentResponse);
 
       const mockBuffer = Buffer.from("test content");
       (axios.get as jest.Mock).mockResolvedValueOnce({ data: mockBuffer });
@@ -140,11 +142,145 @@ describe("MailiskClient", () => {
       const client = new MailiskClient({ apiKey: "test-key" });
       const result = await client.downloadAttachment("attachment-123");
 
-      expect(axios.get).toHaveBeenCalledWith(mockAttachmentResponse.download_url, { responseType: "arraybuffer" });
+      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();