Mise à jour du contrôleur d'identités

Author: RICHARD-Quentin

src/_common/tests/mock.service.ts

@@ -0,0 +1,30 @@
+/**
+ * Enhances createMockService to handle an arbitrary number of call behaviors dynamically.
+ * @param service The service class to mock.
+ * @param methodStubs An object where keys are method names and values are arrays of behaviors for those methods.
+ * @returns A mock service instance with dynamically stubbed methods.
+ */
+export function createMockService<T>(service: new (...args: any[]) => T, methodStubs: Record<string, any[] | any>): T {
+  const mockService = {};
+
+  Object.entries(methodStubs).forEach(([method, stubValueOrArray]) => {
+    const stubValues = Array.isArray(stubValueOrArray) ? stubValueOrArray : [stubValueOrArray];
+    const methodMock = jest.fn();
+
+    stubValues.forEach((stubValue) => {
+      methodMock.mockImplementationOnce((...args) => {
+        if (typeof stubValue === 'function') {
+          return stubValue(...args);
+        } else if (stubValue instanceof Error) {
+          throw stubValue;
+        } else {
+          return stubValue;
+        }
+      });
+    });
+
+    mockService[method] = methodMock;
+  });
+
+  return mockService as T;
+}

src/management/identities/identities.controller.spec.ts

@@ -2,17 +2,18 @@ import { FilterOptions } from '@streamkits/nestjs_module_scrud';
 import { Test, TestingModule } from '@nestjs/testing';
 import { IdentitiesController } from './identities.controller';
 import { IdentitiesService } from './identities.service';
-import { Identities, IdentitiesSchema } from './_schemas/identities.schema';
+import { Identities, IdentitiesDocument, IdentitiesSchema } from './_schemas/identities.schema';
 import { HttpStatus } from '@nestjs/common';
-import { Model, Types } from 'mongoose';
+import { Model, ModifyResult, Query, Types } from 'mongoose';
 import { Response } from 'express';
 import { getModelToken } from '@nestjs/mongoose';
 import { IdentitiesDtoStub } from './_stubs/identities.dto.stub';
 import { IdentitiesValidationService } from './validations/identities.validation.service';
 import { IdentitiesValidationModule } from './validations/identities.validation.module';
 import { MockResponse, createResponse } from 'node-mocks-http';
-import { ValidationSchemaException } from '~/_common/errors/ValidationException';
 import { MongoDbTestInstance } from '~/_common/tests/mongodb.test.instance';
+import { IdentityState } from './_enums/states.enum';
+import { createMockService } from '~/_common/tests/mock.service';
 
 describe('IdentitiesController', () => {
   let controller: IdentitiesController;
@@ -35,20 +36,61 @@ describe('IdentitiesController', () => {
     mongoDbTestInstance = new MongoDbTestInstance();
     await mongoDbTestInstance.start();
     identitiesModel = await mongoDbTestInstance.getModel<Identities>(Identities.name, IdentitiesSchema);
+    _id = new Types.ObjectId();
+
+    // service = createMockService<IdentitiesService>(IdentitiesService, {
+    //   create: [{ ...identitiesCreated }, { ...identitiesAccepted }],
+    //   findAndCount: [{ data: [identitiesWithId], total: 1 }],
+    //   findOne: [{ ...identitiesWithId }],
+    //   update: [{ ...identitiesWithId }],
+    //   delete: [{ ...identitiesWithId }],
+    // });
+
+    service = createMockService<IdentitiesService>(IdentitiesService, {
+      create: [
+        // First call returns a newly created identity with a status of CREATED
+        Promise.resolve({ ...IdentitiesDtoStub(), _id, state: IdentityState.TO_VALIDATE }),
+        // Second call simulates a scenario where creation leads to ACCEPTED status due to validations
+        Promise.resolve({ ...IdentitiesDtoStub(), _id, state: IdentityState.TO_COMPLETE }),
+      ],
+      findAndCount: [
+        // Successful search, returns an array of identities and a total count
+        Promise.resolve({ data: [{ ...IdentitiesDtoStub(), _id }], total: 1 }),
+        // Simulate a failure in searching identities
+        Promise.reject(new Error('Error')),
+      ],
+      findOne: [
+        // Successfully finds an identity
+        Promise.resolve({ ...IdentitiesDtoStub(), _id }),
+        // Simulates an error when finding an identity
+        Promise.reject(new Error('Error')),
+      ],
+      update: [
+        // Successfully updates an identity
+        Promise.resolve({ ...IdentitiesDtoStub(), _id }),
+        // Simulates an error in updating an identity
+        Promise.reject(new Error('Error')),
+      ],
+      delete: [
+        // Successfully deletes an identity
+        Promise.resolve({ ...IdentitiesDtoStub(), _id }),
+        // Simulates an error in deleting an identity
+        Promise.reject(new Error('Error')),
+      ],
+    });
 
     const module: TestingModule = await Test.createTestingModule({
       controllers: [IdentitiesController],
       providers: [
-        IdentitiesService,
+        { provide: IdentitiesService, useValue: service },
         { provide: getModelToken(Identities.name), useValue: identitiesModel },
         IdentitiesValidationService,
       ],
       imports: [IdentitiesValidationModule],
     }).compile();
 
     controller = module.get<IdentitiesController>(IdentitiesController);
-    service = module.get<IdentitiesService>(IdentitiesService);
-    _id = new Types.ObjectId();
+    //service = module.get<IdentitiesService>(IdentitiesService);
   }, 1200000);
 
   beforeEach(() => {
@@ -65,28 +107,15 @@ describe('IdentitiesController', () => {
   });
 
   describe('create', () => {
-    it('should create an identity', async () => {
-      jest.spyOn(service, 'create').mockResolvedValue(IdentitiesDtoStub() as Identities);
-
+    it('should create an identity with no errors', async () => {
       const createIdentity = await controller.create(response, IdentitiesDtoStub());
-      expect(createIdentity.statusCode).toMatch(new RegExp(`(${HttpStatus.CREATED})|(${HttpStatus.ACCEPTED})`));
+      expect(createIdentity.statusCode).toBe(HttpStatus.CREATED);
     });
 
-    // it('should handle ValidationSchemaException by returning the appropriate status code and message', async () => {
-    //   jest.spyOn(service, 'create').mockRejectedValue(
-    //     new ValidationSchemaException({
-    //       message: 'Schema validation failed',
-    //       validations: { field: 'error' },
-    //       statusCode: HttpStatus.BAD_REQUEST,
-    //     }),
-    //   );
-
-    //   const response = createResponse();
-    //   const identity = IdentitiesDtoStub();
-    //   const createIdentity = await controller.create(response, identity);
-    //   expect(createIdentity.statusCode).toBe(HttpStatus.ACCEPTED);
-    //   expect(response).toHaveProperty('greger');
-    // });
+    it('should create an identity with validations', async () => {
+      const createIdentity = await controller.create(response, IdentitiesDtoStub());
+      expect(createIdentity.statusCode).toBe(HttpStatus.ACCEPTED);
+    });
   });
 
   describe('search', () => {
@@ -96,7 +125,6 @@ describe('IdentitiesController', () => {
     });
 
     it('should throw an error when searching identities', async () => {
-      jest.spyOn(service, 'findAndCount').mockRejectedValueOnce(new Error('Error'));
       try {
         await controller.search(response, {}, searchFilterOptions);
       } catch (error) {
@@ -107,14 +135,11 @@ describe('IdentitiesController', () => {
 
   describe('read', () => {
     it('should find an identity', async () => {
-      const newIdentity = await service.create<Identities>(IdentitiesDtoStub());
-      const _id = newIdentity.id;
       const findIdentity = await controller.read(_id, response);
       expect(findIdentity.statusCode).toBe(HttpStatus.OK);
     });
 
     it('should throw an error when finding an identity', async () => {
-      jest.spyOn(service, 'findOne').mockRejectedValueOnce(new Error('Error'));
       try {
         await controller.read(_id, response);
       } catch (error) {
@@ -125,14 +150,11 @@ describe('IdentitiesController', () => {
 
   describe('update', () => {
     it('should update an identity', async () => {
-      const newIdentity = await service.create<Identities>(IdentitiesDtoStub());
-      const _id = newIdentity.id;
       const updateIdentity = await controller.update(_id, IdentitiesDtoStub(), response);
       expect(updateIdentity.statusCode).toBe(HttpStatus.OK);
     });
 
     it('should throw an error when updating an identity', async () => {
-      jest.spyOn(service, 'update').mockRejectedValueOnce(new Error('Error'));
       try {
         await controller.update(_id, IdentitiesDtoStub(), response);
       } catch (error) {
@@ -143,14 +165,11 @@ describe('IdentitiesController', () => {
 
   describe('delete', () => {
     it('should delete an identity', async () => {
-      const newIdentity = await service.create<Identities>(IdentitiesDtoStub());
-      const _id = newIdentity.id;
       const deleteIdentity = await controller.remove(_id, response);
       expect(deleteIdentity.statusCode).toBe(HttpStatus.OK);
     });
 
     it('should throw an error when deleting an identity', async () => {
-      jest.spyOn(service, 'delete').mockRejectedValueOnce(new Error('Error'));
       try {
         await controller.remove(_id, response);
       } catch (error) {