@nsshunt/stsappframework 3.1.161 → 3.1.163

package/src/testertesting/workerInstance.ts

@@ -1,10 +1,9 @@
 /* eslint @typescript-eslint/no-explicit-any: 0, @typescript-eslint/no-unused-vars: 0 */  // --> OFF
 import { MessagePort } from 'worker_threads';
 
-import { IIWMessagePayload, eIWMessageCommands, IIWMessagePayloadContentBase } from './commonTypes'
-
-import type { ISTSAgentWorkerMessagePort, IRunner, ITestRunnerTelemetryPayload } from './stsTestWorkerDefinitions'
-import { IRunnerState } from './stsTestWorkerDefinitions'
+import { IIWMessagePayload, eIWMessageCommands, IIWMessagePayloadContentBase, IRunnerInstance,
+    ISTSAgentWorkerMessagePort, IRunner, ITestRunnerTelemetryPayload, IRunnerEx
+} from './commonTypes'
 
 import { RequestResponseHelper } from './requestResponseHelper'
 
@@ -12,22 +11,31 @@ import chalk from 'chalk';
 // Force chalk level
 chalk.level = 3;
 
+import { Sleep } from '@nsshunt/stsutils';
+
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
 export interface IWorkerInstanceOptions {
 
 }
 
+export interface IRunnerEx2RunState {
+    runnerInstance: IRunnerInstance
+    runner: IRunner
+    iteration: number
+    terminate: boolean
+    paused: boolean
+}
+
 export abstract class WorkerInstance {
     #collectorCollectorPort: MessagePort | null = null;
     #requestResponseHelper: RequestResponseHelper | null = null;
-    #runners: Record<string, IRunner> = { };
+    #runners: Record<string, IRunnerEx2RunState> = { };
     #options: IWorkerInstanceOptions | null = null;
 
     #debug = (message: string) => {
         console.log(chalk.green(`pid: [${process.pid}] WorkerInstance::${message}`));
     }
 
-
     constructor() {
         this.#debug(`constructor`)
     }
@@ -94,32 +102,103 @@ export abstract class WorkerInstance {
         this.#collectorCollectorPort.postMessage(response);
     }
 
-    StartRunner = async (runner: IRunner) => {
-        this.#debug(`StartRunner`)
-        this.#debug(`StartTests: [${JSON.stringify(runner)}]`);
-        runner.state = IRunnerState.running;
-        this.StartWork(runner);
+    CreateAsyncRunner = (testRunnerTelemetryPayload: ITestRunnerTelemetryPayload): IRunnerInstance | null => {
+        return null;
     }
 
-    #AddAsyncRunner = (testRunnerTelemetryPayload: ITestRunnerTelemetryPayload) => {
+    #AddAsyncRunner = (testRunnerTelemetryPayload: ITestRunnerTelemetryPayload): IRunner => {
         this.#debug(`AddAsyncRunner`)
         const { runner } = testRunnerTelemetryPayload;
-        this.#runners[runner.id] = runner;
-        this.StartRunner(runner);
-    }
-
-    #StopRunners = (testRunnerTelemetryPayload: ITestRunnerTelemetryPayload) => {
-        this.#debug(`StopRunners`)
-        if (testRunnerTelemetryPayload === null) {
-            for (const [, testRunner] of Object.entries(this.#runners)) {
-                testRunner.state = IRunnerState.stopped;
+        const asyncRunnerInstance = this.CreateAsyncRunner(testRunnerTelemetryPayload);
+        if (asyncRunnerInstance) {
+            this.#runners[runner.id] = {
+                runnerInstance: asyncRunnerInstance,
+                runner: testRunnerTelemetryPayload.runner,
+                iteration: 0,
+                terminate: false,
+                paused: false
             }
         } else {
-            const runner: IRunner = this.#runners[testRunnerTelemetryPayload.runner.id];
-            if (runner) {
-                runner.state = IRunnerState.stopped;
+            //@@ exception - implementation not found
+        }
+        return runner;
+    }
+
+    //@@ re4set iteration count - need a reset
+
+    #StartRunner = (testRunnerTelemetryPayload: ITestRunnerTelemetryPayload) => {
+        this.#debug(`StartRunner`)
+        const { runner } = testRunnerTelemetryPayload;
+        this.#runners[runner.id].terminate = false;
+        this.#runners[runner.id].paused = false;
+        
+        const ExecuteLoop = async () => {
+            if (this.#runners[runner.id].iteration < this.#runners[runner.id].runner.options.executionProfile.iterations) {
+                await this.#runners[runner.id].runnerInstance.Execute(this.#runners[runner.id].iteration);
+                this.#runners[runner.id].iteration++;
+                await Sleep(0); // Yield to the event loop to make sure we can process worker messages if any in the event loop queue
+                if (!this.#runners[runner.id].terminate) {
+                    if (!this.#runners[runner.id].paused) {
+                        await Sleep(this.#runners[runner.id].runner.options.executionProfile.delayBetweenIterations);
+                        ExecuteLoop();
+                    }
+                }
+            } else {
+                if (this.#collectorCollectorPort) {
+                    const message: IIWMessagePayload = {
+                        command: eIWMessageCommands.Completed,
+                        payload: {
+                            runner
+                        } as ITestRunnerTelemetryPayload
+                    }
+                    this.#collectorCollectorPort.postMessage(message);
+                }
             }
         }
+        ExecuteLoop();
+    }
+
+    #StopRunners = (testRunnerTelemetryPayload: ITestRunnerTelemetryPayload) => {
+        this.#debug(`StopRunners`);
+        for (const [, runner] of Object.entries(this.#runners)) {
+            runner.terminate = true;
+        }
+    }
+
+    #StopRunner = (testRunnerTelemetryPayload: ITestRunnerTelemetryPayload) => {
+        this.#debug(`StopRunner`)
+        const { runner } = testRunnerTelemetryPayload;
+        this.#runners[runner.id].terminate = true;
+    }
+
+    #PauseRunner = (testRunnerTelemetryPayload: ITestRunnerTelemetryPayload) => {
+        this.#debug(`PauseRunner`)
+        const { runner } = testRunnerTelemetryPayload;
+        this.#runners[runner.id].paused = true;
+    }
+
+    #ResumeRunner = (testRunnerTelemetryPayload: ITestRunnerTelemetryPayload) => {
+        this.#debug(`ResumeRunner`);
+        const { runner } = testRunnerTelemetryPayload;
+        this.#runners[runner.id].paused = false;
+        this.#StartRunner(testRunnerTelemetryPayload);
+        //@@ todo
+    }
+
+    #ResetRunner = (testRunnerTelemetryPayload: ITestRunnerTelemetryPayload) => {
+        this.#debug(`ResetRunner`)
+        const { runner } = testRunnerTelemetryPayload;
+        this.#runners[runner.id].terminate = true;
+        this.#runners[runner.id].iteration = 0;
+    }
+
+    // Execute a single iteration of this runners work item
+    #ExecuteRunner = (testRunnerTelemetryPayload: ITestRunnerTelemetryPayload) => {
+        this.#debug(`ExecuteRunner`)
+        const { runner } = testRunnerTelemetryPayload;
+        this.#runners[runner.id].runnerInstance.Execute(this.#runners[runner.id].iteration);
+        this.#runners[runner.id].iteration++;
+        //@@ todo
     }
 
     // ProcessMessage = async(data: MessageEvent) => { // Browser version
@@ -143,6 +222,31 @@ export abstract class WorkerInstance {
                 this.#debug(`ProcessMessage::StopAllAsyncRunners`)
                 this.#StopRunners(payloadMessage.payload as ITestRunnerTelemetryPayload);
                 break;
+            case eIWMessageCommands.StartRunner :
+                this.#debug(`ProcessMessage::StartRunner`)
+                this.#StartRunner(payloadMessage.payload as ITestRunnerTelemetryPayload);
+                break;
+            case eIWMessageCommands.StopRunner :
+                this.#debug(`ProcessMessage::StopRunner`)
+                this.#StopRunner(payloadMessage.payload as ITestRunnerTelemetryPayload);
+                break;
+            case eIWMessageCommands.PauseRunner :
+                this.#debug(`ProcessMessage::PauseRunner`)
+                this.#PauseRunner(payloadMessage.payload as ITestRunnerTelemetryPayload);
+                break;  
+            case eIWMessageCommands.ResumeRunner :
+                this.#debug(`ProcessMessage::ResumeRunner`)
+                this.#ResumeRunner(payloadMessage.payload as ITestRunnerTelemetryPayload);
+                break;  
+            case eIWMessageCommands.ResetRunner :
+                this.#debug(`ProcessMessage::ResetRunner`)
+                this.#ResetRunner(payloadMessage.payload as ITestRunnerTelemetryPayload);
+                break;  
+            case eIWMessageCommands.ExecuteRunner :
+                this.#debug(`ProcessMessage::ExecuteRunner`)
+                this.#ExecuteRunner(payloadMessage.payload as ITestRunnerTelemetryPayload);
+                //@@ should return a response ??
+                break;  
             default :
                 this.#debug(`ProcessMessage::default`)
                 this.#debug(`Invalid payloadMessage.command: [${payloadMessage.command}] - Ignoring`);

package/src/testertesting/workerManager.ts

@@ -1,22 +1,20 @@
 /* eslint @typescript-eslint/no-explicit-any: 0, @typescript-eslint/no-unused-vars: 0 */  // --> OFF
 //import MyWorker from './sts-worker?worker' // https://vitejs.dev/guide/features.html#web-workers
-import { type IAsyncRunnerContext, IIWMessagePayload, IIWMessagePayloadContentBase, 
-    type IIWMessageCommand, eIWMessageCommands } from './commonTypes'
-    
-import { Gauge, InstrumentGaugeTelemetry } from '@nsshunt/stsobservability'
+import { IAsyncRunnerContext, IIWMessagePayload, IIWMessagePayloadContentBase, 
+    IIWMessageCommand, eIWMessageCommands, IWorkerState, IRunnerState,
+    ISTSAgentWorkerMessagePort, IWorkerEx, IRunner, IRunnerEx,
+    ITestRunnerTelemetryPayload, IRunnerOptions, IRunnerTelemetry,
+    IWorkerManagerOptions, IWorkerFactory, IRunnerEvent
+} from './commonTypes'
 
 import { ModelDelimeter } from '@nsshunt/stsutils'
 
-import type { ISTSAgentWorkerMessagePort, IWorkerEx, IRunner, IRunnerEx,
-    ITestRunnerTelemetryPayload, IRunnerOptions, IRunnerTelemetry,
-    IWorkerManagerOptions, IWorkerFactory } from './stsTestWorkerDefinitions'
-
-import { IWorkerState, IRunnerState } from './stsTestWorkerDefinitions'
 import { Sleep } from '@nsshunt/stsutils';
 
 import { AgentInstrumentController, PublishInstrumentController } from '@nsshunt/stsobservability'
 
 import chalk from 'chalk';
+import { TelemetryProcessor } from './telemetryProcessor'
 chalk.level = 3;
 
 export class STSWorkerManager {
@@ -26,9 +24,8 @@ export class STSWorkerManager {
     #workerId = 0;
     #options: IWorkerManagerOptions;
     #STSInstrumentController: PublishInstrumentController
-     
+    #telemetryProcessor: TelemetryProcessor
     #app: any
-
      
     constructor(app: any, options?: IWorkerManagerOptions) {
         this.#app = app;
@@ -39,6 +36,7 @@ export class STSWorkerManager {
         }
 
         this.#STSInstrumentController = this.#options.publishInstrumentController;
+        this.#telemetryProcessor = new TelemetryProcessor();
     }
     
     #debug = (message: string) => {
@@ -49,6 +47,14 @@ export class STSWorkerManager {
         return this.#workersEx;
     }
 
+    get runnerId(): number {
+        return this.#runner;
+    }
+
+    set runnerId(id: number) {
+        this.#runner = id;
+    }
+
     AddWorker = async (useWorkerFactory?: IWorkerFactory): Promise<IWorkerEx> => {
         let workerFactory: IWorkerFactory;
         if (useWorkerFactory) {
@@ -58,17 +64,24 @@ export class STSWorkerManager {
             // Use the default workFactory
             workerFactory = this.#options.workerFactory
         }
+
+        const workerId = this.#workerId++;
         const stsWorkerEx: IWorkerEx = {
-            id: this.#workerId++, // uuidv4()
+            id: workerId,
             worker: workerFactory.createWorkerThreadWorker(),
             primaryWorker: workerFactory.createPrimaryThreadWorker(this.#app, workerFactory.primaryThreadWorkerOptions),
             state: IWorkerState.starting,
             workerThreadWorkerOptions: workerFactory.workerThreadWorkerOptions,
             primaryThreadWorkerOptions: workerFactory.primaryThreadWorkerOptions,
             runnersEx: { } as Record<string, IRunnerEx>,
+            runnersEvents: { } as Record<string, IRunnerEvent[]>,
             AddRunner: (runnerOptions: IRunnerOptions): IRunnerEx => this.AddRunnerToWorker(stsWorkerEx, runnerOptions),
+            StartRunner: (runner: IRunnerEx): Promise<boolean> => this.#StartRunner(stsWorkerEx, runner),
             StopRunner: (runner: IRunnerEx): Promise<boolean> => this.#StopRunner(stsWorkerEx, runner),
-            Stop: async (): Promise<boolean> => this.#StopWorker(stsWorkerEx)
+            PauseRunner: (runner: IRunnerEx): Promise<boolean> => this.#PauseRunner(stsWorkerEx, runner),
+            ResumeRunner: (runner: IRunnerEx): Promise<boolean> => this.#ResumeRunner(stsWorkerEx, runner),
+            Stop: async (): Promise<boolean> => this.#StopWorker(stsWorkerEx),
+            GetRunner: (id: string): IRunnerEx | null => this.#workersEx[workerId].GetRunner(id)
         }
         this.#STSInstrumentController.LogEx(chalk.yellow(`pid: [${process.pid}] Creating new worker: [${stsWorkerEx.id}]`));
         this.#debug(`Adding worker: [${stsWorkerEx.id}]`);
@@ -105,13 +118,17 @@ export class STSWorkerManager {
             const publishMessagePayload: IIWMessagePayload = data as IIWMessagePayload;
             switch (publishMessagePayload.command) {
             case eIWMessageCommands.MessagePortResponse : 
-                this.#debug(`AddWorker::eIWMessageCommands.MessagePortResponse`);
+                //this.#debug(`AddWorker::eIWMessageCommands.MessagePortResponse`);
                 stsWorkerEx.state = IWorkerState.started;
                 break;
             case eIWMessageCommands.InstrumentTelemetry :
-                this.#debug(`AddWorker::eIWMessageCommands.InstrumentTelemetry`);
+                //this.#debug(`AddWorker::eIWMessageCommands.InstrumentTelemetry`);
                 this.#ProcessTelemetry(stsWorkerEx, publishMessagePayload.payload as ITestRunnerTelemetryPayload);
                 break;
+            case eIWMessageCommands.Completed :
+                //this.#debug(`AddWorker::eIWMessageCommands.InstrumentTelemetry`);
+                this.#ProcessCompleted(stsWorkerEx, publishMessagePayload.payload as ITestRunnerTelemetryPayload);
+                break;
             default :
                 this.#debug(`AddWorker::default`);
                 stsWorkerEx.primaryWorker.ProcessMessageFromWorker(workerPort, publishMessagePayload);
@@ -138,7 +155,6 @@ export class STSWorkerManager {
             id: runnerEx.id,
             asyncRunnerContext: { ...runnerEx.asyncRunnerContext },
             options: { ...runnerEx.options },
-            state: runnerEx.state,
             instrumentData: { ...runnerEx.instrumentData }
         } as IRunner
     }
@@ -159,136 +175,17 @@ export class STSWorkerManager {
 
         if (workerEx.runnersEx[runner.id]) {
             const runnerEx: IRunnerEx = workerEx.runnersEx[runner.id];
-            let update = false;
 
             // Copy telemetry
             runnerEx.instrumentData = { ...runner.instrumentData };
 
-            this.#debug(JSON.stringify(runnerEx.instrumentData));
-
             if (runner.instrumentData.message) {
                 runnerEx.instrumentData.message = [...runner.instrumentData.message];
             } else {
                 runnerEx.instrumentData.message = [ ];
             }
 
-            if (runner.instrumentData.message) {
-                runner.instrumentData.message.forEach((message) => {
-                    runnerEx.publishInstrumentController.LogEx(message);
-                });
-                update = true;
-            }
-
-            if (runner.instrumentData.requestCount) {
-                runnerEx.publishInstrumentController.UpdateInstrument(Gauge.REQUEST_COUNT_GAUGE, {
-                    val: runnerEx.instrumentData.requestCount
-                } as InstrumentGaugeTelemetry);
-                update = true;
-            }
-
-            if (runner.instrumentData.errorCount) {
-                runnerEx.publishInstrumentController.UpdateInstrument(Gauge.ERROR_COUNT_GAUGE, {
-                    val: runnerEx.instrumentData.errorCount
-                } as InstrumentGaugeTelemetry);
-                update = true;
-            }
-
-            if (runner.instrumentData.retryCount) {
-                runnerEx.publishInstrumentController.UpdateInstrument(Gauge.RETRY_COUNT_GAUGE, {
-                    val: runnerEx.instrumentData.retryCount
-                } as InstrumentGaugeTelemetry);
-                update = true;
-            }
-
-            if (runner.instrumentData.authenticationCount) {
-                runnerEx.publishInstrumentController.UpdateInstrument(Gauge.AUTHENTICATION_COUNT_GAUGE, {
-                    val: runnerEx.instrumentData.authenticationCount
-                } as InstrumentGaugeTelemetry);
-                update = true;
-            }
-
-            if (runner.instrumentData.authenticationErrorCount) {
-                runnerEx.publishInstrumentController.UpdateInstrument(Gauge.AUTHENTICATION_ERROR_COUNT_GAUGE, {
-                    val: runnerEx.instrumentData.authenticationCount
-                } as InstrumentGaugeTelemetry);
-                update = true;
-            }
-
-            if (runner.instrumentData.authenticationRetryCount) {
-                runnerEx.publishInstrumentController.UpdateInstrument(Gauge.AUTHENTICATION_RETRY_COUNT_GAUGE, {
-                    val: runnerEx.instrumentData.authenticationCount
-                } as InstrumentGaugeTelemetry);
-                update = true;
-            }
-
-            if (runner.instrumentData.coreCount) {
-                runnerEx.publishInstrumentController.UpdateInstrument(Gauge.CORE_COUNT_GAUGE, {
-                    val: runnerEx.instrumentData.coreCount
-                } as InstrumentGaugeTelemetry);
-                update = true;
-            }
-
-            if (runner.instrumentData.timer) {
-                runnerEx.publishInstrumentController.UpdateInstrument(Gauge.TIMER_GAUGE, {
-                    val: runnerEx.instrumentData.timer
-                } as InstrumentGaugeTelemetry);
-                update = true;
-            }
-
-            if (runner.instrumentData.activeRequestCount) {
-                runnerEx.publishInstrumentController.UpdateInstrument(Gauge.ACTIVE_REQUEST_GAUGE, {
-                    val: runnerEx.instrumentData.activeRequestCount
-                } as InstrumentGaugeTelemetry);
-                update = true;
-            }
-
-            if (runner.instrumentData.velocity) {
-                runnerEx.publishInstrumentController.UpdateInstrument(Gauge.VELOCITY_GAUGE, {
-                    Inc: runnerEx.instrumentData.velocity
-                } as InstrumentGaugeTelemetry);
-                update = true;
-            }
-
-            if (runner.instrumentData.duration) {
-                runnerEx.publishInstrumentController.UpdateInstrument(Gauge.DURATION_GAUGE, {
-                    val: runnerEx.instrumentData.duration
-                } as InstrumentGaugeTelemetry);
-                runnerEx.publishInstrumentController.UpdateInstrument(Gauge.DURATION_HISTOGRAM_GAUGE, {
-                    val: runnerEx.instrumentData.duration
-                } as InstrumentGaugeTelemetry);
-                update = true;
-            }
-
-            if (runner.instrumentData.latency) {
-                runnerEx.publishInstrumentController.UpdateInstrument(Gauge.LATENCY_GAUGE, {
-                    val: runnerEx.instrumentData.latency
-                } as InstrumentGaugeTelemetry);
-                runnerEx.publishInstrumentController.UpdateInstrument(Gauge.LATENCY_HISTOGRAM_GAUGE, {
-                    val: runnerEx.instrumentData.latency
-                } as InstrumentGaugeTelemetry);
-                update = true;
-            }
-
-            if (runner.instrumentData.childCount) {
-                runnerEx.publishInstrumentController.UpdateInstrument(Gauge.CHILD_COUNT, {
-                    val: runnerEx.instrumentData.childCount
-                } as InstrumentGaugeTelemetry);
-                update = true;
-            }
-
-            if (runner.instrumentData.rx) {
-                runnerEx.publishInstrumentController.UpdateInstrument(Gauge.NETWORK_RX_GAUGE, {
-                    Inc: runnerEx.instrumentData.rx
-                } as InstrumentGaugeTelemetry);
-                update = true;
-            }
-
-            if (runner.instrumentData.tx) {
-                runnerEx.publishInstrumentController.UpdateInstrument(Gauge.NETWORK_TX_GAUGE, {
-                    Inc: runnerEx.instrumentData.tx
-                } as InstrumentGaugeTelemetry);
-                update = true;
-            }
+            const update = this.#telemetryProcessor.ProcessTelemetry(runnerEx.publishInstrumentController, runnerEx.instrumentData);
 
             if (update) {
                 //store.Update(workerEx, runnerEx);
@@ -296,6 +193,19 @@ export class STSWorkerManager {
         }
     }
 
+    #ProcessCompleted = (workerEx: IWorkerEx, payloadContents: ITestRunnerTelemetryPayload): void => {
+        const { runner } = payloadContents;
+        if (workerEx.runnersEvents[runner.id]) {
+            const runnersEvents: IRunnerEvent[] = workerEx.runnersEvents[runner.id];
+            runnersEvents.forEach(ev => {
+                if (ev.eventName.localeCompare('Completed') === 0) {
+                    ev.cb();
+                }
+            })
+        }
+        console.log(chalk.green(`ProcessCompleted: [${JSON.stringify(runner)}]`));
+    }
+
     #CreateAsyncRunner = (workerEx: IWorkerEx, runnerOptions: IRunnerOptions): IRunnerEx => {
         //const applicationStore = ApplicationStore();
         this.#runner++; // The runner number always increases
@@ -313,11 +223,11 @@ ${this.#runner}`,
             threadId: `worker${workerEx.id}`,
             asyncRunnerId: this.#runner
         }
+
         const runnerEx: IRunnerEx = {
             id: this.#runner,
             publishInstrumentController: (this.#STSInstrumentController as AgentInstrumentController).AddPublishInstrumentController(asyncRunnerContext),
             asyncRunnerContext: asyncRunnerContext,
-            state: IRunnerState.created,
             options: runnerOptions,
             instrumentData: {
                 requestCount: 0,
@@ -337,11 +247,27 @@ ${this.#runner}`,
                 rx: 0,
                 tx: 0
             } as IRunnerTelemetry,
-            Stop: async (): Promise<boolean> => this.#StopRunner(workerEx, runnerEx)
+            Start: async (): Promise<boolean> => this.#StartRunner(workerEx, runnerEx),
+            Stop: async (): Promise<boolean> => this.#StopRunner(workerEx, runnerEx),
+            Pause: async (): Promise<boolean> => this.#PauseRunner(workerEx, runnerEx),
+            Resume: async (): Promise<boolean> => this.#ResumeRunner(workerEx, runnerEx),
+            Reset: async (): Promise<boolean> => this.#ResetRunner(workerEx, runnerEx),
+            Execute: async (): Promise<boolean> => this.#ExecuteRunner(workerEx, runnerEx),
+            Terminate: async (): Promise<boolean> => this.#TerminateRunner(workerEx, runnerEx),
+            on: (eventName: string, cb: () => void): IRunnerEx => {
+                if (!workerEx.runnersEvents[runnerEx.id]) {
+                    workerEx.runnersEvents[runnerEx.id] = [ ];
+                }
+                workerEx.runnersEvents[runnerEx.id].push({
+                    eventName,
+                    cb
+                });
+                return runnerEx;
+            }
         }
+
         return runnerEx;
     }
-
      
     #PostMessageToWorker = (workerEx: IWorkerEx, command: IIWMessageCommand, payload: IIWMessagePayloadContentBase | null, transferObject?: any) => {
         if (transferObject) {
@@ -367,7 +293,35 @@ ${this.#runner}`,
         }
     }
 
-    #StopRunner = async (workerEx: IWorkerEx, runnerEx: IRunnerEx | null = null): Promise<boolean> => {
+    #StartRunner = async (workerEx: IWorkerEx, runnerEx: IRunnerEx): Promise<boolean> => {
+        this.#PostMessageToWorker(workerEx, eIWMessageCommands.StartRunner, {
+            runner: this.#CreateRunnerCopy(runnerEx)
+        } as ITestRunnerTelemetryPayload);
+        return true;
+    }
+
+    #ResetRunner = async (workerEx: IWorkerEx, runnerEx: IRunnerEx): Promise<boolean> => {
+        this.#PostMessageToWorker(workerEx, eIWMessageCommands.ResetRunner, {
+            runner: this.#CreateRunnerCopy(runnerEx)
+        } as ITestRunnerTelemetryPayload);
+        return true;
+    }
+
+    #ExecuteRunner = async (workerEx: IWorkerEx, runnerEx: IRunnerEx): Promise<boolean> => {
+        this.#PostMessageToWorker(workerEx, eIWMessageCommands.ExecuteRunner, {
+            runner: this.#CreateRunnerCopy(runnerEx)
+        } as ITestRunnerTelemetryPayload);
+        return true;
+    }
+
+    #StopRunner = async (workerEx: IWorkerEx, runnerEx: IRunnerEx): Promise<boolean> => {
+        this.#PostMessageToWorker(workerEx, eIWMessageCommands.StopRunner, {
+            runner: this.#CreateRunnerCopy(runnerEx)
+        } as ITestRunnerTelemetryPayload);
+        return true;
+    }
+
+    #TerminateRunner = async (workerEx: IWorkerEx, runnerEx: IRunnerEx | null = null): Promise<boolean> => {
         // If runnerEx not provided, Remove the first runner in the collection
         if (runnerEx === null) {
             const ids: string[] = Object.keys(workerEx.runnersEx);
@@ -377,7 +331,7 @@ ${this.#runner}`,
             }
         }
         if (runnerEx !== null) {
-            this.#PostMessageToWorker(workerEx, eIWMessageCommands.StopAllAsyncRunners, {
+            this.#PostMessageToWorker(workerEx, eIWMessageCommands.StopRunner, {
                 runner: this.#CreateRunnerCopy(runnerEx)
             } as ITestRunnerTelemetryPayload);
 
@@ -401,6 +355,20 @@ ${this.#runner}`,
         return true;
     }
 
+    #PauseRunner = async (workerEx: IWorkerEx, runnerEx: IRunnerEx): Promise<boolean> => {
+        this.#PostMessageToWorker(workerEx, eIWMessageCommands.PauseRunner, {
+            runner: this.#CreateRunnerCopy(runnerEx)
+        } as ITestRunnerTelemetryPayload);
+        return true;
+    }
+
+    #ResumeRunner = async (workerEx: IWorkerEx, runnerEx: IRunnerEx): Promise<boolean> => {
+        this.#PostMessageToWorker(workerEx, eIWMessageCommands.ResumeRunner, {
+            runner: this.#CreateRunnerCopy(runnerEx)
+        } as ITestRunnerTelemetryPayload);
+        return true;
+    }
+
     #StopWorker = async (workerEx: IWorkerEx): Promise<boolean> => {
         try {
             if (workerEx.state !== IWorkerState.stopped) {

package/src/testertesting/workerPrimaryTestRunner01.ts

@@ -5,7 +5,7 @@ import chalk from 'chalk';
 chalk.level = 3;
 
 import { IPrimaryWorker, IWorkerOptions, PublishMessageCommandsTestRunner, 
-    IIWMessagePayload, IIWMessagePayloadContentBase } from './stsTestWorkerDefinitions'
+    IIWMessagePayload, IIWMessagePayloadContentBase } from './commonTypes'
 
 //import { STSOAuth2Manager, STSOAuth2ManagerPluginKey } from '@nsshunt/stsoauth2plugin'
 

package/src/testertesting/workerWorkerTestRunner01.ts

@@ -3,10 +3,12 @@ import chalk from 'chalk';
 // Force chalk level
 chalk.level = 3;
 
-import { IRunner, IRunnerOptions, IRunnerState } from './stsTestWorkerDefinitions'
+import { IRunner, IRunnerOptions, IRunnerInstance, ITestRunnerTelemetryPayload, IRunnerEx } from './commonTypes'
 
 import { WorkerInstance } from './workerInstance'
 
+import { TestCase01 } from './testCase01'
+
 export interface IRunnerOptionsEx extends IRunnerOptions {
     iterations: number
     sleepDuration: number
@@ -99,6 +101,9 @@ export class WorkerWorkerTestRunner01 extends WorkerInstance {
         });
         */
 
+
+
+        /*
         while (runner.state !== IRunnerState.stopped) {
 
             await Sleep(0);
@@ -149,6 +154,23 @@ export class WorkerWorkerTestRunner01 extends WorkerInstance {
                 runner.instrumentData.rx = 0;
             }
         }
+            */
+    }
+}
+
+export class WorkerTestCases extends WorkerInstance {
+    constructor() {
+        super()
+    }
+
+    override CreateAsyncRunner = (testRunnerTelemetryPayload: ITestRunnerTelemetryPayload): IRunnerInstance | null => {
+        const { runner } = testRunnerTelemetryPayload;
+        switch (runner.options.testType) {
+        case 'TestCase01' :
+            return new TestCase01(this, runner)
+        }
+
+        return null;
     }
 }
 
@@ -161,7 +183,7 @@ import { Sleep } from '@nsshunt/stsutils';
 
 let messagePort: MessagePort;
 
-const worker = new WorkerWorkerTestRunner01();
+const worker = new WorkerTestCases();
 
 parentPort?.on('message', (data: any) => {