autoroll/modules/rpc-mock/index.ts

import { toParamSet } from 'common-sk/modules/query';
import {
  AutoRollService,
  AutoRollStatus,
  CreateManualRollRequest,
  GetRollersRequest,
  GetMiniStatusRequest,
  GetStatusRequest,
  ManualRoll,
  ModeChange,
  SetModeRequest,
  SetStrategyRequest,
  StrategyChange,
  UnthrottleRequest,
  UnthrottleResponse,
  MockRPCsForTesting,
} from '../rpc';

import { GetFakeStatus } from './fake-status';
import { GetFakeMiniStatuses} from './fake-ministatuses';
import { GetRollersResponse, Mode, Strategy, ManualRoll_Status, GetStatusResponse, GetMiniStatusResponse, SetModeResponse, SetStrategyResponse, CreateManualRollResponse, ManualRoll_Result } from '../rpc/rpc';
import { GetFakeConfig } from './fake-config';

export * from './fake-status';

/**
 * SetupMocks changes the rpc module to use the mocked client from this module.
 */
export function SetupMocks() {
  MockRPCsForTesting(new FakeAutoRollService())
}

const manualRollResults = Object.keys(ManualRoll_Result);

/**
 * FakeAutoRollService provides a mocked implementation of AutoRollService.
 */
class FakeAutoRollService implements AutoRollService {
  private manualRollResult: number = 0;
  private manualRequestId: number = 0;
  private status: AutoRollStatus = GetFakeStatus();

  getRollers(_: GetRollersRequest): Promise<GetRollersResponse> {
    return Promise.resolve({
      rollers: GetFakeMiniStatuses(),
    });
  }

  getMiniStatus(_: GetMiniStatusRequest): Promise<GetMiniStatusResponse> {
    return Promise.resolve({
      status: this.status.miniStatus,
    });
  }

  getStatus(_: GetStatusRequest): Promise<GetStatusResponse> {
    const params = toParamSet(window.location.search.substring(1));
    if (params["status"]?.indexOf("error") >= 0) {
      this.status.status = "error";
      this.status.error = "Error message goes here!";
    }
    return Promise.resolve({
      status: this.status,
    });
  }

  setMode(req: SetModeRequest): Promise<SetModeResponse> {
    return new Promise((resolve, reject) => {
      const validModes = Object.keys(Mode)
      const validMode = validModes.indexOf(req.mode);
      if (validMode < 0) {
        reject("Invalid mode: " + req.mode + "; valid modes: " + validModes);
        return;
      }
      const mc: ModeChange = {
        rollerId: req.rollerId,
        mode: req.mode,
        user: "you@google.com",
        time: new Date().toString(), // TODO(borenet): Is this the right format?
        message: req.message,
      };
      this.status.mode = mc;
      resolve({
        status: this.status,
      });
    });
  }

  setStrategy(req: SetStrategyRequest): Promise<SetStrategyResponse> {
    return new Promise((resolve, reject) => {
      const validStrategies = Object.keys(Strategy);
      const validStrategy = validStrategies.indexOf(req.strategy);
      if (validStrategy < 0) {
        reject("Invalid strategy: " + req.strategy + "; valid strategies: " +
                validStrategies);
        return;
      }
      const sc: StrategyChange = {
        rollerId: req.rollerId,
        strategy: req.strategy,
        user: "you@google.com",
        time: new Date().toString(), // TODO(borenet): Is this the right format?
        message: req.message,
      }
      this.status.strategy = sc;
      resolve({
        status: this.status,
      });
    });
  }

  createManualRoll(req: CreateManualRollRequest): Promise<CreateManualRollResponse> {
    const result =  manualRollResults[this.manualRollResult++ % manualRollResults.length];
    const id: string = "manualRequest" + this.manualRequestId;
    this.manualRequestId++;
    const rv: ManualRoll = {
      id: id,
      dryRun: false,
      noEmail: false,
      noResolveRevision: false,
      rollerId: req.rollerId,
      revision: req.revision,
      requester: "you@google.com",
      result: ManualRoll_Result[<keyof typeof ManualRoll_Result>result],
      status: ManualRoll_Status.PENDING,
      timestamp: new Date("2017-08-28T03:51:10Z").toString(), // TODO(borenet): Is this the right format?
      url: result == "" ? "" : "https://fake.google.com",
    };
    if (!this.status.manualRolls) {
      this.status.manualRolls = [];
    }
    this.status.manualRolls.push(rv);
    return Promise.resolve({
      roll: rv,
    });
  }

  unthrottle(_: UnthrottleRequest): Promise<UnthrottleResponse> {
    return Promise.resolve({});
  }
}