add health check rest service

src/modules/health/tests/unit/messager.spec.ts

@@ -0,0 +1,47 @@
+import { AmqpConnection } from '@golevelup/nestjs-rabbitmq';
+import { ConfigService } from '@nestjs/config';
+import { Test, TestingModule } from '@nestjs/testing';
+import { Messager } from '../../adapters/secondaries/messager';
+
+const mockAmqpConnection = {
+  publish: jest.fn().mockImplementation(),
+};
+
+const mockConfigService = {
+  get: jest.fn().mockResolvedValue({
+    RMQ_EXCHANGE: 'mobicoop',
+  }),
+};
+
+describe('Messager', () => {
+  let messager: Messager;
+
+  beforeAll(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      imports: [],
+      providers: [
+        Messager,
+        {
+          provide: AmqpConnection,
+          useValue: mockAmqpConnection,
+        },
+        {
+          provide: ConfigService,
+          useValue: mockConfigService,
+        },
+      ],
+    }).compile();
+
+    messager = module.get<Messager>(Messager);
+  });
+
+  it('should be defined', () => {
+    expect(messager).toBeDefined();
+  });
+
+  it('should publish a message', async () => {
+    jest.spyOn(mockAmqpConnection, 'publish');
+    messager.publish('test.create.info', 'my-test');
+    expect(mockAmqpConnection.publish).toHaveBeenCalledTimes(1);
+  });
+});

src/modules/health/tests/unit/prisma.health-indicator.usecase.spec.ts

@@ -0,0 +1,58 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { PrismaHealthIndicatorUseCase } from '../../domain/usecases/prisma.health-indicator.usecase';
+import { AuthenticationRepository } from '../../../authentication/adapters/secondaries/authentication.repository';
+import { PrismaClientKnownRequestError } from '@prisma/client/runtime';
+import { HealthCheckError, HealthIndicatorResult } from '@nestjs/terminus';
+
+const mockAuthenticationRepository = {
+  healthCheck: jest
+    .fn()
+    .mockImplementationOnce(() => {
+      return Promise.resolve(true);
+    })
+    .mockImplementation(() => {
+      throw new PrismaClientKnownRequestError('Service unavailable', {
+        code: 'code',
+        clientVersion: 'version',
+      });
+    }),
+};
+
+describe('PrismaHealthIndicatorUseCase', () => {
+  let prismaHealthIndicatorUseCase: PrismaHealthIndicatorUseCase;
+
+  beforeAll(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        {
+          provide: AuthenticationRepository,
+          useValue: mockAuthenticationRepository,
+        },
+        PrismaHealthIndicatorUseCase,
+      ],
+    }).compile();
+
+    prismaHealthIndicatorUseCase = module.get<PrismaHealthIndicatorUseCase>(
+      PrismaHealthIndicatorUseCase,
+    );
+  });
+
+  it('should be defined', () => {
+    expect(prismaHealthIndicatorUseCase).toBeDefined();
+  });
+
+  describe('execute', () => {
+    it('should check health successfully', async () => {
+      const healthIndicatorResult: HealthIndicatorResult =
+        await prismaHealthIndicatorUseCase.isHealthy('prisma');
+
+      expect(healthIndicatorResult['prisma'].status).toBe('up');
+    });
+
+    it('should throw an error if database is unavailable', async () => {
+      await expect(
+        prismaHealthIndicatorUseCase.isHealthy('prisma'),
+      ).rejects.toBeInstanceOf(HealthCheckError);
+    });
+  });
+});