Merge pull request #14 from Visual-Regression-Tracker/54-project-name

Allow to use project name for build creation

Author: pashidlos

src/builds/builds.service.spec.ts

@@ -4,9 +4,10 @@ import { PrismaService } from '../prisma/prisma.service';
 import { TestRunsService } from '../test-runs/test-runs.service';
 import { EventsGateway } from '../events/events.gateway';
 import { CreateBuildDto } from './dto/build-create.dto';
-import { Build, TestRun } from '@prisma/client';
+import { Build, TestRun, Project } from '@prisma/client';
 import { mocked } from 'ts-jest/utils';
 import { BuildDto } from './dto/build.dto';
+import { HttpException, HttpStatus } from '@nestjs/common';
 
 jest.mock('./dto/build.dto');
 
@@ -17,13 +18,17 @@ const initService = async ({
   buildDeleteMock = jest.fn(),
   testRunDeleteMock = jest.fn(),
   eventsBuildCreatedMock = jest.fn(),
+  projectFindManyMock = jest.fn(),
 }) => {
   const module: TestingModule = await Test.createTestingModule({
     providers: [
       BuildsService,
       {
         provide: PrismaService,
         useValue: {
+          project: {
+            findMany: projectFindManyMock,
+          },
           build: {
             findMany: buildFindManyMock,
             create: buildCreateMock,
@@ -119,30 +124,54 @@ describe('BuildsService', () => {
     expect(result).toEqual([buildDto]);
   });
 
-  it('create', async () => {
+  describe('create', () => {
     const createBuildDto: CreateBuildDto = {
       branchName: 'branchName',
-      projectId: 'projectId',
+      project: 'project id or name',
     };
-    const buildCreateMock = jest.fn().mockResolvedValueOnce(build);
-    const eventsBuildCreatedMock = jest.fn();
-    mocked(BuildDto).mockReturnValueOnce(buildDto);
-    service = await initService({ buildCreateMock, eventsBuildCreatedMock });
 
-    const result = await service.create(createBuildDto);
+    it('should create', async () => {
+      const project: Project = {
+        id: 'project id',
+        name: 'name',
+        updatedAt: new Date(),
+        createdAt: new Date(),
+      };
+      const buildCreateMock = jest.fn().mockResolvedValueOnce(build);
+      const projectFindManyMock = jest.fn().mockResolvedValueOnce([project]);
+      const eventsBuildCreatedMock = jest.fn();
+      mocked(BuildDto).mockReturnValueOnce(buildDto);
+      service = await initService({ buildCreateMock, eventsBuildCreatedMock, projectFindManyMock });
+
+      const result = await service.create(createBuildDto);
 
-    expect(buildCreateMock).toHaveBeenCalledWith({
-      data: {
-        branchName: createBuildDto.branchName,
-        project: {
-          connect: {
-            id: createBuildDto.projectId,
+      expect(projectFindManyMock).toHaveBeenCalledWith({
+        where: {
+          OR: [{ id: createBuildDto.project }, { name: createBuildDto.project }],
+        },
+      });
+      expect(buildCreateMock).toHaveBeenCalledWith({
+        data: {
+          branchName: createBuildDto.branchName,
+          project: {
+            connect: {
+              id: project.id,
+            },
           },
         },
-      },
+      });
+      expect(eventsBuildCreatedMock).toHaveBeenCalledWith(buildDto);
+      expect(result).toBe(buildDto);
+    });
+
+    it('should throw exception if not found', async () => {
+      const projectFindManyMock = jest.fn().mockResolvedValueOnce([]);
+      service = await initService({ projectFindManyMock });
+
+      await expect(service.create(createBuildDto)).rejects.toThrowError(
+        new HttpException('Project not found', HttpStatus.NOT_FOUND)
+      );
     });
-    expect(eventsBuildCreatedMock).toHaveBeenCalledWith(buildDto);
-    expect(result).toBe(buildDto);
   });
 
   it('delete', async () => {

src/builds/builds.service.ts

@@ -1,4 +1,4 @@
-import { Injectable } from '@nestjs/common';
+import { Injectable, HttpException, HttpStatus } from '@nestjs/common';
 import { CreateBuildDto } from './dto/build-create.dto';
 import { PrismaService } from '../prisma/prisma.service';
 import { Build } from '@prisma/client';
@@ -27,12 +27,22 @@ export class BuildsService {
   }
 
   async create(createBuildDto: CreateBuildDto): Promise<BuildDto> {
+    const projects = await this.prismaService.project.findMany({
+      where: {
+        OR: [{ id: createBuildDto.project }, { name: createBuildDto.project }],
+      },
+    });
+
+    if (projects.length <= 0) {
+      throw new HttpException(`Project not found`, HttpStatus.NOT_FOUND);
+    }
+
     const build = await this.prismaService.build.create({
       data: {
         branchName: createBuildDto.branchName,
         project: {
           connect: {
-            id: createBuildDto.projectId,
+            id: projects[0].id,
           },
         },
       },

src/builds/dto/build-create.dto.ts

@@ -1,12 +1,12 @@
 import { ApiProperty } from '@nestjs/swagger';
-import { IsString, IsUUID } from 'class-validator';
+import { IsString, IsUUID, IsOptional } from 'class-validator';
 
 export class CreateBuildDto {
   @ApiProperty()
   @IsString()
   readonly branchName: string;
 
   @ApiProperty()
-  @IsUUID()
-  readonly projectId: string;
+  @IsString()
+  readonly project: string;
 }

src/prisma/prisma.service.ts

@@ -4,7 +4,9 @@ import { PrismaClient } from '@prisma/client';
 @Injectable()
 export class PrismaService extends PrismaClient implements OnModuleInit, OnModuleDestroy {
   constructor() {
-    super();
+    super({
+      // log: [{ emit: 'stdout', level: 'query' }],
+    });
   }
   async onModuleInit() {
     await this.connect();

test/builds.e2e-spec.ts

@@ -45,10 +45,10 @@ describe('Builds (e2e)', () => {
   });
 
   describe('POST /', () => {
-    it('201', () => {
+    it('201 by id', () => {
       const createBuildDto: CreateBuildDto = {
         branchName: 'branchName',
-        projectId: project.id,
+        project: project.id,
       };
       return requestWithApiKey(app, 'post', '/builds', createBuildDto, user.apiKey)
         .expect(201)
@@ -61,18 +61,42 @@ describe('Builds (e2e)', () => {
         });
     });
 
+    it('201 by name', () => {
+      const createBuildDto: CreateBuildDto = {
+        branchName: 'branchName',
+        project: project.name,
+      };
+      return requestWithApiKey(app, 'post', '/builds', createBuildDto, user.apiKey)
+        .expect(201)
+        .expect(res => {
+          expect(res.body.projectId).toBe(project.id);
+          expect(res.body.branchName).toBe(createBuildDto.branchName);
+          expect(res.body.failedCount).toBe(0);
+          expect(res.body.passedCount).toBe(0);
+          expect(res.body.unresolvedCount).toBe(0);
+        });
+    });
+    
+    it('404', () => {
+      const createBuildDto: CreateBuildDto = {
+        branchName: 'branchName',
+        project: 'random',
+      };
+      return requestWithApiKey(app, 'post', '/builds', createBuildDto, user.apiKey).expect(404);
+    });
+
     it('403', () => {
       const createBuildDto: CreateBuildDto = {
         branchName: 'branchName',
-        projectId: project.id,
+        project: project.id,
       };
       return requestWithApiKey(app, 'post', '/builds', createBuildDto, '').expect(403);
     });
   });
 
   describe('GET /', () => {
     it('200', async () => {
-      const build = await buildsService.create({ projectId: project.id, branchName: 'develop' });
+      const build = await buildsService.create({ project: project.id, branchName: 'develop' });
 
       return requestWithAuth(app, 'get', `/builds?projectId=${project.id}`, {}, user.token)
         .expect(200)
@@ -88,13 +112,13 @@ describe('Builds (e2e)', () => {
 
   describe('DELETE /', () => {
     it('200', async () => {
-      const build = await buildsService.create({ projectId: project.id, branchName: 'develop' });
+      const build = await buildsService.create({ project: project.id, branchName: 'develop' });
 
       return requestWithAuth(app, 'delete', `/builds/${build.id}`, {}, user.token).expect(200);
     });
 
     it('401', async () => {
-      const build = await buildsService.create({ projectId: project.id, branchName: 'develop' });
+      const build = await buildsService.create({ project: project.id, branchName: 'develop' });
 
       return requestWithAuth(app, 'delete', `/builds/${build.id}`, {}, '').expect(401);
     });