new authorization

src/modules/authentication/tests/unit/interface/add-username.grpc.controller.spec.ts

@@ -0,0 +1,89 @@
+import { IdResponse } from '@mobicoop/ddd-library';
+import { RpcExceptionCode } from '@mobicoop/ddd-library';
+import { UsernameAlreadyExistsException } from '@modules/authentication/core/domain/authentication.errors';
+import { Type } from '@modules/authentication/core/domain/username.types';
+import { AddUsernameGrpcController } from '@modules/authentication/interface/grpc-controllers/add-username.grpc.controller';
+import { AddUsernameRequestDto } from '@modules/authentication/interface/grpc-controllers/dtos/add-username.request.dto';
+import { CommandBus } from '@nestjs/cqrs';
+import { RpcException } from '@nestjs/microservices';
+import { Test, TestingModule } from '@nestjs/testing';
+
+const addUsernameRequest: AddUsernameRequestDto = {
+  userId: '78153e03-4861-4f58-a705-88526efee53b',
+  name: 'john.doe@email.com',
+  type: Type.EMAIL,
+};
+
+const mockCommandBus = {
+  execute: jest
+    .fn()
+    .mockImplementationOnce(() => 'john.doe@email.com')
+    .mockImplementationOnce(() => {
+      throw new UsernameAlreadyExistsException();
+    })
+    .mockImplementationOnce(() => {
+      throw new Error();
+    }),
+};
+
+describe('Add Username Grpc Controller', () => {
+  let addUsernameGrpcController: AddUsernameGrpcController;
+
+  beforeAll(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        {
+          provide: CommandBus,
+          useValue: mockCommandBus,
+        },
+        AddUsernameGrpcController,
+      ],
+    }).compile();
+
+    addUsernameGrpcController = module.get<AddUsernameGrpcController>(
+      AddUsernameGrpcController,
+    );
+  });
+
+  afterEach(async () => {
+    jest.clearAllMocks();
+  });
+
+  it('should be defined', () => {
+    expect(addUsernameGrpcController).toBeDefined();
+  });
+
+  it('should add a new username', async () => {
+    jest.spyOn(mockCommandBus, 'execute');
+    const result: IdResponse = await addUsernameGrpcController.addUsername(
+      addUsernameRequest,
+    );
+    expect(result).toBeInstanceOf(IdResponse);
+    expect(result.id).toBe('john.doe@email.com');
+    expect(mockCommandBus.execute).toHaveBeenCalledTimes(1);
+  });
+
+  it('should throw a dedicated RpcException if username already exists', async () => {
+    jest.spyOn(mockCommandBus, 'execute');
+    expect.assertions(3);
+    try {
+      await addUsernameGrpcController.addUsername(addUsernameRequest);
+    } catch (e: any) {
+      expect(e).toBeInstanceOf(RpcException);
+      expect(e.error.code).toBe(RpcExceptionCode.ALREADY_EXISTS);
+    }
+    expect(mockCommandBus.execute).toHaveBeenCalledTimes(1);
+  });
+
+  it('should throw a generic RpcException', async () => {
+    jest.spyOn(mockCommandBus, 'execute');
+    expect.assertions(3);
+    try {
+      await addUsernameGrpcController.addUsername(addUsernameRequest);
+    } catch (e: any) {
+      expect(e).toBeInstanceOf(RpcException);
+      expect(e.error.code).toBe(RpcExceptionCode.UNKNOWN);
+    }
+    expect(mockCommandBus.execute).toHaveBeenCalledTimes(1);
+  });
+});

src/modules/authentication/tests/unit/interface/create-authentication.grpc.controller.spec.ts

@@ -0,0 +1,99 @@
+import { IdResponse } from '@mobicoop/ddd-library';
+import { RpcExceptionCode } from '@mobicoop/ddd-library';
+import { AuthenticationAlreadyExistsException } from '@modules/authentication/core/domain/authentication.errors';
+import { Type } from '@modules/authentication/core/domain/username.types';
+import { CreateAuthenticationGrpcController } from '@modules/authentication/interface/grpc-controllers/create-authentication.grpc.controller';
+import { CreateAuthenticationRequestDto } from '@modules/authentication/interface/grpc-controllers/dtos/create-authentication.request.dto';
+import { CommandBus } from '@nestjs/cqrs';
+import { RpcException } from '@nestjs/microservices';
+import { Test, TestingModule } from '@nestjs/testing';
+
+const createAuthenticationRequest: CreateAuthenticationRequestDto = {
+  userId: '78153e03-4861-4f58-a705-88526efee53b',
+  password: 'John123',
+  usernames: [
+    {
+      name: 'john.doe@email.com',
+      type: Type.EMAIL,
+    },
+  ],
+};
+
+const mockCommandBus = {
+  execute: jest
+    .fn()
+    .mockImplementationOnce(() => '78153e03-4861-4f58-a705-88526efee53b')
+    .mockImplementationOnce(() => {
+      throw new AuthenticationAlreadyExistsException();
+    })
+    .mockImplementationOnce(() => {
+      throw new Error();
+    }),
+};
+
+describe('Create Authentication Grpc Controller', () => {
+  let createAuthenticationGrpcController: CreateAuthenticationGrpcController;
+
+  beforeAll(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        {
+          provide: CommandBus,
+          useValue: mockCommandBus,
+        },
+        CreateAuthenticationGrpcController,
+      ],
+    }).compile();
+
+    createAuthenticationGrpcController =
+      module.get<CreateAuthenticationGrpcController>(
+        CreateAuthenticationGrpcController,
+      );
+  });
+
+  afterEach(async () => {
+    jest.clearAllMocks();
+  });
+
+  it('should be defined', () => {
+    expect(createAuthenticationGrpcController).toBeDefined();
+  });
+
+  it('should create a new authentication', async () => {
+    jest.spyOn(mockCommandBus, 'execute');
+    const result: IdResponse = await createAuthenticationGrpcController.create(
+      createAuthenticationRequest,
+    );
+    expect(result).toBeInstanceOf(IdResponse);
+    expect(result.id).toBe('78153e03-4861-4f58-a705-88526efee53b');
+    expect(mockCommandBus.execute).toHaveBeenCalledTimes(1);
+  });
+
+  it('should throw a dedicated RpcException if authentication already exists', async () => {
+    jest.spyOn(mockCommandBus, 'execute');
+    expect.assertions(3);
+    try {
+      await createAuthenticationGrpcController.create(
+        createAuthenticationRequest,
+      );
+    } catch (e: any) {
+      expect(e).toBeInstanceOf(RpcException);
+      expect(e.error.code).toBe(RpcExceptionCode.ALREADY_EXISTS);
+    }
+    expect(mockCommandBus.execute).toHaveBeenCalledTimes(1);
+  });
+
+  it('should throw a generic RpcException', async () => {
+    jest.spyOn(mockCommandBus, 'execute');
+    expect.assertions(3);
+    try {
+      await createAuthenticationGrpcController.create(
+        createAuthenticationRequest,
+      );
+    } catch (e: any) {
+      expect(e).toBeInstanceOf(RpcException);
+      expect(e.error.code).toBe(RpcExceptionCode.UNKNOWN);
+    }
+    expect(mockCommandBus.execute).toHaveBeenCalledTimes(1);
+  });
+});

src/modules/authentication/tests/unit/interface/delete-authentication.grpc.controller.spec.ts

@@ -0,0 +1,108 @@
+import {
+  DatabaseErrorException,
+  NotFoundException,
+} from '@mobicoop/ddd-library';
+import { RpcExceptionCode } from '@mobicoop/ddd-library';
+import { DeleteAuthenticationGrpcController } from '@modules/authentication/interface/grpc-controllers/delete-authentication.grpc.controller';
+import { DeleteAuthenticationRequestDto } from '@modules/authentication/interface/grpc-controllers/dtos/delete-authentication.request.dto';
+import { CommandBus } from '@nestjs/cqrs';
+import { RpcException } from '@nestjs/microservices';
+import { Test, TestingModule } from '@nestjs/testing';
+
+const deleteAuthenticationRequest: DeleteAuthenticationRequestDto = {
+  userId: '78153e03-4861-4f58-a705-88526efee53b',
+};
+
+const mockCommandBus = {
+  execute: jest
+    .fn()
+    .mockImplementationOnce(() => ({}))
+    .mockImplementationOnce(() => {
+      throw new NotFoundException();
+    })
+    .mockImplementationOnce(() => {
+      throw new DatabaseErrorException();
+    })
+    .mockImplementationOnce(() => {
+      throw new Error();
+    }),
+};
+
+describe('Delete Authentication Grpc Controller', () => {
+  let deleteAuthenticationGrpcController: DeleteAuthenticationGrpcController;
+
+  beforeAll(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        {
+          provide: CommandBus,
+          useValue: mockCommandBus,
+        },
+        DeleteAuthenticationGrpcController,
+      ],
+    }).compile();
+
+    deleteAuthenticationGrpcController =
+      module.get<DeleteAuthenticationGrpcController>(
+        DeleteAuthenticationGrpcController,
+      );
+  });
+
+  afterEach(async () => {
+    jest.clearAllMocks();
+  });
+
+  it('should be defined', () => {
+    expect(deleteAuthenticationGrpcController).toBeDefined();
+  });
+
+  it('should create a new authentication', async () => {
+    jest.spyOn(mockCommandBus, 'execute');
+    await deleteAuthenticationGrpcController.delete(
+      deleteAuthenticationRequest,
+    );
+    expect(mockCommandBus.execute).toHaveBeenCalledTimes(1);
+  });
+
+  it('should throw a dedicated RpcException if authentication does not exist', async () => {
+    jest.spyOn(mockCommandBus, 'execute');
+    expect.assertions(3);
+    try {
+      await deleteAuthenticationGrpcController.delete(
+        deleteAuthenticationRequest,
+      );
+    } catch (e: any) {
+      expect(e).toBeInstanceOf(RpcException);
+      expect(e.error.code).toBe(RpcExceptionCode.NOT_FOUND);
+    }
+    expect(mockCommandBus.execute).toHaveBeenCalledTimes(1);
+  });
+
+  it('should throw a dedicated RpcException if a database error occurs', async () => {
+    jest.spyOn(mockCommandBus, 'execute');
+    expect.assertions(3);
+    try {
+      await deleteAuthenticationGrpcController.delete(
+        deleteAuthenticationRequest,
+      );
+    } catch (e: any) {
+      expect(e).toBeInstanceOf(RpcException);
+      expect(e.error.code).toBe(RpcExceptionCode.INTERNAL);
+    }
+    expect(mockCommandBus.execute).toHaveBeenCalledTimes(1);
+  });
+
+  it('should throw a generic RpcException', async () => {
+    jest.spyOn(mockCommandBus, 'execute');
+    expect.assertions(3);
+    try {
+      await deleteAuthenticationGrpcController.delete(
+        deleteAuthenticationRequest,
+      );
+    } catch (e: any) {
+      expect(e).toBeInstanceOf(RpcException);
+      expect(e.error.code).toBe(RpcExceptionCode.UNKNOWN);
+    }
+    expect(mockCommandBus.execute).toHaveBeenCalledTimes(1);
+  });
+});

src/modules/authentication/tests/unit/interface/is-valid-username.decorator.spec.ts

@@ -0,0 +1,57 @@
+import { Type } from '@modules/authentication/core/domain/username.types';
+import { IsValidUsername } from '@modules/authentication/interface/grpc-controllers/dtos/validators/decorators/is-valid-username.decorator';
+import { Validator } from 'class-validator';
+
+describe('Username decorator', () => {
+  class MyClass {
+    @IsValidUsername({
+      message: 'Invalid username',
+    })
+    name: string;
+
+    type: Type;
+  }
+  it('should return a property decorator has a function', () => {
+    const isValidUsername = IsValidUsername();
+    expect(typeof isValidUsername).toBe('function');
+  });
+  it('should validate a valid phone username', async () => {
+    const myClassInstance = new MyClass();
+    myClassInstance.name = '+33611223344';
+    myClassInstance.type = Type.PHONE;
+    const validator = new Validator();
+    const validation = await validator.validate(myClassInstance);
+    expect(validation.length).toBe(0);
+  });
+  it('should validate a valid email username', async () => {
+    const myClassInstance = new MyClass();
+    myClassInstance.name = 'john.doe@email.com';
+    myClassInstance.type = Type.EMAIL;
+    const validator = new Validator();
+    const validation = await validator.validate(myClassInstance);
+    expect(validation.length).toBe(0);
+  });
+  it('should not validate an invalid phone username', async () => {
+    const myClassInstance = new MyClass();
+    myClassInstance.name = '11223344';
+    myClassInstance.type = Type.PHONE;
+    const validator = new Validator();
+    const validation = await validator.validate(myClassInstance);
+    expect(validation.length).toBe(1);
+  });
+  it('should not validate an invalid email username', async () => {
+    const myClassInstance = new MyClass();
+    myClassInstance.name = 'john.doe.email.com';
+    myClassInstance.type = Type.EMAIL;
+    const validator = new Validator();
+    const validation = await validator.validate(myClassInstance);
+    expect(validation.length).toBe(1);
+  });
+  it('should not validate if type is not set', async () => {
+    const myClassInstance = new MyClass();
+    myClassInstance.name = 'john.doe@email.com';
+    const validator = new Validator();
+    const validation = await validator.validate(myClassInstance);
+    expect(validation.length).toBe(1);
+  });
+});