feat(#455): handle baselineBranchName

docker-compose.yml

@@ -51,7 +51,7 @@ services:
   #   container_name: pgadmin4
   #   # https://hub.docker.com/r/dpage/pgadmin4
   #   # https://www.pgadmin.org/docs/pgadmin4/latest/release_notes_7_4.html
-  #   image: dpage/pgadmin4:7.4
+  #   image: dpage/pgadmin4
   #   restart: always
   #   environment:
   #     PGADMIN_DEFAULT_EMAIL: admin@admin.com

prisma/migrations/20250225101118_add_protected_branches/migration.sql

@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "Project" ADD COLUMN     "protectedBranch" TEXT;

prisma/schema.prisma

@@ -1,5 +1,5 @@
 generator client {
-  provider = "prisma-client-js"
+  provider      = "prisma-client-js"
   binaryTargets = ["native", "debian-openssl-3.0.x", "linux-arm64-openssl-3.0.x"]
 }
 
@@ -41,6 +41,7 @@ model Project {
   builds                Build[]
   TestRun               TestRun[]
   testVariations        TestVariation[]
+  protectedBranch       String?
 }
 
 model TestRun {

prisma/test/seed.spec.ts

@@ -16,6 +16,7 @@ const mockDefaultProject = {
   autoApproveFeature: true,
   imageComparison: 'pixelmatch',
   imageComparisonConfig: '{ "threshold": 0.1, "ignoreAntialiasing": true, "allowDiffDimensions": false }',
+  protectedBranch: null,
 } as const;
 
 const mockDefaultUser = {

src/_data_/index.ts

@@ -13,6 +13,7 @@ export const TEST_PROJECT: Project = {
   autoApproveFeature: true,
   imageComparisonConfig: '{ "threshold": 0.1, "ignoreAntialiasing": true, "allowDiffDimensions": false }',
   imageComparison: ImageComparison.pixelmatch,
+  protectedBranch: 'release-[0-9]+',
 };
 
 export const TEST_BUILD: Build = {

src/projects/dto/project.dto.ts

@@ -1,5 +1,5 @@
 import { ApiProperty } from '@nestjs/swagger';
-import { IsUUID, IsString, IsNumber, IsBoolean, IsEnum, IsJSON, IsDate } from 'class-validator';
+import { IsUUID, IsString, IsNumber, IsBoolean, IsEnum, IsJSON, IsDate, IsOptional } from 'class-validator';
 import { ImageComparison, Project } from '@prisma/client';
 import { Type } from 'class-transformer';
 
@@ -49,4 +49,9 @@ export class ProjectDto implements Project {
   @ApiProperty()
   @IsJSON()
   imageComparisonConfig: string;
+
+  @ApiProperty()
+  @IsString()
+  @IsOptional()
+  protectedBranch: string;
 }

src/projects/projects.service.ts

@@ -48,6 +48,7 @@ export class ProjectsService {
         imageComparisonConfig: projectDto.imageComparisonConfig,
         maxBuildAllowed: projectDto.maxBuildAllowed,
         maxBranchLifetime: projectDto.maxBranchLifetime,
+        protectedBranch: projectDto.protectedBranch,
       },
     });
   }
@@ -63,6 +64,7 @@ export class ProjectsService {
         maxBuildAllowed: projectDto.maxBuildAllowed,
         maxBranchLifetime: projectDto.maxBranchLifetime,
         imageComparisonConfig: projectDto.imageComparisonConfig,
+        protectedBranch: projectDto.protectedBranch,
       },
     });
   }

src/shared/tasks/tasks.service.spec.ts

@@ -6,7 +6,7 @@ import { TestVariationsService } from '../../test-variations/test-variations.ser
 
 const initService = async ({
   projectFindManyMock = jest.fn(),
-  testVariationFindManyMock = jest.fn(),
+  findOldTestVariationsMock = jest.fn(),
   testVariationsDeleteMock = jest.fn(),
 }) => {
   const module: TestingModule = await Test.createTestingModule({
@@ -15,9 +15,6 @@ const initService = async ({
       {
         provide: PrismaService,
         useValue: {
-          testVariation: {
-            findMany: testVariationFindManyMock,
-          },
           project: {
             findMany: projectFindManyMock,
           },
@@ -27,6 +24,7 @@ const initService = async ({
         provide: TestVariationsService,
         useValue: {
           delete: testVariationsDeleteMock,
+          findOldTestVariations: findOldTestVariationsMock,
         },
       },
     ],
@@ -43,11 +41,11 @@ describe('cleanOldTestVariations', () => {
     const project = TEST_PROJECT;
     const testVariation = generateTestVariation();
     const projectFindManyMock = jest.fn().mockResolvedValueOnce([project]);
-    const testVariationFindManyMock = jest.fn().mockResolvedValueOnce([testVariation]);
+    const findOldTestVariationsMock = jest.fn().mockResolvedValueOnce([testVariation]);
     const testVariationsDeleteMock = jest.fn();
     service = await initService({
       projectFindManyMock: projectFindManyMock,
-      testVariationFindManyMock: testVariationFindManyMock,
+      findOldTestVariationsMock: findOldTestVariationsMock,
       testVariationsDeleteMock: testVariationsDeleteMock,
     });
     const dateNow = new Date('2022-10-23');
@@ -59,13 +57,7 @@ describe('cleanOldTestVariations', () => {
     await service.cleanOldTestVariations();
 
     // .Assert
-    expect(testVariationFindManyMock).toHaveBeenCalledWith({
-      where: {
-        updatedAt: { lte: dateRemoveAfter },
-        branchName: { not: project.mainBranchName },
-        projectId: project.id,
-      },
-    });
+    expect(findOldTestVariationsMock).toHaveBeenCalledWith(project, dateRemoveAfter);
     expect(testVariationsDeleteMock).toBeCalledWith(testVariation.id);
   });
 });

src/shared/tasks/tasks.service.ts

@@ -21,13 +21,8 @@ export class TasksService {
       const dateRemoveAfter: Date = new Date();
       dateRemoveAfter.setDate(dateRemoveAfter.getDate() - project.maxBranchLifetime);
 
-      const testVariations = await this.prismaService.testVariation.findMany({
-        where: {
-          projectId: project.id,
-          updatedAt: { lte: dateRemoveAfter },
-          branchName: { not: project.mainBranchName },
-        },
-      });
+      const testVariations = await this.testVariationService.findOldTestVariations(project, dateRemoveAfter);
+
       this.logger.debug(
         `Removing ${testVariations.length} TestVariations for ${project.name} later than ${dateRemoveAfter}`
       );

src/test-runs/dto/create-test-request.dto.ts

@@ -34,4 +34,9 @@ export class CreateTestRequestDto extends BaselineDataDto {
   @IsOptional()
   @IsString()
   comment?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  baselineBranchName?: string;
 }

src/test-runs/test-runs.service.ts

@@ -85,8 +85,16 @@ export class TestRunsService {
 
     // try auto approve
     if (project.autoApproveFeature) {
-      testRunWithResult = await this.tryAutoApproveByPastBaselines({ testVariation, testRun: testRunWithResult });
-      testRunWithResult = await this.tryAutoApproveByNewBaselines({ testVariation, testRun: testRunWithResult });
+      testRunWithResult = await this.tryAutoApproveByPastBaselines({
+        testVariation,
+        testRun: testRunWithResult,
+        baselineBranchName: createTestRequestDto.baselineBranchName,
+      });
+      testRunWithResult = await this.tryAutoApproveByNewBaselines({
+        testVariation,
+        testRun: testRunWithResult,
+        baselineBranchName: createTestRequestDto.baselineBranchName,
+      });
     }
     return new TestRunResultDto(testRunWithResult, testVariation);
   }
@@ -348,7 +356,11 @@ export class TestRunsService {
    * @param testVariation
    * @param testRun
    */
-  private async tryAutoApproveByNewBaselines({ testVariation, testRun }: AutoApproveProps): Promise<TestRun> {
+  private async tryAutoApproveByNewBaselines({
+    testVariation,
+    testRun,
+    baselineBranchName,
+  }: AutoApproveProps): Promise<TestRun> {
     if (testRun.status === TestStatus.ok) {
       return testRun;
     }
@@ -358,6 +370,7 @@ export class TestRunsService {
       where: {
         ...getTestVariationUniqueData(testVariation),
         baselineName: testVariation.baselineName,
+        baselineBranchName,
         status: TestStatus.approved,
         testVariation: {
           projectId: testVariation.projectId,
@@ -407,4 +420,5 @@ export class TestRunsService {
 interface AutoApproveProps {
   testVariation: TestVariation;
   testRun: TestRun;
+  baselineBranchName?: string;
 }

src/test-variations/test-variations.service.spec.ts

@@ -306,6 +306,126 @@ describe('TestVariationsService', () => {
       });
       expect(result).toBe(variationMainMock);
     });
+
+    it('can find by baselineBranchName', async () => {
+      const createRequest: CreateTestRequestDto = {
+        buildId: 'buildId',
+        projectId: projectMock.id,
+        name: 'Test name',
+        os: 'OS',
+        browser: 'browser',
+        viewport: 'viewport',
+        device: 'device',
+        customTags: '',
+        branchName: 'develop',
+        baselineBranchName: 'main',
+      };
+
+      const variationMock: TestVariation = {
+        id: '123',
+        projectId: projectMock.id,
+        name: 'Test name',
+        baselineName: 'main',
+        os: 'OS',
+        browser: 'browser',
+        viewport: 'viewport',
+        device: 'device',
+        customTags: '',
+        ignoreAreas: '[]',
+        comment: 'some comment',
+        branchName: 'develop',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      };
+      const projectFindUniqueMock = jest.fn().mockReturnValueOnce(projectMock);
+      service = await initModule({ projectFindUniqueMock });
+      service.findUnique = jest.fn().mockResolvedValueOnce(variationMock).mockResolvedValueOnce(undefined);
+
+      const result = await service.find(createRequest);
+
+      expect(projectFindUniqueMock).toHaveBeenCalledWith({ where: { id: createRequest.projectId } });
+      expect(service.findUnique).toHaveBeenNthCalledWith(1, {
+        name: createRequest.name,
+        projectId: createRequest.projectId,
+        os: createRequest.os,
+        browser: createRequest.browser,
+        viewport: createRequest.viewport,
+        device: createRequest.device,
+        customTags: createRequest.customTags,
+        branchName: createRequest.baselineBranchName,
+      });
+      expect(service.findUnique).toHaveBeenNthCalledWith(2, {
+        name: createRequest.name,
+        projectId: createRequest.projectId,
+        os: createRequest.os,
+        browser: createRequest.browser,
+        viewport: createRequest.viewport,
+        device: createRequest.device,
+        customTags: createRequest.customTags,
+        branchName: createRequest.branchName,
+      });
+      expect(result).toBe(variationMock);
+    });
+
+    it("can find by current branch if baselineBranchName doesn't exist", async () => {
+      const createRequest: CreateTestRequestDto = {
+        buildId: 'buildId',
+        projectId: projectMock.id,
+        name: 'Test name',
+        os: 'OS',
+        browser: 'browser',
+        viewport: 'viewport',
+        device: 'device',
+        customTags: '',
+        branchName: 'main',
+        baselineBranchName: 'release-1',
+      };
+
+      const variationMock: TestVariation = {
+        id: '123',
+        projectId: projectMock.id,
+        name: 'Test name',
+        baselineName: 'baselineName',
+        os: 'OS',
+        browser: 'browser',
+        viewport: 'viewport',
+        device: 'device',
+        customTags: '',
+        ignoreAreas: '[]',
+        comment: 'some comment',
+        branchName: 'develop',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      };
+      const projectFindUniqueMock = jest.fn().mockReturnValueOnce(projectMock);
+      service = await initModule({ projectFindUniqueMock });
+      service.findUnique = jest.fn().mockResolvedValueOnce(undefined).mockResolvedValueOnce(variationMock);
+
+      const result = await service.find(createRequest);
+
+      expect(projectFindUniqueMock).toHaveBeenCalledWith({ where: { id: createRequest.projectId } });
+      expect(service.findUnique).toHaveBeenNthCalledWith(1, {
+        name: createRequest.name,
+        projectId: createRequest.projectId,
+        os: createRequest.os,
+        browser: createRequest.browser,
+        viewport: createRequest.viewport,
+        device: createRequest.device,
+        customTags: createRequest.customTags,
+        branchName: createRequest.baselineBranchName,
+      });
+      expect(service.findUnique).toHaveBeenNthCalledWith(2, {
+        name: createRequest.name,
+        projectId: createRequest.projectId,
+        os: createRequest.os,
+        browser: createRequest.browser,
+        viewport: createRequest.viewport,
+        device: createRequest.device,
+        customTags: createRequest.customTags,
+        branchName: createRequest.branchName,
+      });
+      expect(result).toBe(variationMock);
+    });
   });
 
   it('create', async () => {

src/test-variations/test-variations.service.ts

@@ -1,6 +1,6 @@
 import { Injectable, Inject, forwardRef, Logger } from '@nestjs/common';
 import { PrismaService } from '../prisma/prisma.service';
-import { TestVariation, Baseline, Build, TestRun, User } from '@prisma/client';
+import { TestVariation, Baseline, Build, TestRun, User, type Project } from '@prisma/client';
 import { StaticService } from '../static/static.service';
 import { BuildsService } from '../builds/builds.service';
 import { TestRunsService } from '../test-runs/test-runs.service';
@@ -79,36 +79,34 @@ export class TestVariationsService {
    * @param baselineData
    * @returns
    */
-  async find(
-    createTestRequestDto: BaselineDataDto & { projectId: string; sourceBranch?: string }
-  ): Promise<TestVariation | null> {
+  async find(createTestRequestDto: Omit<CreateTestRequestDto, 'buildId'>): Promise<TestVariation | null> {
     const project = await this.prismaService.project.findUnique({ where: { id: createTestRequestDto.projectId } });
-    const mainBranch = createTestRequestDto.sourceBranch ?? project.mainBranchName;
+    const baselineBranch = createTestRequestDto.baselineBranchName ?? project.mainBranchName;
 
     const [mainBranchTestVariation, currentBranchTestVariation] = await Promise.all([
-      // search main branch variation
+      // search baseline branch variation
       this.findUnique({
         projectId: createTestRequestDto.projectId,
-        branchName: mainBranch,
+        branchName: baselineBranch,
         ...getTestVariationUniqueData(createTestRequestDto),
       }),
       // search current branch variation
-      createTestRequestDto.branchName !== mainBranch &&
+      createTestRequestDto.branchName !== baselineBranch &&
         this.findUnique({
           projectId: createTestRequestDto.projectId,
           branchName: createTestRequestDto.branchName,
           ...getTestVariationUniqueData(createTestRequestDto),
         }),
     ]);
 
-    if (!!currentBranchTestVariation) {
+    if (currentBranchTestVariation) {
       if (mainBranchTestVariation && mainBranchTestVariation.updatedAt > currentBranchTestVariation.updatedAt) {
         return mainBranchTestVariation;
       }
       return currentBranchTestVariation;
     }
 
-    if (!!mainBranchTestVariation) {
+    if (mainBranchTestVariation) {
       return mainBranchTestVariation;
     }
   }
@@ -248,4 +246,14 @@ export class TestVariationsService {
       where: { id: baseline.id },
     });
   }
+
+  async findOldTestVariations(project: Project, dateRemoveAfter: Date) {
+    return await this.prismaService.$queryRaw<Project[]>`
+      SELECT * from public."TestVariation"
+        WHERE "projectId" = ${project.id}
+        AND "updatedAt" <= ${dateRemoveAfter}
+        AND "branchName" NOT LIKE ${project.mainBranchName}
+        AND "branchName" NOT SIMILAR TO ${project.protectedBranch}
+      `;
+  }
 }