MixedGuard added

Author: pashidlos

src/auth/auth.module.ts

@@ -6,6 +6,8 @@ import { JwtStrategy } from './jwt.strategy';
 import { ApiGuard } from './guards/api.guard';
 import { ConfigService } from '@nestjs/config';
 import { PrismaService } from '../prisma/prisma.service';
+import { MixedGuard } from './guards/mixed.guard';
+import { JwtAuthGuard } from './guards/auth.guard';
 
 @Module({
   imports: [
@@ -20,7 +22,7 @@ import { PrismaService } from '../prisma/prisma.service';
       inject: [ConfigService],
     }),
   ],
-  providers: [AuthService, JwtStrategy, ApiGuard, PrismaService],
-  exports: [AuthService],
+  providers: [AuthService, JwtStrategy, ApiGuard, JwtAuthGuard, PrismaService],
+  exports: [AuthService, ApiGuard, JwtAuthGuard],
 })
 export class AuthModule {}

src/auth/guards/mixed.guard.ts

@@ -0,0 +1,21 @@
+import { ExecutionContext, Injectable, CanActivate } from '@nestjs/common';
+import { ApiGuard } from './api.guard';
+import { JwtAuthGuard } from './auth.guard';
+
+@Injectable()
+export class MixedGuard implements CanActivate {
+  constructor(private readonly apiGuard: ApiGuard, private readonly authGuard: JwtAuthGuard) {}
+
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    let jwtAuth = false;
+    try {
+      jwtAuth = (await this.authGuard.canActivate(context)) as boolean;
+    } catch (err) {}
+
+    let apiAuth = false;
+    try {
+      apiAuth = await this.apiGuard.canActivate(context);
+    } catch (err) {}
+    return jwtAuth || apiAuth;
+  }
+}

src/builds/builds.controller.spec.ts

@@ -2,15 +2,21 @@ import { Test, TestingModule } from '@nestjs/testing';
 import { BuildsController } from './builds.controller';
 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';
 
 describe('Builds Controller', () => {
   let controller: BuildsController;
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
       controllers: [BuildsController],
-      providers: [{ provide: BuildsService, useValue: {} },
-      { provide: PrismaService, useValue: {} }],
+      providers: [
+        { provide: BuildsService, useValue: {} },
+        { provide: PrismaService, useValue: {} },
+        { provide: ApiGuard, useValue: {} },
+        { provide: JwtAuthGuard, useValue: {} },
+      ],
     }).compile();
 
     controller = module.get<BuildsController>(BuildsController);

src/builds/builds.controller.ts

@@ -6,6 +6,7 @@ import { CreateBuildDto } from './dto/build-create.dto';
 import { ApiGuard } from '../auth/guards/api.guard';
 import { Build } from '@prisma/client';
 import { BuildDto } from './dto/build.dto';
+import { MixedGuard } from '../auth/guards/mixed.guard';
 
 @Controller('builds')
 @ApiTags('builds')
@@ -38,7 +39,8 @@ export class BuildsController {
   @Patch(':id')
   @ApiResponse({ type: BuildDto })
   @ApiSecurity('api_key')
-  @UseGuards(ApiGuard)
+  @ApiBearerAuth()
+  @UseGuards(MixedGuard)
   stop(@Param('id', new ParseUUIDPipe()) id: string): Promise<BuildDto> {
     return this.buildsService.stop(id);
   }

src/builds/builds.module.ts

@@ -5,9 +5,10 @@ import { UsersModule } from '../users/users.module';
 import { PrismaService } from '../prisma/prisma.service';
 import { TestRunsModule } from '../test-runs/test-runs.module';
 import { SharedModule } from '../shared/shared.module';
+import { AuthModule } from '../auth/auth.module';
 
 @Module({
-  imports: [SharedModule, UsersModule, TestRunsModule],
+  imports: [SharedModule, UsersModule, TestRunsModule, AuthModule],
   providers: [BuildsService, PrismaService],
   controllers: [BuildsController],
   exports: [BuildsService],

src/builds/builds.service.spec.ts

@@ -257,6 +257,9 @@ describe('BuildsService', () => {
 
     expect(buildUpdateMock).toHaveBeenCalledWith({
       where: { id },
+      include: {
+        testRuns: true,
+      },
       data: {
         isRunning: false,
       },

src/builds/builds.service.ts

@@ -65,6 +65,9 @@ export class BuildsService {
   async stop(id: string): Promise<BuildDto> {
     const build = await this.prismaService.build.update({
       where: { id },
+      include: {
+        testRuns: true,
+      },
       data: {
         isRunning: false,
       },

test/builds.e2e-spec.ts

@@ -127,21 +127,30 @@ describe('Builds (e2e)', () => {
   });
 
   describe('PATCH /', () => {
-    it('200', async () => {
+    it('200 jwt', async () => {
+      const build = await buildsService.create({ project: project.id, branchName: 'develop' });
+
+      return requestWithAuth(app, 'patch', `/builds/${build.id}`, {}, user.token)
+        .expect(200)
+        .expect((res) => {
+          expect(res.body.isRunning).toBe(false);
+        });
+    });
+
+    it('200 api', async () => {
       const build = await buildsService.create({ project: project.id, branchName: 'develop' });
 
       return requestWithApiKey(app, 'patch', `/builds/${build.id}`, {}, user.apiKey)
         .expect(200)
         .expect((res) => {
-          expect(res.body.projectId).toBe(project.id);
           expect(res.body.isRunning).toBe(false);
         });
     });
 
-    it('401', async () => {
+    it('403', async () => {
       const build = await buildsService.create({ project: project.id, branchName: 'develop' });
 
-      return requestWithAuth(app, 'patch', `/builds/${build.id}`, {}, '').expect(401);
+      return requestWithAuth(app, 'patch', `/builds/${build.id}`, {}, '').expect(403);
     });
   });
 });

test/projects.e2e-spec.ts

@@ -34,7 +34,6 @@ describe('Projects (e2e)', () => {
 
     app = moduleFixture.createNestApplication();
     usersService = moduleFixture.get<UsersService>(UsersService);
-    usersService = moduleFixture.get<UsersService>(UsersService);
 
     await app.init();
   });