refactor(scenario): move commands to separate files

Author: urish

.eslintrc.js

@@ -13,5 +13,6 @@ module.exports = {
     '@typescript-eslint/explicit-function-return-type': 'off',
     '@typescript-eslint/strict-boolean-expressions': 'off',
     '@typescript-eslint/restrict-template-expressions': 'off',
+    '@typescript-eslint/method-signature-style': 'off',
   },
 };

src/TestScenario.ts

@@ -1,22 +1,17 @@
 import chalk from 'chalk';
 import type { APIClient } from './APIClient';
 import type { EventManager } from './EventManager';
-import type { ExpectEngine } from './ExpectEngine';
-import { parseTime } from './utils/parseTime';
 
-const validStepKeys = ['name'];
-
-export interface ISetControlParams {
-  'part-id': string;
-  control: string;
-  value: number;
+export interface IScenarioCommand {
+  validate?(params: any): boolean;
+  run(scenario: TestScenario, client: APIClient, params: any): Promise<void>;
 }
 
+const validStepKeys = ['name'];
+
 export interface IStepDefinition {
   name?: string;
-  'wait-serial': string;
-  delay: string;
-  'set-control': ISetControlParams;
+  [key: string]: any;
 }
 
 export interface IScenarioDefinition {
@@ -31,11 +26,13 @@ export class TestScenario {
   private stepIndex = 0;
   private client?: APIClient;
 
-  constructor(
-    readonly scenario: IScenarioDefinition,
-    readonly eventManager: EventManager,
-    readonly expectEngine: ExpectEngine
-  ) {}
+  readonly handlers: Record<string, IScenarioCommand> = {};
+
+  constructor(readonly scenario: IScenarioDefinition, readonly eventManager: EventManager) {}
+
+  registerCommands(commands: Record<string, IScenarioCommand>) {
+    Object.assign(this.handlers, commands);
+  }
 
   validate() {
     const { scenario } = this;
@@ -71,26 +68,24 @@ export class TestScenario {
   async start(client: APIClient) {
     this.stepIndex = 0;
     this.client = client;
-    await this.nextStep();
-  }
-
-  async nextStep() {
-    if (this.client?.running) {
-      void this.client.simPause();
+    for (const step of this.scenario.steps) {
+      if (client.running) {
+        void client.simPause();
+      }
+      if (step.name) {
+        this.log(chalk`{gray Executing step:} {yellow ${step.name}`);
+      }
+      await this.executeStep(client, step);
     }
+    this.log(chalk`{green Scenario completed successfully}`);
+    process.exit(0);
+  }
 
-    const step = this.scenario.steps[this.stepIndex];
-    if (step == null) {
-      this.log(chalk`{green Scenario completed successfully}`);
-      process.exit(0);
-    }
-    if (step.name) {
-      this.log(chalk`{gray Executing step:} {yellow ${step.name}`);
-    }
-    for (const key of Object.keys(this.handlers) as Array<keyof typeof this.handlers>) {
+  async executeStep(client: APIClient, step: IStepDefinition) {
+    for (const key of Object.keys(this.handlers)) {
       if (key in step) {
         const value = step[key];
-        void this.handlers[key](value as any, step);
+        await this.handlers[key].run(this, client, value);
         this.stepIndex++;
         return;
       }
@@ -103,37 +98,13 @@ export class TestScenario {
     console.log(chalk`{cyan [${this.scenario.name}]}`, message);
   }
 
+  fail(message: string) {
+    throw new Error(`[${this.client?.lastNanos}ns] ${message}`);
+  }
+
   async resume() {
     await this.client?.simResume(
       this.eventManager.timeToNextEvent >= 0 ? this.eventManager.timeToNextEvent : undefined
     );
   }
-
-  handlers = {
-    'wait-serial': async (text: string) => {
-      this.expectEngine.expectTexts.push(text);
-      this.expectEngine.once('match', () => {
-        this.log(chalk`Expected text matched: {green "${text}"}`);
-        const textIndex = this.expectEngine.expectTexts.indexOf(text);
-        if (textIndex >= 0) {
-          this.expectEngine.expectTexts.splice(textIndex, 1);
-        }
-        void this.nextStep();
-      });
-      await this.resume();
-    },
-    delay: async (value: string, step: IStepDefinition) => {
-      const nanos = parseTime(value);
-      const targetNanos = (this.client?.lastNanos ?? 0) + nanos;
-      this.log(chalk`delay {yellow ${value}}`);
-      this.eventManager.at(targetNanos, () => {
-        void this.nextStep();
-      });
-      await this.resume();
-    },
-    'set-control': async (params: ISetControlParams) => {
-      await this.client?.controlSet(params['part-id'], params.control, params.value);
-      await this.nextStep();
-    },
-  };
 }

src/main.ts

@@ -12,6 +12,9 @@ import { parseConfig } from './config';
 import { cliHelp } from './help';
 import { loadChips } from './loadChips';
 import { readVersion } from './readVersion';
+import { DelayCommand } from './scenario/DelayCommand';
+import { SetControlCommand } from './scenario/SetControlCommand';
+import { WaitSerialCommand } from './scenario/WaitSerialCommand';
 
 const millis = 1_000_000;
 
@@ -110,9 +113,13 @@ async function main() {
   if (resolvedScenarioFile) {
     scenario = new TestScenario(
       YAML.parse(readFileSync(resolvedScenarioFile, 'utf-8')),
-      eventManager,
-      expectEngine
+      eventManager
     );
+    scenario.registerCommands({
+      delay: new DelayCommand(eventManager),
+      'set-control': new SetControlCommand(),
+      'wait-serial': new WaitSerialCommand(expectEngine),
+    });
     scenario.validate();
   }
 
@@ -166,7 +173,7 @@ async function main() {
     console.log('Starting simulation...');
   }
 
-  await scenario?.start(client);
+  const scenarioPromise = scenario?.start(client);
 
   if (timeoutNanos) {
     eventManager.at(timeoutNanos, () => {
@@ -220,6 +227,8 @@ async function main() {
   if (timeToNextEvent > 0) {
     await client.simResume(timeToNextEvent);
   }
+
+  await scenarioPromise;
 }
 
 main().catch((err) => {

src/scenario/DelayCommand.ts

@@ -0,0 +1,21 @@
+import chalk from 'chalk';
+import { type APIClient } from '../APIClient';
+import { type EventManager } from '../EventManager';
+import { type TestScenario } from '../TestScenario';
+import { parseTime } from '../utils/parseTime';
+import { promiseAndResolver } from '../utils/promise';
+
+export class DelayCommand {
+  constructor(readonly eventManager: EventManager) {}
+
+  async run(scenario: TestScenario, client: APIClient, value: string) {
+    const nanos = parseTime(value);
+    const targetNanos = (client.lastNanos ?? 0) + nanos;
+    scenario.log(chalk`delay {yellow ${value}}`);
+    const delayPromise = promiseAndResolver();
+    this.eventManager.at(targetNanos, () => {
+      delayPromise.resolve();
+    });
+    await Promise.all([scenario.resume(), delayPromise.promise]);
+  }
+}

src/scenario/SetControlCommand.ts

@@ -0,0 +1,14 @@
+import { type APIClient } from '../APIClient';
+import { type TestScenario } from '../TestScenario';
+
+export interface ISetControlParams {
+  'part-id': string;
+  control: string;
+  value: number;
+}
+
+export class SetControlCommand {
+  async run(scenario: TestScenario, client: APIClient, params: ISetControlParams) {
+    await client.controlSet(params['part-id'], params.control, params.value);
+  }
+}

src/scenario/WaitSerialCommand.ts

@@ -0,0 +1,23 @@
+import chalk from 'chalk';
+import type { APIClient } from '../APIClient';
+import type { ExpectEngine } from '../ExpectEngine';
+import type { IScenarioCommand, TestScenario } from '../TestScenario';
+import { promiseAndResolver } from '../utils/promise';
+
+export class WaitSerialCommand implements IScenarioCommand {
+  constructor(readonly expectEngine: ExpectEngine) {}
+
+  async run(scenario: TestScenario, client: APIClient, text: string) {
+    this.expectEngine.expectTexts.push(text);
+    const { promise, resolve } = promiseAndResolver();
+    this.expectEngine.once('match', () => {
+      scenario.log(chalk`Expected text matched: {green "${text}"}`);
+      const textIndex = this.expectEngine.expectTexts.indexOf(text);
+      if (textIndex >= 0) {
+        this.expectEngine.expectTexts.splice(textIndex, 1);
+      }
+      resolve();
+    });
+    await Promise.all([scenario.resume(), promise]);
+  }
+}

src/utils/promise.ts

@@ -0,0 +1,9 @@
+export function promiseAndResolver<T = void>() {
+  let resolve: (value: T | Promise<T>) => void, reject: (reason?: any) => void;
+  const promise = new Promise<T>((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  });
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  return { promise, resolve: resolve!, reject: reject! };
+}