WIP implements identities

Author: tacxou

service/src/core/core.module.ts

@@ -3,24 +3,30 @@ import { RouterModule } from '@nestjs/core'
 import { CoreService } from '~/core/core.service'
 import { CoreController } from '~/core/core.controller'
 import { AuthModule } from './auth/auth.module'
-import { UsersModule } from './users/users.module'
 import { CategoriesModule } from './categories/categories.module'
 import { ProjectModule } from './projects/project.module'
 import { TriggersModule } from './triggers/triggers.module'
 import { CrontabsModule } from './crontabs/crontabs.module'
 import { PreferencesModule } from './preferences/preferences.module'
 import { FilestorageModule } from './filestorage/filestorage.module'
+import { EntitesModule } from '~/core/entites/entites.module'
+import { IdentitiesModule } from '~/core/identities/identities.module'
 
 @Module({
   imports: [
     AuthModule,
-    UsersModule,
     CategoriesModule,
-    ProjectModule, 
+    ProjectModule,
     TriggersModule,
     CrontabsModule,
     PreferencesModule,
     FilestorageModule,
+    CategoriesModule,
+    ProjectModule,
+    TriggersModule,
+    CrontabsModule,
+    EntitesModule,
+    IdentitiesModule,
   ],
   providers: [CoreService],
   controllers: [CoreController],

service/src/core/identities/dto/identities.dto.ts

@@ -0,0 +1,7 @@
+import { PartialType } from "@nestjs/swagger"
+
+export class IdentitiesCreateDto {
+
+}
+
+export class IdentitiesUpdateDto extends PartialType(IdentitiesCreateDto) {}

service/src/core/identities/identities.controller.spec.ts

@@ -0,0 +1,199 @@
+import { DeleteResult } from 'mongodb'
+import { Test, TestingModule } from '@nestjs/testing'
+import { IdentitiesController } from './identities.controller'
+import { IdentitiesService } from './identities.service'
+import { IdentitiesDto } from './dto/identities.dto'
+import { Identities } from './schemas/identities.schema'
+import { HttpException, HttpStatus } from '@nestjs/common'
+import { Types } from 'mongoose'
+import { Response, Request } from 'express'
+import { getMockReq, getMockRes } from '@jest-mock/express'
+
+describe('IdentitiesController', () => {
+  let controller: IdentitiesController
+  let service: IdentitiesService
+  const date = new Date()
+  const _id = new Types.ObjectId()
+  const { res, mockClear } = getMockRes()
+  const object: Identities = {
+    _id,
+    metadata: {
+      createdAt: date,
+      createdBy: 'console',
+      lastUpdateAt: date,
+      lastUpdateBy: 'console',
+    },
+    info: [],
+  }
+
+  beforeEach(async () => {
+    mockClear()
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [IdentitiesController],
+      providers: [
+        IdentitiesService,
+        {
+          provide: IdentitiesService,
+          useValue: {
+            search: jest.fn().mockResolvedValue([[object], 1]),
+            create: jest.fn().mockResolvedValue(object),
+            read: jest.fn().mockResolvedValue(object),
+            update: jest.fn().mockResolvedValue(object),
+            remove: jest.fn().mockResolvedValue({
+              acknowledged: true,
+              deletedCount: 1,
+            }),
+          },
+        },
+      ],
+    }).compile()
+
+    controller = module.get<IdentitiesController>(IdentitiesController)
+    service = module.get<IdentitiesService>(IdentitiesService)
+  })
+
+  describe('search', () => {
+    it('should return an array of Identities objects and the total count', async () => {
+      const req = getMockReq()
+      const query = { _id: _id.toString() }
+      const limit = 10
+      const skip = 1
+      const expectedResult: [Identities[], number] = [[object], 1]
+      jest.spyOn(service, 'search').mockImplementation(async () => await expectedResult)
+      const response = await controller.search(req, res, query, limit.toString(), skip.toString(), null)
+      expect(response.json).toHaveBeenCalledWith({ data: expectedResult[0], total: expectedResult[1] })
+      expect(response.status).toHaveBeenCalledWith(HttpStatus.OK)
+    })
+
+    it('should return an array of Identities objects with default pagination', async () => {
+      const req = getMockReq()
+      const query = { _id: _id.toString() }
+      const limit = 0
+      const skip = 0
+      const expectedResult: [Identities[], number] = [[object], 1]
+      jest.spyOn(service, 'search').mockImplementation(async () => await expectedResult)
+      const response = await controller.search(req, res, query, limit.toString(), skip.toString(), null)
+      expect(response.json).toHaveBeenCalledWith({ data: expectedResult[0], total: expectedResult[1] })
+      expect(response.status).toHaveBeenCalledWith(HttpStatus.OK)
+    })
+
+    it('should throw HttpException with BAD_REQUEST status when an error occurs', async () => {
+      const req = {} as Request
+      const res = {} as Response
+      const query = { someParam: 'value' }
+      const limit = 10
+      const skip = 0
+      jest.spyOn(service, 'search').mockRejectedValue(new Error('Something went wrong'))
+
+      try {
+        await controller.search(req, res, query, limit.toString(), skip.toString(), null)
+      } catch (error) {
+        const status = error.getStatus()
+        const response = error.getResponse()
+
+        expect(error).toBeInstanceOf(HttpException)
+        expect(status).toBe(400)
+        expect(response).toBe('Something went wrong')
+      }
+    })
+  })
+
+  describe('read', () => {
+    it('should return the data successfully', async () => {
+      const expectedResult: Identities = object
+      jest.spyOn(service, 'read').mockImplementation(async () => await expectedResult)
+      const result = await controller.read(_id.toString(), res)
+      expect(res.status).toHaveBeenCalledWith(HttpStatus.OK)
+      expect(res.json).toHaveBeenCalledWith(expectedResult)
+      expect(result).toEqual(res)
+    })
+
+    it('should throw an HttpException with the error message', async () => {
+      const errorMessage = 'Error message'
+      jest.spyOn(service, 'read').mockRejectedValue(new Error(errorMessage))
+      try {
+        await controller.read(_id.toString(), res)
+      } catch (error) {
+        expect(error.getStatus()).toBe(HttpStatus.BAD_REQUEST)
+        expect(error.getResponse()).toBe(errorMessage)
+      }
+    })
+  })
+
+  describe('create', () => {
+    it('should return a Identities object', async () => {
+      const dto: IdentitiesDto = { someProp: 'value' }
+      const expectedResult = object
+      jest.spyOn(service, 'create').mockImplementation(async () => await expectedResult)
+      const response = await controller.create(dto, res)
+      expect(response.status).toHaveBeenCalledWith(HttpStatus.CREATED)
+      expect(response.json).toHaveBeenCalledWith(expectedResult)
+    })
+
+    it('should throw HttpException with BAD_REQUEST status when an error occurs', async () => {
+      const dto: IdentitiesDto = { someProp: 'value' }
+      jest.spyOn(service, 'create').mockRejectedValue(new Error('Something went wrong'))
+
+      try {
+        await controller.create(dto, res)
+      } catch (error) {
+        expect(error).toBeInstanceOf(HttpException)
+        expect(error.getStatus()).toBe(400)
+        expect(error.getResponse()).toBe('Something went wrong')
+      }
+    })
+  })
+
+  describe('update', () => {
+    it('should return a Identities object', async () => {
+      const id = _id.toString()
+      const dto: IdentitiesDto = { someProp: 'value' }
+      const expectedResult: Identities = object
+      jest.spyOn(service, 'update').mockImplementation(async () => await expectedResult)
+      const response = await controller.update(id, dto, res)
+      expect(response.status).toHaveBeenCalledWith(HttpStatus.OK)
+      expect(response.json).toHaveBeenCalledWith(expectedResult)
+    })
+
+    it('should throw HttpException with BAD_REQUEST status when an error occurs', async () => {
+      const id = _id.toString()
+      const dto: IdentitiesDto = { someProp: 'value' }
+      jest.spyOn(service, 'update').mockRejectedValue(new Error('Something went wrong'))
+
+      try {
+        await controller.update(id, dto, res)
+      } catch (error) {
+        expect(error).toBeInstanceOf(HttpException)
+        expect(error.getStatus()).toBe(400)
+        expect(error.getResponse()).toBe('Something went wrong')
+      }
+    })
+  })
+
+  describe('remove', () => {
+    it('should return a Identities object', async () => {
+      const id = _id.toString()
+      const expectedResult: DeleteResult = {
+        acknowledged: true,
+        deletedCount: 1,
+      }
+      jest.spyOn(service, 'remove').mockImplementation(async () => await expectedResult)
+      const response = await controller.remove(id, res)
+      expect(response.status).toHaveBeenCalledWith(HttpStatus.OK)
+      expect(response.json).toHaveBeenCalledWith(expectedResult)
+    })
+
+    it('should throw HttpException with BAD_REQUEST status when an error occurs', async () => {
+      const id = _id.toString()
+      jest.spyOn(service, 'remove').mockRejectedValue(new Error('Something went wrong'))
+
+      try {
+        await controller.remove(id, res)
+      } catch (error) {
+        expect(error).toBeInstanceOf(HttpException)
+        expect(error.getStatus()).toBe(400)
+        expect(error.getResponse()).toBe('Something went wrong')
+      }
+    })
+  })
+})

service/src/core/identities/identities.controller.ts

@@ -0,0 +1,10 @@
+import { Controller } from '@nestjs/common'
+import { IdentitiesService } from './identities.service'
+import { AbstractController } from '~/_common/abstracts/abstract.controller'
+
+@Controller('identities')
+export class IdentitiesController extends AbstractController {
+  constructor(private readonly service: IdentitiesService) {
+    super()
+  }
+}

service/src/core/identities/identities.module.ts

@@ -0,0 +1,19 @@
+import { Module } from '@nestjs/common'
+import { MongooseModule } from '@nestjs/mongoose'
+import { IdentitiesSchema, Identities } from './schemas/identities.schema'
+import { IdentitiesService } from './identities.service'
+import { IdentitiesController } from './identities.controller'
+
+@Module({
+  imports: [
+    MongooseModule.forFeatureAsync([
+      {
+        name: Identities.name,
+        useFactory: () => IdentitiesSchema,
+      },
+    ]),
+  ],
+  providers: [IdentitiesService],
+  controllers: [IdentitiesController],
+})
+export class IdentitiesModule {}

service/src/core/identities/identities.service.spec.ts

@@ -0,0 +1,105 @@
+import { DeleteResult } from 'mongodb'
+import { Test, TestingModule } from '@nestjs/testing'
+import { IdentitiesService } from './identities.service'
+import { getModelToken } from '@nestjs/mongoose'
+import { Identities } from './schemas/identities.schema'
+import { Model, Types } from 'mongoose'
+
+describe('IdentitiesService', () => {
+  let service: IdentitiesService
+  let model: Model<Identities>
+  const _id = new Types.ObjectId()
+  const date = new Date()
+  const mockIdentities: Identities = {
+    _id,
+    metadata: {
+      createdAt: date,
+      createdBy: 'console',
+      lastUpdateAt: date,
+      lastUpdateBy: 'console',
+    },
+    info: [],
+  }
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        IdentitiesService,
+        {
+          provide: getModelToken(Identities.name),
+          useValue: Model,
+        },
+      ],
+    }).compile()
+    service = module.get<IdentitiesService>(IdentitiesService)
+    model = module.get<Model<Identities>>(getModelToken(Identities.name))
+  })
+
+  describe('create', () => {
+    it('should create a new record', async () => {
+      const createTest = {}
+      jest.spyOn(model, 'create').mockImplementationOnce(() => Promise.resolve(mockIdentities))
+      const result = await service.create(createTest)
+      expect(result).toEqual(mockIdentities)
+    })
+  })
+
+  describe('search', () => {
+    it('should return an array of records and total count', async () => {
+      const expected = [mockIdentities]
+      const total = 1
+      jest.spyOn(model, 'countDocuments').mockResolvedValueOnce(total)
+      jest.spyOn(model, 'find').mockResolvedValueOnce(expected)
+      const [result, resultTotal] = await service.search()
+      expect(result).toEqual(expected)
+      expect(resultTotal).toEqual(total)
+    })
+
+    it('should return an empty array if no records are found', async () => {
+      const expected = []
+      const total = 0
+      jest.spyOn(model, 'countDocuments').mockResolvedValueOnce(total)
+      jest.spyOn(model, 'find').mockResolvedValueOnce(expected)
+      const [result, resultTotal] = await service.search()
+      expect(result).toEqual(expected)
+      expect(resultTotal).toEqual(total)
+    })
+  })
+
+  describe('read', () => {
+    it('should return a Identities record by ID', async () => {
+      const expected = mockIdentities
+      jest.spyOn(model, 'findById').mockResolvedValueOnce(expected)
+      const result = await service.read(_id.toString())
+      expect(result).toEqual(expected)
+    })
+
+    it('should return null if Identities record is not found', async () => {
+      const expected = null
+      jest.spyOn(model, 'findById').mockResolvedValueOnce(expected)
+      const result = await service.read('123')
+      expect(result).toEqual(expected)
+    })
+  })
+
+  describe('update', () => {
+    it('should update a Identities record by ID with metadata', async () => {
+      const identitiesDto = { info: { key: 'updated value' } }
+      const newObject = { ...mockIdentities }
+      const expected = newObject.info.push(identitiesDto.info)
+      jest.spyOn(model, 'findByIdAndUpdate').mockResolvedValueOnce(expected)
+      const result = await service.update(_id.toString(), identitiesDto)
+      expect(result).toEqual(expected)
+    })
+  })
+
+  describe('remove', () => {
+    it('should remove a Identities record by ID', async () => {
+      const id = '123'
+      const deleteResult: DeleteResult = { acknowledged: true, deletedCount: 1 }
+      jest.spyOn(model, 'deleteOne').mockResolvedValueOnce(deleteResult)
+      const result = await service.remove(id)
+      expect(result).toEqual(deleteResult)
+    })
+  })
+})

service/src/core/identities/identities.service.ts

@@ -0,0 +1,13 @@
+import { Injectable } from '@nestjs/common'
+import { InjectModel } from '@nestjs/mongoose'
+import { Identities } from './schemas/identities.schema'
+import { Model } from 'mongoose'
+import { AbstractService } from '~/_common/abstracts/abstract.service'
+
+@Injectable()
+export class IdentitiesService extends AbstractService {
+  constructor(@InjectModel(Identities.name) protected model: Model<Identities>,
+  ) {
+    super()
+  }
+}