unit tests

backend/tests/unit/services/email/EmailClient.test.js

@@ -0,0 +1,297 @@
+// Mock AWS SDK before requiring modules
+jest.mock('@aws-sdk/client-ses', () => ({
+  SESClient: jest.fn().mockImplementation(() => ({
+    send: jest.fn(),
+  })),
+  SendEmailCommand: jest.fn(),
+}));
+
+jest.mock('../../../../config/aws', () => ({
+  getAWSConfig: jest.fn(() => ({ region: 'us-east-1' })),
+}));
+
+jest.mock('../../../../services/email/core/emailUtils', () => ({
+  htmlToPlainText: jest.fn((html) => html.replace(/<[^>]*>/g, '')),
+}));
+
+// Clear singleton between tests
+beforeEach(() => {
+  jest.clearAllMocks();
+  // Reset the singleton instance
+  const EmailClient = require('../../../../services/email/core/EmailClient');
+  EmailClient.instance = null;
+});
+
+describe('EmailClient', () => {
+  const { SESClient, SendEmailCommand } = require('@aws-sdk/client-ses');
+  const { getAWSConfig } = require('../../../../config/aws');
+
+  describe('constructor', () => {
+    it('should create a new instance', () => {
+      const EmailClient = require('../../../../services/email/core/EmailClient');
+      EmailClient.instance = null;
+      const client = new EmailClient();
+      expect(client).toBeDefined();
+      expect(client.sesClient).toBeNull();
+      expect(client.initialized).toBe(false);
+    });
+
+    it('should return existing instance (singleton pattern)', () => {
+      const EmailClient = require('../../../../services/email/core/EmailClient');
+      EmailClient.instance = null;
+      const client1 = new EmailClient();
+      const client2 = new EmailClient();
+      expect(client1).toBe(client2);
+    });
+  });
+
+  describe('initialize', () => {
+    it('should initialize SES client with AWS config', async () => {
+      const EmailClient = require('../../../../services/email/core/EmailClient');
+      EmailClient.instance = null;
+      const client = new EmailClient();
+
+      await client.initialize();
+
+      expect(getAWSConfig).toHaveBeenCalled();
+      expect(SESClient).toHaveBeenCalledWith({ region: 'us-east-1' });
+      expect(client.initialized).toBe(true);
+    });
+
+    it('should not re-initialize if already initialized', async () => {
+      const EmailClient = require('../../../../services/email/core/EmailClient');
+      EmailClient.instance = null;
+      const client = new EmailClient();
+
+      await client.initialize();
+      await client.initialize();
+
+      expect(SESClient).toHaveBeenCalledTimes(1);
+    });
+
+    it('should wait for existing initialization if in progress', async () => {
+      const EmailClient = require('../../../../services/email/core/EmailClient');
+      EmailClient.instance = null;
+      const client = new EmailClient();
+
+      // Start two initializations concurrently
+      const [result1, result2] = await Promise.all([
+        client.initialize(),
+        client.initialize(),
+      ]);
+
+      expect(SESClient).toHaveBeenCalledTimes(1);
+    });
+
+    it('should throw error if AWS config fails', async () => {
+      getAWSConfig.mockImplementationOnce(() => {
+        throw new Error('AWS config error');
+      });
+
+      const EmailClient = require('../../../../services/email/core/EmailClient');
+      EmailClient.instance = null;
+      const client = new EmailClient();
+
+      await expect(client.initialize()).rejects.toThrow('AWS config error');
+    });
+  });
+
+  describe('sendEmail', () => {
+    const originalEnv = process.env;
+
+    beforeEach(() => {
+      process.env = {
+        ...originalEnv,
+        EMAIL_ENABLED: 'true',
+        SES_FROM_EMAIL: 'noreply@rentall.com',
+        SES_FROM_NAME: 'RentAll',
+      };
+    });
+
+    afterEach(() => {
+      process.env = originalEnv;
+    });
+
+    it('should return early if EMAIL_ENABLED is not true', async () => {
+      process.env.EMAIL_ENABLED = 'false';
+
+      const EmailClient = require('../../../../services/email/core/EmailClient');
+      EmailClient.instance = null;
+      const client = new EmailClient();
+
+      const result = await client.sendEmail(
+        'test@example.com',
+        'Test Subject',
+        '<p>Hello</p>'
+      );
+
+      expect(result).toEqual({ success: true, messageId: 'disabled' });
+    });
+
+    it('should return early if EMAIL_ENABLED is not set', async () => {
+      delete process.env.EMAIL_ENABLED;
+
+      const EmailClient = require('../../../../services/email/core/EmailClient');
+      EmailClient.instance = null;
+      const client = new EmailClient();
+
+      const result = await client.sendEmail(
+        'test@example.com',
+        'Test Subject',
+        '<p>Hello</p>'
+      );
+
+      expect(result).toEqual({ success: true, messageId: 'disabled' });
+    });
+
+    it('should send email with correct parameters', async () => {
+      const mockSend = jest.fn().mockResolvedValue({ MessageId: 'msg-123' });
+      SESClient.mockImplementation(() => ({ send: mockSend }));
+
+      const EmailClient = require('../../../../services/email/core/EmailClient');
+      EmailClient.instance = null;
+      const client = new EmailClient();
+
+      const result = await client.sendEmail(
+        'test@example.com',
+        'Test Subject',
+        '<p>Hello World</p>'
+      );
+
+      expect(SendEmailCommand).toHaveBeenCalledWith({
+        Source: 'RentAll <noreply@rentall.com>',
+        Destination: {
+          ToAddresses: ['test@example.com'],
+        },
+        Message: {
+          Subject: {
+            Data: 'Test Subject',
+            Charset: 'UTF-8',
+          },
+          Body: {
+            Html: {
+              Data: '<p>Hello World</p>',
+              Charset: 'UTF-8',
+            },
+            Text: {
+              Data: expect.any(String),
+              Charset: 'UTF-8',
+            },
+          },
+        },
+      });
+
+      expect(result).toEqual({ success: true, messageId: 'msg-123' });
+    });
+
+    it('should send to multiple recipients', async () => {
+      const mockSend = jest.fn().mockResolvedValue({ MessageId: 'msg-456' });
+      SESClient.mockImplementation(() => ({ send: mockSend }));
+
+      const EmailClient = require('../../../../services/email/core/EmailClient');
+      EmailClient.instance = null;
+      const client = new EmailClient();
+
+      await client.sendEmail(
+        ['user1@example.com', 'user2@example.com'],
+        'Test Subject',
+        '<p>Hello</p>'
+      );
+
+      expect(SendEmailCommand).toHaveBeenCalledWith(
+        expect.objectContaining({
+          Destination: {
+            ToAddresses: ['user1@example.com', 'user2@example.com'],
+          },
+        })
+      );
+    });
+
+    it('should use provided text content', async () => {
+      const mockSend = jest.fn().mockResolvedValue({ MessageId: 'msg-789' });
+      SESClient.mockImplementation(() => ({ send: mockSend }));
+
+      const EmailClient = require('../../../../services/email/core/EmailClient');
+      EmailClient.instance = null;
+      const client = new EmailClient();
+
+      await client.sendEmail(
+        'test@example.com',
+        'Test Subject',
+        '<p>Hello</p>',
+        'Custom plain text'
+      );
+
+      expect(SendEmailCommand).toHaveBeenCalledWith(
+        expect.objectContaining({
+          Message: expect.objectContaining({
+            Body: expect.objectContaining({
+              Text: {
+                Data: 'Custom plain text',
+                Charset: 'UTF-8',
+              },
+            }),
+          }),
+        })
+      );
+    });
+
+    it('should add reply-to address if configured', async () => {
+      process.env.SES_REPLY_TO_EMAIL = 'support@rentall.com';
+      const mockSend = jest.fn().mockResolvedValue({ MessageId: 'msg-000' });
+      SESClient.mockImplementation(() => ({ send: mockSend }));
+
+      const EmailClient = require('../../../../services/email/core/EmailClient');
+      EmailClient.instance = null;
+      const client = new EmailClient();
+
+      await client.sendEmail(
+        'test@example.com',
+        'Test Subject',
+        '<p>Hello</p>'
+      );
+
+      expect(SendEmailCommand).toHaveBeenCalledWith(
+        expect.objectContaining({
+          ReplyToAddresses: ['support@rentall.com'],
+        })
+      );
+    });
+
+    it('should return error if send fails', async () => {
+      const mockSend = jest.fn().mockRejectedValue(new Error('SES send failed'));
+      SESClient.mockImplementation(() => ({ send: mockSend }));
+
+      const EmailClient = require('../../../../services/email/core/EmailClient');
+      EmailClient.instance = null;
+      const client = new EmailClient();
+
+      const result = await client.sendEmail(
+        'test@example.com',
+        'Test Subject',
+        '<p>Hello</p>'
+      );
+
+      expect(result).toEqual({ success: false, error: 'SES send failed' });
+    });
+
+    it('should auto-initialize if not initialized', async () => {
+      const mockSend = jest.fn().mockResolvedValue({ MessageId: 'msg-auto' });
+      SESClient.mockImplementation(() => ({ send: mockSend }));
+
+      const EmailClient = require('../../../../services/email/core/EmailClient');
+      EmailClient.instance = null;
+      const client = new EmailClient();
+
+      expect(client.initialized).toBe(false);
+
+      await client.sendEmail(
+        'test@example.com',
+        'Test Subject',
+        '<p>Hello</p>'
+      );
+
+      expect(client.initialized).toBe(true);
+    });
+  });
+});