WIP Crontabs

Author: RICHARD-Quentin

service/src/core/core.module.ts

@@ -2,15 +2,15 @@ import { DynamicModule, Module } from '@nestjs/common'
 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 { 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';
 
 @Module({
-  imports: [
-  AuthModule,
-  UsersModule,
-  CategoriesModule],
+  imports: [AuthModule, UsersModule, CategoriesModule, ProjectModule, TriggersModule, CrontabsModule],
   providers: [CoreService],
   controllers: [CoreController],
 })

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

@@ -0,0 +1,199 @@
+import { DeleteResult } from 'mongodb'
+import { Test, TestingModule } from '@nestjs/testing'
+import { CrontabsController } from './crontabs.controller'
+import { CrontabsService } from './crontabs.service'
+import { CrontabsDto } from './dto/crontabs.dto'
+import { Crontabs } from './schemas/crontabs.schema'
+import { HttpException, HttpStatus } from '@nestjs/common'
+import { Types } from 'mongoose'
+import { Response, Request } from 'express'
+import { getMockReq, getMockRes } from '@jest-mock/express'
+
+describe('CrontabsController', () => {
+  let controller: CrontabsController
+  let service: CrontabsService
+  const date = new Date()
+  const _id = new Types.ObjectId()
+  const { res, mockClear } = getMockRes()
+  const object: Crontabs = {
+    _id,
+    metadata: {
+      createdAt: date,
+      createdBy: 'console',
+      lastUpdateAt: date,
+      lastUpdateBy: 'console',
+    },
+    info: [],
+  }
+
+  beforeEach(async () => {
+    mockClear()
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [CrontabsController],
+      providers: [
+        CrontabsService,
+        {
+          provide: CrontabsService,
+          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<CrontabsController>(CrontabsController)
+    service = module.get<CrontabsService>(CrontabsService)
+  })
+
+  describe('search', () => {
+    it('should return an array of Crontabs objects and the total count', async () => {
+      const req = getMockReq()
+      const query = { _id: _id.toString() }
+      const limit = 10
+      const skip = 1
+      const expectedResult: [Crontabs[], 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 Crontabs objects with default pagination', async () => {
+      const req = getMockReq()
+      const query = { _id: _id.toString() }
+      const limit = 0
+      const skip = 0
+      const expectedResult: [Crontabs[], 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: Crontabs = 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 Crontabs object', async () => {
+      const dto: CrontabsDto = { 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: CrontabsDto = { 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 Crontabs object', async () => {
+      const id = _id.toString()
+      const dto: CrontabsDto = { someProp: 'value' }
+      const expectedResult: Crontabs = 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: CrontabsDto = { 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 Crontabs 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/crontabs/crontabs.controller.ts

@@ -0,0 +1,68 @@
+import { Body, Controller, Delete, Get, HttpStatus, Param, Patch, Post, Req, Res } from '@nestjs/common'
+import { CrontabsCreateDto, CrontabsUpdateDto } from './dto/crontabs.dto'
+import { CrontabsService } from './crontabs.service'
+import { AbstractController } from '~/_common/abstracts/abstract.controller'
+import { ApiParam } from '@nestjs/swagger'
+import { SearchFilterSchema, FilterSchema, SearchFilterOptions, FilterOptions, ObjectIdValidationPipe } from '@streamkits/nestjs_module_scrud'
+import { Types } from 'mongoose'
+import { Request, Response } from 'express'
+@Controller('crontabs')
+export class CrontabsController extends AbstractController {
+  protected readonly projection = {
+    name: 1,
+    description: 1,
+  }
+
+  constructor(private readonly _service: CrontabsService) {
+    super()
+  }
+
+  @Post()
+  public async create(@Req() req: Request, @Res() res: Response, @Body() body: CrontabsCreateDto) {
+    const data = await this._service.create(body)
+    return res.status(HttpStatus.CREATED).json({
+      statusCode: HttpStatus.CREATED,
+      data,
+    })
+  }
+
+  @Get()
+  public async search(@Res() res: Response, @SearchFilterSchema() searchFilterSchema: FilterSchema, @SearchFilterOptions() searchFilterOptions: FilterOptions) {
+    const [data, total] = await this._service.findAndCount(searchFilterSchema, this.projection, searchFilterOptions)
+    return res.status(HttpStatus.OK).json({
+      statusCode: HttpStatus.OK,
+      total,
+      data,
+    })
+  }
+
+  @Get(':_id([0-9a-fA-F]{24})')
+  @ApiParam({ name: '_id', type: String })
+  public async read(@Param('_id', ObjectIdValidationPipe) _id: Types.ObjectId, @Res() res: Response) {
+    const data = await this._service.findById(_id)
+    return res.status(HttpStatus.OK).json({
+      statusCode: HttpStatus.OK,
+      data,
+    })
+  }
+
+  @Patch(':_id([0-9a-fA-F]{24})')
+  @ApiParam({ name: '_id', type: String })
+  public async update(@Param('_id', ObjectIdValidationPipe) _id: Types.ObjectId, @Body() body: CrontabsUpdateDto, @Res() res: Response) {
+    const data = await this._service.update(_id, body)
+    return res.status(HttpStatus.OK).json({
+      statusCode: HttpStatus.OK,
+      data,
+    })
+  }
+
+  @Delete(':_id([0-9a-fA-F]{24})')
+  @ApiParam({ name: '_id', type: String })
+  public async remove(@Param('_id', ObjectIdValidationPipe) _id: Types.ObjectId, @Res() res: Response) {
+    const data = await this._service.delete(_id)
+    return res.status(HttpStatus.OK).json({
+      statusCode: HttpStatus.OK,
+      data,
+    })
+  }
+}

service/src/core/crontabs/crontabs.service.spec.ts

@@ -0,0 +1,105 @@
+import { DeleteResult } from 'mongodb'
+import { Test, TestingModule } from '@nestjs/testing'
+import { CrontabsService } from './crontabs.service'
+import { getModelToken } from '@nestjs/mongoose'
+import { Crontabs } from './schemas/crontabs.schema'
+import { Model, Types } from 'mongoose'
+
+describe('CrontabsService', () => {
+  let service: CrontabsService
+  let model: Model<Crontabs>
+  const _id = new Types.ObjectId()
+  const date = new Date()
+  const mockCrontabs: Crontabs = {
+    _id,
+    metadata: {
+      createdAt: date,
+      createdBy: 'console',
+      lastUpdateAt: date,
+      lastUpdateBy: 'console',
+    },
+    info: [],
+  }
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        CrontabsService,
+        {
+          provide: getModelToken(Crontabs.name),
+          useValue: Model,
+        },
+      ],
+    }).compile()
+    service = module.get<CrontabsService>(CrontabsService)
+    model = module.get<Model<Crontabs>>(getModelToken(Crontabs.name))
+  })
+
+  describe('create', () => {
+    it('should create a new record', async () => {
+      const createTest = {}
+      jest.spyOn(model, 'create').mockImplementationOnce(() => Promise.resolve(mockCrontabs))
+      const result = await service.create(createTest)
+      expect(result).toEqual(mockCrontabs)
+    })
+  })
+
+  describe('search', () => {
+    it('should return an array of records and total count', async () => {
+      const expected = [mockCrontabs]
+      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 Crontabs record by ID', async () => {
+      const expected = mockCrontabs
+      jest.spyOn(model, 'findById').mockResolvedValueOnce(expected)
+      const result = await service.read(_id.toString())
+      expect(result).toEqual(expected)
+    })
+
+    it('should return null if Crontabs 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 Crontabs record by ID with metadata', async () => {
+      const crontabsDto = { info: { key: 'updated value' } }
+      const newObject = { ...mockCrontabs }
+      const expected = newObject.info.push(crontabsDto.info)
+      jest.spyOn(model, 'findByIdAndUpdate').mockResolvedValueOnce(expected)
+      const result = await service.update(_id.toString(), crontabsDto)
+      expect(result).toEqual(expected)
+    })
+  })
+
+  describe('remove', () => {
+    it('should remove a Crontabs 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)
+    })
+  })
+})