fix: old builds delete

Author: Przybylski Krzysztof

src/_data_/index.ts

@@ -5,7 +5,7 @@ export const TEST_PROJECT: Project = {
   id: '1',
   name: 'Test Project',
   buildsCounter: 2,
-  maxBuildAllowed: 1,
+  maxBuildAllowed: 3,
   maxBranchLifetime: 30,
   mainBranchName: 'master',
   createdAt: new Date(),

src/builds/builds.controller.ts

@@ -73,7 +73,7 @@ export class BuildsController {
   @Roles(Role.admin, Role.editor)
   async create(@Body() createBuildDto: CreateBuildDto): Promise<BuildDto> {
     const project = await this.projectService.findOne(createBuildDto.project);
-    await this.buildsService.deleteOldBuilds(project.id, project.maxBuildAllowed);
+    await this.buildsService.deleteOldBuilds(project);
     const build = await this.buildsService.findOrCreate({
       projectId: project.id,
       branchName: createBuildDto.branchName ?? project.mainBranchName,

src/builds/builds.module.ts

@@ -7,10 +7,12 @@ import { TestRunsModule } from '../test-runs/test-runs.module';
 import { SharedModule } from '../shared/shared.module';
 import { AuthModule } from '../auth/auth.module';
 import { ProjectsModule } from '../projects/projects.module';
+import { StaticService } from '../static/static.service';
+import { StaticFactoryService } from '../static/static.factory';
 
 @Module({
   imports: [SharedModule, UsersModule, forwardRef(() => TestRunsModule), AuthModule, forwardRef(() => ProjectsModule)],
-  providers: [BuildsService, PrismaService],
+  providers: [BuildsService, PrismaService, StaticFactoryService, StaticService],
   controllers: [BuildsController],
   exports: [BuildsService],
 })

src/builds/builds.service.ts

@@ -1,11 +1,12 @@
 import { forwardRef, Inject, Injectable, Logger } from '@nestjs/common';
 import { PrismaService } from '../prisma/prisma.service';
-import { Build, Prisma, TestStatus } from '@prisma/client';
+import { Build, Prisma, TestStatus, Project } from '@prisma/client';
 import { TestRunsService } from '../test-runs/test-runs.service';
 import { EventsGateway } from '../shared/events/events.gateway';
 import { BuildDto } from './dto/build.dto';
 import { PaginatedBuildDto } from './dto/build-paginated.dto';
 import { ModifyBuildDto } from './dto/build-modify.dto';
+import { StaticService } from '../static/static.service';
 
 @Injectable()
 export class BuildsService {
@@ -15,7 +16,8 @@ export class BuildsService {
     private prismaService: PrismaService,
     private eventsGateway: EventsGateway,
     @Inject(forwardRef(() => TestRunsService))
-    private testRunsService: TestRunsService
+    private testRunsService: TestRunsService,
+    private staticService: StaticService
   ) {}
 
   async findOne(id: string): Promise<BuildDto> {
@@ -93,12 +95,38 @@ export class BuildsService {
     return build;
   }
 
-  async deleteOldBuilds(projectId: string, keepBuilds: number) {
-    keepBuilds = keepBuilds < 2 ? keepBuilds : keepBuilds - 1;
-    this.findMany(projectId, undefined, keepBuilds).then((buildList) => {
-      buildList.data.forEach((eachBuild) => {
-        this.remove(eachBuild.id);
-      });
+  async deleteOldBuilds(project: Project) {
+    this.logger.log('Going to delete old builds');
+
+    const keepBuilds = project.maxBuildAllowed <= 1 ? 1 : project.maxBuildAllowed - 1;
+
+    const buildsToDelete = await this.prismaService.build.findMany({
+      where: { projectId: { equals: project.id } },
+      orderBy: { createdAt: 'desc' },
+      skip: keepBuilds,
+    });
+
+    const buildIds = buildsToDelete.map((build) => build.id);
+
+    const testRunsToDelete = await this.prismaService.testRun.findMany({ where: { buildId: { in: buildIds } } });
+
+    await this.prismaService.testRun.deleteMany({ where: { buildId: { in: buildIds } } });
+
+    testRunsToDelete.forEach((testRun) => {
+      this.staticService.deleteImage(testRun.diffName);
+      this.staticService.deleteImage(testRun.imageName);
+    });
+
+    testRunsToDelete.forEach((testRun) => {
+      this.logger.log(`TestRun deleted ${testRun.id}`);
+      this.eventsGateway.testRunDeleted(testRun);
+    });
+
+    await this.prismaService.build.deleteMany({ where: { id: { in: buildIds } } });
+
+    buildsToDelete.forEach((build) => {
+      this.logger.log(`Build deleted ${build.id}`);
+      this.eventsGateway.buildDeleted(new BuildDto({ ...build }));
     });
   }
 

test/builds.e2e-spec.ts

@@ -57,6 +57,34 @@ describe('Builds (e2e)', () => {
   });
 
   describe('POST /', () => {
+    it('deletes old builds', async () => {
+      const createBuild = async (count: number) => {
+        const image_v1 = './test/image.png';
+
+        const createBuildDto: CreateBuildDto = {
+          branchName: `branchName-${count}`,
+          project: project.id,
+        };
+        await requestWithApiKey(app, 'post', '/builds', user.apiKey).send(createBuildDto).expect(201);
+        await haveTestRunCreated(buildsService, testRunsService, project.id, `branchName-${count}`, image_v1);
+      };
+
+      for (let i = 0; i < 6; i++) {
+        await createBuild(i);
+      }
+
+      const builds = await buildsService.findMany(project.id, 10, 0);
+
+      expect(builds.total).toBe(project.maxBuildAllowed);
+      expect(builds.data).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({ branchName: 'branchName-5' }),
+          expect.objectContaining({ branchName: 'branchName-4' }),
+          expect.objectContaining({ branchName: 'branchName-3' }),
+        ])
+      );
+    });
+
     it('201 by id', () => {
       const createBuildDto: CreateBuildDto = {
         branchName: 'branchName',