multithread build creation supported

closes Visual-Regression-Tracker/Visual-Regression-Tracker#258

Author: pashidlos

src/_data_/index.ts

@@ -1,4 +1,4 @@
-import { Project } from '@prisma/client';
+import { Build, Project } from '@prisma/client';
 
 export const TEST_PROJECT: Project = {
   id: '1',
@@ -8,3 +8,16 @@ export const TEST_PROJECT: Project = {
   createdAt: new Date(),
   updatedAt: new Date(),
 };
+
+export const TEST_BUILD: Build = {
+  id: 'a9385fc1-884d-4f9f-915e-40da0e7773d5',
+  ciBuildId: 'ciBuildId',
+  number: 2345,
+  branchName: 'develop',
+  status: 'new',
+  projectId: 'e0a37894-6f29-478d-b13e-6182fecc715e',
+  updatedAt: new Date(),
+  createdAt: new Date(),
+  userId: '2341235',
+  isRunning: true,
+};

src/builds/builds.controller.spec.ts

@@ -4,25 +4,100 @@ import { BuildsService } from './builds.service';
 import { PrismaService } from '../prisma/prisma.service';
 import { ApiGuard } from '../auth/guards/api.guard';
 import { JwtAuthGuard } from '../auth/guards/auth.guard';
+import { ProjectsService } from '../projects/projects.service';
+import { TEST_BUILD, TEST_PROJECT } from '../_data_';
+import { Build } from '.prisma/client';
+import { BuildDto } from './dto/build.dto';
+import { CreateBuildDto } from './dto/build-create.dto';
+import { EventsGateway } from '../shared/events/events.gateway';
 
+const initController = async ({
+  projectFindOneMock = jest.fn(),
+  buildFindOrCreateMock = jest.fn(),
+  buildIncrementBuildNumberMock = jest.fn(),
+  eventBuildCreatedMock = jest.fn(),
+}) => {
+  const module: TestingModule = await Test.createTestingModule({
+    controllers: [BuildsController],
+    providers: [
+      {
+        provide: ProjectsService,
+        useValue: {
+          findOne: projectFindOneMock,
+        },
+      },
+      {
+        provide: BuildsService,
+        useValue: {
+          findOrCreate: buildFindOrCreateMock,
+          incrementBuildNumber: buildIncrementBuildNumberMock,
+        },
+      },
+      { provide: EventsGateway, useValue: { buildCreated: eventBuildCreatedMock } },
+      { provide: PrismaService, useValue: {} },
+      { provide: ApiGuard, useValue: {} },
+      { provide: JwtAuthGuard, useValue: {} },
+    ],
+  }).compile();
+
+  return module.get<BuildsController>(BuildsController);
+};
 describe('Builds Controller', () => {
   let controller: BuildsController;
 
-  beforeEach(async () => {
-    const module: TestingModule = await Test.createTestingModule({
-      controllers: [BuildsController],
-      providers: [
-        { provide: BuildsService, useValue: {} },
-        { provide: PrismaService, useValue: {} },
-        { provide: ApiGuard, useValue: {} },
-        { provide: JwtAuthGuard, useValue: {} },
-      ],
-    }).compile();
-
-    controller = module.get<BuildsController>(BuildsController);
-  });
+  const createBuildDto: CreateBuildDto = {
+    ciBuildId: 'ciBuildId',
+    branchName: 'branchName',
+    project: 'name',
+  };
+  const project = TEST_PROJECT;
+  const newBuild: Build = {
+    ...TEST_BUILD,
+    number: null,
+  };
+  const buildWithNumber: Build = {
+    ...TEST_BUILD,
+    number: 12,
+  };
+
+  beforeEach(async () => {});
 
-  it('should be defined', () => {
+  it('should be defined', async () => {
+    controller = await initController({});
     expect(controller).toBeDefined();
   });
+
+  it('should create new build', async () => {
+    const eventBuildCreatedMock = jest.fn();
+    const projectFindOneMock = jest.fn().mockResolvedValueOnce(project);
+    const buildFindOrCreateMock = jest.fn().mockResolvedValueOnce(newBuild);
+    const buildIncrementBuildNumberMock = jest.fn().mockResolvedValueOnce(buildWithNumber);
+    controller = await initController({
+      projectFindOneMock,
+      buildFindOrCreateMock,
+      buildIncrementBuildNumberMock,
+      eventBuildCreatedMock,
+    });
+
+    const result = await controller.create(createBuildDto);
+
+    expect(result).toStrictEqual(new BuildDto(buildWithNumber));
+    expect(buildIncrementBuildNumberMock).toHaveBeenCalledWith(newBuild.id, project.id);
+    expect(eventBuildCreatedMock).toHaveBeenCalledWith(new BuildDto(buildWithNumber));
+  });
+
+  it('should reuse build', async () => {
+    const eventBuildCreatedMock = jest.fn();
+    const projectFindOneMock = jest.fn().mockResolvedValueOnce(project);
+    const buildFindOrCreateMock = jest.fn().mockResolvedValueOnce(buildWithNumber);
+    controller = await initController({
+      projectFindOneMock,
+      buildFindOrCreateMock,
+      eventBuildCreatedMock,
+    });
+
+    const result = await controller.create(createBuildDto);
+
+    expect(result).toStrictEqual(new BuildDto(buildWithNumber));
+  });
 });

src/builds/builds.controller.ts

@@ -11,6 +11,8 @@ import {
   Patch,
   ParseIntPipe,
   ParseBoolPipe,
+  forwardRef,
+  Inject,
 } from '@nestjs/common';
 import { BuildsService } from './builds.service';
 import { JwtAuthGuard } from '../auth/guards/auth.guard';
@@ -22,11 +24,18 @@ import { BuildDto } from './dto/build.dto';
 import { MixedGuard } from '../auth/guards/mixed.guard';
 import { PaginatedBuildDto } from './dto/build-paginated.dto';
 import { ModifyBuildDto } from './dto/build-modify.dto';
+import { ProjectsService } from '../projects/projects.service';
+import { EventsGateway } from '../shared/events/events.gateway';
 
 @Controller('builds')
 @ApiTags('builds')
 export class BuildsController {
-  constructor(private buildsService: BuildsService) {}
+  constructor(
+    private buildsService: BuildsService,
+    private eventsGateway: EventsGateway,
+    @Inject(forwardRef(() => ProjectsService))
+    private projectService: ProjectsService
+  ) {}
 
   @Get()
   @ApiOkResponse({ type: PaginatedBuildDto })
@@ -59,8 +68,18 @@ export class BuildsController {
   @ApiOkResponse({ type: BuildDto })
   @ApiSecurity('api_key')
   @UseGuards(ApiGuard)
-  create(@Body() createBuildDto: CreateBuildDto): Promise<BuildDto> {
-    return this.buildsService.create(createBuildDto);
+  async create(@Body() createBuildDto: CreateBuildDto): Promise<BuildDto> {
+    const project = await this.projectService.findOne(createBuildDto.project);
+    let build = await this.buildsService.findOrCreate({
+      projectId: project.id,
+      branchName: createBuildDto.branchName,
+      ciBuildId: createBuildDto.ciBuildId,
+    });
+    if (!build.number) {
+      build = await this.buildsService.incrementBuildNumber(build.id, project.id);
+      this.eventsGateway.buildCreated(new BuildDto(build));
+    }
+    return new BuildDto(build);
   }
 
   @Patch(':id')

src/builds/builds.service.spec.ts

@@ -174,88 +174,6 @@ describe('BuildsService', () => {
     });
   });
 
-  describe('create', () => {
-    const createBuildDto: CreateBuildDto = {
-      ciBuildId: 'ciBuildId',
-      branchName: 'branchName',
-      project: 'name',
-    };
-
-    const project: Project = {
-      id: 'project id',
-      name: 'name',
-      mainBranchName: 'master',
-      buildsCounter: 1,
-      updatedAt: new Date(),
-      createdAt: new Date(),
-    };
-
-    it('should create', async () => {
-      const buildFindUniqueMock = jest.fn().mockResolvedValueOnce(null);
-      const buildCreateMock = jest.fn().mockResolvedValueOnce(build);
-      const projectFindOneMock = jest.fn().mockResolvedValueOnce(project);
-      const projectUpdateMock = jest.fn().mockResolvedValueOnce(project);
-      const eventsBuildCreatedMock = jest.fn();
-      mocked(BuildDto).mockReturnValue(buildDto);
-      service = await initService({
-        buildCreateMock,
-        buildFindUniqueMock,
-        eventsBuildCreatedMock,
-        projectFindOneMock,
-        projectUpdateMock,
-      });
-
-      const result = await service.create(createBuildDto);
-
-      expect(projectFindOneMock).toHaveBeenCalledWith(createBuildDto.project);
-      expect(buildFindUniqueMock).toHaveBeenCalledWith({
-        where: {
-          projectId_ciBuildId: {
-            projectId: project.id,
-            ciBuildId: createBuildDto.ciBuildId,
-          },
-        },
-      });
-      expect(projectUpdateMock).toHaveBeenCalledWith({
-        where: { id: project.id },
-        data: {
-          buildsCounter: {
-            increment: 1,
-          },
-        },
-      });
-      expect(buildCreateMock).toHaveBeenCalledWith({
-        data: {
-          branchName: createBuildDto.branchName,
-          ciBuildId: createBuildDto.ciBuildId,
-          isRunning: true,
-          number: project.buildsCounter,
-          project: {
-            connect: {
-              id: project.id,
-            },
-          },
-        },
-      });
-      expect(eventsBuildCreatedMock).toHaveBeenCalledWith(buildDto);
-      expect(result).toBe(buildDto);
-    });
-
-    it('should reuse by ciBuildId', async () => {
-      const buildFindUniqueMock = jest.fn().mockResolvedValueOnce(build);
-      const projectFindOneMock = jest.fn().mockResolvedValueOnce(project);
-      mocked(BuildDto).mockReturnValue(buildDto);
-      service = await initService({
-        buildFindUniqueMock,
-        projectFindOneMock,
-      });
-
-      const result = await service.create(createBuildDto);
-
-      expect(result).toBe(buildDto);
-    });
-  });
-
   it('delete', async () => {
     const buildFindUniqueMock = jest.fn().mockResolvedValueOnce(build);
     const buildDeleteMock = jest.fn();