Merge pull request #397 from topcoder-platform/PM-5231

PM-5231: Queue validation scorer submissions

Author: jmgasper

src/api/marathon-match-config/marathon-match-config.controller.ts

@@ -10,13 +10,18 @@ import {
   Put,
   Query,
   Res,
+  UploadedFile,
   UseGuards,
   UseInterceptors,
 } from '@nestjs/common';
+import { FileInterceptor } from '@nestjs/platform-express';
+import { PhaseConfigType } from '@prisma/client';
 import { Response } from 'express';
+import { memoryStorage } from 'multer';
 import {
   ApiBearerAuth,
   ApiBody,
+  ApiConsumes,
   ApiOperation,
   ApiParam,
   ApiQuery,
@@ -31,6 +36,8 @@ import {
   RerunResponseDto,
   SearchMarathonMatchConfigQueryDto,
   SystemRerunResponseDto,
+  TestSubmissionResponseDto,
+  TestSubmissionUploadDto,
   UpdateMarathonMatchConfigDto,
 } from 'src/dto/marathon-match-config.dto';
 import { PaginationHeaderInterceptor } from 'src/interceptors/PaginationHeaderInterceptor';
@@ -193,6 +200,93 @@ export class MarathonMatchConfigController {
     );
   }
 
+  /**
+   * Uploads a validation submission and queues scorer execution through ECS.
+   * @param challengeId Challenge ID.
+   * @param body Multipart form fields for validation scoring.
+   * @param file Uploaded submission ZIP.
+   * @param user Authenticated user for authorization and member fallback.
+   * @returns Created submission and ECS task launch details.
+   */
+  @Post('/:challengeId/test-submission')
+  @Roles(
+    UserRole.Admin,
+    UserRole.Copilot,
+    UserRole.ProjectManager,
+    UserRole.User,
+  )
+  @Scopes(Scope.UpdateMarathonMatch)
+  @UseGuards(ChallengeCopilotResourceGuard)
+  @HttpCode(HttpStatus.ACCEPTED)
+  @ApiOperation({
+    summary: 'Upload and score a Marathon Match validation submission',
+    description:
+      'Roles: Admin or challenge Copilot/Manager resource | Scopes: update:marathon-match',
+  })
+  @ApiParam({
+    name: 'challengeId',
+    description:
+      'The challenge ID for the marathon match validation submission request',
+    example: '30000123',
+  })
+  @ApiConsumes('multipart/form-data')
+  @UseInterceptors(
+    FileInterceptor('file', {
+      storage: memoryStorage(),
+    }),
+  )
+  @ApiBody({
+    required: true,
+    type: 'multipart/form-data',
+    schema: {
+      type: 'object',
+      properties: {
+        file: {
+          type: 'string',
+          format: 'binary',
+        },
+        configType: {
+          type: 'string',
+          enum: Object.values(PhaseConfigType),
+          default: PhaseConfigType.PROVISIONAL,
+        },
+        memberId: {
+          type: 'string',
+        },
+        fileName: {
+          type: 'string',
+        },
+      },
+      required: ['file'],
+    },
+  })
+  @ApiResponse({
+    status: 202,
+    description:
+      'Validation submission created and queued for asynchronous scoring.',
+    type: TestSubmissionResponseDto,
+  })
+  @ApiResponse({
+    status: 400,
+    description:
+      'Missing file, tester is not compiled successfully, or requested phase config is missing.',
+  })
+  @ApiResponse({ status: 403, description: 'Forbidden.' })
+  @ApiResponse({ status: 404, description: 'Marathon match config not found.' })
+  async uploadTestSubmission(
+    @Param('challengeId') challengeId: string,
+    @Body() body: TestSubmissionUploadDto,
+    @UploadedFile() file: Express.Multer.File,
+    @User() user: JwtUser,
+  ): Promise<TestSubmissionResponseDto> {
+    return await this.marathonMatchConfigService.uploadTestSubmission(
+      challengeId,
+      body,
+      file,
+      user,
+    );
+  }
+
   /**
    * Lists marathon match configurations with optional filters and pagination.
    * @param query Search and pagination query parameters.

src/api/marathon-match-config/marathon-match-config.service.spec.ts

@@ -27,6 +27,7 @@ describe('MarathonMatchConfigService', () => {
   const createService = () => {
     const httpService = {
       get: jest.fn(),
+      post: jest.fn(),
     };
     const ecsService = {
       launchScorerTask: jest.fn(),
@@ -426,6 +427,150 @@ describe('MarathonMatchConfigService', () => {
     );
   });
 
+  it('uploads a validation submission and queues scorer execution', async () => {
+    const { service, ecsService, httpService, m2mService, prisma } =
+      createService();
+    const user = {
+      isMachine: false,
+      userId: '40051399',
+    } as never;
+
+    prisma.marathonMatchConfig.findUnique.mockResolvedValue({
+      id: 'config-1',
+      challengeId: '30000123',
+      active: true,
+      submissionApiUrl: 'https://submissions.example.com/v6',
+      testerId: 'tester-1',
+      taskDefinitionName: 'mm-runner',
+      taskDefinitionVersion: '7',
+      tester: {
+        compilationStatus: CompilationStatus.SUCCESS,
+      },
+      phaseConfigs: [
+        {
+          id: 'phase-provisional',
+          configType: PhaseConfigType.PROVISIONAL,
+          phaseId: 'provisional-phase',
+          startSeed: BigInt(100),
+          numberOfTests: 50,
+        },
+      ],
+    });
+    m2mService.getM2MToken.mockResolvedValue('m2m-token');
+    httpService.post.mockReturnValue(
+      of({
+        data: {
+          id: 'validation-submission-1',
+        },
+      }),
+    );
+    ecsService.launchScorerTask.mockResolvedValue({
+      taskArn: 'arn:aws:ecs:task/task-1',
+      taskId: 'task-1',
+      cluster: 'cluster-1',
+      containerName: 'runner',
+      taskDefinition: 'mm-runner:7',
+      cloudWatchLogsConsoleUrl: 'https://logs.example.com/task-1',
+    });
+
+    const result = await service.uploadTestSubmission(
+      '30000123',
+      {
+        configType: PhaseConfigType.PROVISIONAL,
+      },
+      {
+        buffer: Buffer.from('zip'),
+        mimetype: 'application/zip',
+        originalname: 'solution.zip',
+        size: 3,
+      } as Express.Multer.File,
+      user,
+    );
+
+    const postedForm = httpService.post.mock.calls[0][1] as FormData;
+    expect(result).toEqual({
+      challengeId: '30000123',
+      submissionId: 'validation-submission-1',
+      configType: PhaseConfigType.PROVISIONAL,
+      taskArn: 'arn:aws:ecs:task/task-1',
+      taskId: 'task-1',
+      cloudWatchLogsConsoleUrl: 'https://logs.example.com/task-1',
+    });
+    expect(httpService.post).toHaveBeenCalledWith(
+      'https://submissions.example.com/v6/submissions/validation-upload',
+      expect.any(FormData),
+      {
+        headers: {
+          Authorization: 'Bearer m2m-token',
+        },
+      },
+    );
+    expect(postedForm.get('challengeId')).toBe('30000123');
+    expect(postedForm.get('memberId')).toBe('40051399');
+    expect(postedForm.get('type')).toBe('CONTEST_SUBMISSION');
+    expect(postedForm.get('submissionPhaseId')).toBe('provisional-phase');
+    expect(ecsService.launchScorerTask).toHaveBeenCalledWith(
+      '30000123',
+      'validation-submission-1',
+      {
+        taskDefinitionName: 'mm-runner',
+        taskDefinitionVersion: '7',
+      },
+      {
+        configType: PhaseConfigType.PROVISIONAL,
+        startSeed: BigInt(100),
+        numberOfTests: 50,
+      },
+      undefined,
+      {
+        memberId: '40051399',
+      },
+    );
+  });
+
+  it('rejects validation submissions when the tester is not compiled', async () => {
+    const { service, ecsService, httpService, prisma } = createService();
+
+    prisma.marathonMatchConfig.findUnique.mockResolvedValue({
+      id: 'config-1',
+      challengeId: '30000123',
+      testerId: 'tester-1',
+      tester: {
+        compilationStatus: CompilationStatus.FAILED,
+        compilationError: 'javac failed',
+      },
+      phaseConfigs: [
+        {
+          id: 'phase-provisional',
+          configType: PhaseConfigType.PROVISIONAL,
+          phaseId: 'provisional-phase',
+          startSeed: BigInt(100),
+          numberOfTests: 50,
+        },
+      ],
+    });
+
+    await expect(
+      service.uploadTestSubmission(
+        '30000123',
+        {},
+        {
+          buffer: Buffer.from('zip'),
+          mimetype: 'application/zip',
+          originalname: 'solution.zip',
+          size: 3,
+        } as Express.Multer.File,
+        {
+          isMachine: false,
+          userId: '40051399',
+        } as never,
+      ),
+    ).rejects.toThrow(BadRequestException);
+
+    expect(httpService.post).not.toHaveBeenCalled();
+    expect(ecsService.launchScorerTask).not.toHaveBeenCalled();
+  });
+
   it('rate limits rerun scorer task launches in batches', async () => {
     jest.useFakeTimers();