task_scheduler/modules/rpc-mock/index.ts

import {
  AddSkipTaskRuleRequest,
  AddSkipTaskRuleResponse,
  CancelJobRequest,
  CancelJobResponse,
  DeleteSkipTaskRuleRequest,
  DeleteSkipTaskRuleResponse,
  GetJobRequest,
  GetJobResponse,
  GetTaskRequest,
  GetTaskResponse,
  GetSkipTaskRulesRequest,
  GetSkipTaskRulesResponse,
  Job,
  SearchJobsRequest,
  SearchJobsResponse,
  SearchTasksRequest,
  SearchTasksResponse,
  Task,
  TaskSchedulerService,
  TriggerJobsRequest,
  TriggerJobsResponse,
} from '../rpc';
import {
  job1,
  task0,
  task1,
  task2,
  task3,
  task4,
  job2,
  skipRule1,
  skipRule2,
  skipRule3,
} from './fake-data';
import { JobStatus, SkipTaskRule } from '../rpc/rpc';

export * from './fake-data';

/**
 * FakeTaskSchedulerService provides a mocked implementation of
 * TaskSchedulerService.
 */
export class FakeTaskSchedulerService implements TaskSchedulerService {
  private jobs: { [key: string]: Job } = {
    [job1.id]: job1,
    [job2.id]: job2,
  };

  private tasks: { [key: string]: Task } = {
    [task0.id]: task0,
    [task1.id]: task1,
    [task2.id]: task2,
    [task3.id]: task3,
    [task4.id]: task4,
  };

  private jobID: number = 0;

  private skipRules = [skipRule1, skipRule2, skipRule3];

  triggerJobs(
    triggerJobsRequest: TriggerJobsRequest,
  ): Promise<TriggerJobsResponse> {
    const ids = triggerJobsRequest.jobs!.map((job) => `${this.jobID++}`);
    return Promise.resolve({
      jobIds: ids,
    });
  }

  getJob(getJobRequest: GetJobRequest): Promise<GetJobResponse> {
    return Promise.resolve({
      job: this.jobs[getJobRequest.id],
    });
  }

  cancelJob(cancelJobRequest: CancelJobRequest): Promise<CancelJobResponse> {
    const job = this.jobs[cancelJobRequest.id];
    job.status = JobStatus.JOB_STATUS_CANCELED;
    return Promise.resolve({
      job: job,
    });
  }

  searchJobs(req: SearchJobsRequest): Promise<SearchJobsResponse> {
    console.log(req);
    const results: Job[] = Object.values(this.jobs).filter((job: Job) => {
      if (req.hasRepo && job.repoState?.repo != req.repo) {
        return false;
      } if (req.hasRevision && job.repoState?.revision != req.revision) {
        return false;
      } if (req.hasIssue && req.issue != job.repoState!.patch!.issue) {
        return false;
      } if (
        req.hasPatchset
        && req.patchset != job.repoState?.patch?.patchset
      ) {
        return false;
      } if (req.hasName && job.name != req.name) {
        return false;
      } if (
        req.hasBuildbucketBuildId
        && job.buildbucketBuildId != req.buildbucketBuildId
      ) {
        return false;
      } if (req.hasStatus && job.status != req.status) {
        return false;
      } if (
        req.hasTimeStart
        && new Date(job.createdAt!).getTime() <= new Date(req.timeStart!).getTime()
      ) {
        return false;
      } if (
        req.hasTimeEnd
        && new Date(job.createdAt!).getTime() > new Date(req.timeEnd!).getTime()
      ) {
        return false;
      } if (req.hasIsForce && job.isForce != req.isForce) {
        return false;
      }
      return true;
    });
    console.log(results);
    return Promise.resolve({
      jobs: results,
    });
  }

  getTask(getTaskRequest: GetTaskRequest): Promise<GetTaskResponse> {
    return Promise.resolve({
      task: this.tasks[getTaskRequest.id],
    });
  }

  searchTasks(
    searchTasksRequest: SearchTasksRequest,
  ): Promise<SearchTasksResponse> {
    return new Promise((_, reject) => {
      reject('not implemented');
    });
  }

  getSkipTaskRules(
    getSkipTaskRulesRequest: GetSkipTaskRulesRequest,
  ): Promise<GetSkipTaskRulesResponse> {
    return Promise.resolve({ rules: this.skipRules.slice() });
  }

  addSkipTaskRule(
    addSkipTaskRuleRequest: AddSkipTaskRuleRequest,
  ): Promise<AddSkipTaskRuleResponse> {
    this.skipRules.push({
      addedBy: 'you@google.com',
      taskSpecPatterns: addSkipTaskRuleRequest.taskSpecPatterns,
      commits: addSkipTaskRuleRequest.commits,
      description: addSkipTaskRuleRequest.description,
      name: addSkipTaskRuleRequest.name,
    });
    return Promise.resolve({ rules: this.skipRules.slice() });
  }

  deleteSkipTaskRule(
    deleteSkipTaskRuleRequest: DeleteSkipTaskRuleRequest,
  ): Promise<DeleteSkipTaskRuleResponse> {
    this.skipRules = this.skipRules.filter(
      (rule: SkipTaskRule) => rule.name != deleteSkipTaskRuleRequest.id,
    );
    return Promise.resolve({ rules: this.skipRules.slice() });
  }
}