test: add unit tests for MailService, MailController, and MailUseCases

Author: jzunigax2

src/externals/mail/mail.service.spec.ts

@@ -0,0 +1,102 @@
+import { Test, type TestingModule } from '@nestjs/testing';
+import { createMock, type DeepMocked } from '@golevelup/ts-jest';
+import { ConflictException } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { MailService } from './mail.service';
+import { HttpClient } from '../http/http.service';
+
+describe('MailService', () => {
+  let mailService: MailService;
+  let httpClient: DeepMocked<HttpClient>;
+  let configService: DeepMocked<ConfigService>;
+
+  beforeEach(async () => {
+    const moduleRef: TestingModule = await Test.createTestingModule({
+      providers: [MailService],
+    })
+      .useMocker(() => createMock())
+      .compile();
+
+    mailService = moduleRef.get(MailService);
+    httpClient = moduleRef.get(HttpClient);
+    configService = moduleRef.get(ConfigService);
+
+    configService.get.mockImplementation((key: string) => {
+      const config = {
+        'apis.mail.url': 'http://mail:3100',
+        'secrets.gateway':
+          'LS0tLS1CRUdJTiBSU0EgUFJJVkFURSBLRVktLS0tLQpNSUlCT3dJQkFBSkJBTDlDTVRlZGEramdIcGJuTmtlSm51TlpnYzg5TGFvMGNQNkl6dlJrYTJ0MUVKbnh5ZTA1CndSWGZLMXFpbTFOMGU3cGhkd0RkRWYvNGJ1eFc5V2g1UWxzQ0F3RUFBUUpCQUpnRXljLzF2VDdGWFNyK3JpTWcKWFAxQ09LNTdaeCtCUFVyamZQTytHYSszWk1MRHhqaG44dGZmV1E4VUpKemJ5VkQ0Q0JqTmNra2xRN3phQ29BNwo1WWtDSVFEd0h2MXhVRkFVUkI2b3QwL0JMMWNxek5SNU80dFBMT0NjL2gyK0o4Y09WUUloQU12b0FrMm5IQWhSClpRNmhNZGFTdWtPVTE3MTYvRGxnNWNiSXNWYXh0bDN2QWlBTUdTT2YzL0lJODEyd0ZueFlPWEJrNGFrYTZwc2MKUkNDVkNHQ3JRZ25QZVFJZ2NTU2E2cFc0YzFFZTN5Qkl0RVNVZ0YxOTNKRDZsYWdUdDlxeXRHVkZ5UmNDSVFDYgp6dE85ampXcERmYTlnWTV2dVB4MFgyUkcxbjJQb0ZYVjVXT29RanNqbnc9PQotLS0tLUVORCBSU0EgUFJJVkFURSBLRVktLS0tLQo=',
+        isDevelopment: true,
+      };
+      return config[key];
+    });
+  });
+
+  it('should be defined', () => {
+    expect(mailService).toBeDefined();
+  });
+
+  describe('createAccount', () => {
+    const payload = {
+      userId: 'user-uuid',
+      address: 'john@inxt.eu',
+      domain: 'inxt.eu',
+      displayName: 'John Doe',
+    };
+
+    it('When mail gateway responds successfully, then it should return account data', async () => {
+      httpClient.post.mockResolvedValueOnce({
+        data: { address: 'john@inxt.eu', domain: 'inxt.eu' },
+      } as any);
+
+      const result = await mailService.createAccount(payload);
+
+      expect(result).toEqual({ address: 'john@inxt.eu', domain: 'inxt.eu' });
+      expect(httpClient.post).toHaveBeenCalledWith(
+        'http://mail:3100/gateway/accounts',
+        payload,
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            'Content-Type': 'application/json',
+            Authorization: expect.stringMatching(/^Bearer /),
+          }),
+        }),
+      );
+    });
+
+    it('When mail gateway returns 409, then it should throw ConflictException', async () => {
+      const axiosError = {
+        response: {
+          status: 409,
+          data: { message: 'Address already in use' },
+        },
+      };
+      httpClient.post.mockRejectedValueOnce(axiosError);
+
+      await expect(mailService.createAccount(payload)).rejects.toThrow(
+        ConflictException,
+      );
+    });
+
+    it('When mail gateway returns 409 without message, then it should use default message', async () => {
+      const axiosError = {
+        response: { status: 409, data: {} },
+      };
+      httpClient.post.mockRejectedValueOnce(axiosError);
+
+      await expect(mailService.createAccount(payload)).rejects.toThrow(
+        'Mail account already exists',
+      );
+    });
+
+    it('When mail gateway returns non-409 error, then it should rethrow', async () => {
+      const axiosError = {
+        response: { status: 500 },
+        message: 'Internal Server Error',
+      };
+      httpClient.post.mockRejectedValueOnce(axiosError);
+
+      await expect(mailService.createAccount(payload)).rejects.toBe(axiosError);
+    });
+  });
+});

src/externals/mail/mail.service.ts

@@ -1,4 +1,4 @@
-import { Inject, Injectable } from '@nestjs/common';
+import { ConflictException, Inject, Injectable } from '@nestjs/common';
 import { sign } from 'jsonwebtoken';
 import { ConfigService } from '@nestjs/config';
 import { HttpClient } from '../http/http.service';
@@ -52,12 +52,21 @@ export class MailService {
     const baseUrl = this.configService.get('apis.mail.url');
     const headers = this.getAuthHeaders();
 
-    const res = await this.httpClient.post(
-      `${baseUrl}/gateway/accounts`,
-      payload,
-      { headers },
-    );
+    try {
+      const res = await this.httpClient.post(
+        `${baseUrl}/gateway/accounts`,
+        payload,
+        { headers },
+      );
 
-    return res.data;
+      return res.data;
+    } catch (error) {
+      if (error?.response?.status === 409) {
+        throw new ConflictException(
+          error.response.data?.message || 'Mail account already exists',
+        );
+      }
+      throw error;
+    }
   }
 }

src/modules/mail/mail.controller.spec.ts

@@ -0,0 +1,72 @@
+import { Test, type TestingModule } from '@nestjs/testing';
+import { createMock, type DeepMocked } from '@golevelup/ts-jest';
+import { ConflictException } from '@nestjs/common';
+import { MailController } from './mail.controller';
+import { MailUseCases } from './mail.usecase';
+import { newUser } from '../../../test/fixtures';
+import { PaymentRequiredException } from '../feature-limit/exceptions/payment-required.exception';
+
+describe('MailController', () => {
+  let controller: MailController;
+  let mailUseCases: DeepMocked<MailUseCases>;
+
+  beforeEach(async () => {
+    const moduleRef: TestingModule = await Test.createTestingModule({
+      controllers: [MailController],
+    })
+      .useMocker(() => createMock())
+      .compile();
+
+    controller = moduleRef.get(MailController);
+    mailUseCases = moduleRef.get(MailUseCases);
+  });
+
+  describe('createMailAccount', () => {
+    const dto = {
+      address: 'john',
+      domain: 'inxt.eu',
+      displayName: 'John Doe',
+      password: 'encrypted-password',
+    };
+
+    it('When called with valid input, then it should return the usecase result', async () => {
+      const user = newUser();
+      const expected = {
+        token: 'token',
+        newToken: 'newToken',
+        address: 'john@inxt.eu',
+      };
+
+      mailUseCases.createMailAccount.mockResolvedValueOnce(expected);
+
+      const result = await controller.createMailAccount(user, dto);
+
+      expect(result).toEqual(expected);
+      expect(mailUseCases.createMailAccount).toHaveBeenCalledWith(user, dto);
+    });
+
+    it('When user has no mail access, then it should propagate PaymentRequiredException', async () => {
+      const user = newUser();
+
+      mailUseCases.createMailAccount.mockRejectedValueOnce(
+        new PaymentRequiredException('Mail access is not available'),
+      );
+
+      await expect(controller.createMailAccount(user, dto)).rejects.toThrow(
+        PaymentRequiredException,
+      );
+    });
+
+    it('When user already has a mail account, then it should propagate ConflictException', async () => {
+      const user = newUser();
+
+      mailUseCases.createMailAccount.mockRejectedValueOnce(
+        new ConflictException('User already has a mail account'),
+      );
+
+      await expect(controller.createMailAccount(user, dto)).rejects.toThrow(
+        ConflictException,
+      );
+    });
+  });
+});