@nsshunt/stsappframework 3.1.214 → 3.1.216

package/src/testertesting/testCase01.ts

@@ -1,207 +0,0 @@
-/* eslint @typescript-eslint/no-explicit-any: 0, @typescript-eslint/no-unused-vars: 0 */  // --> OFF
-import { IRunnerInstance, IRunnerOptions, IRunner } from './commonTypes'
-
-import chalk from 'chalk';
-
-import { WorkerInstance } from './workerInstance'
-
-import { Sleep } from '@nsshunt/stsutils'
-
-declare interface LogMessageData {
-    indent: number
-    adder: number
-}
-
-declare type LogMessageDataSet = Record<string, LogMessageData>;
-
-export interface IRunnerOptionsEx extends IRunnerOptions {
-    sleepDuration: number
-    logMessageMod: number
-}
-
-export class TestCase01 implements IRunnerInstance {
-    #runner: IRunner
-    #workerInstance: WorkerInstance;
-    #logMessageDataSet: LogMessageDataSet = { };
-    #publishTelemetryTimeout: any = null;
-    #publishTelemetryCount: number = 0;
-    #maxBufferSize = 50; // Max number of PostTelemetry calls before a publish. This should always be less than the logger instrtument maxSize buffer (default 200)
-    #publishTelemetryTimeoutVal = 1000; // Maximum timne to wait between telemetry publish. The logic is what ever case comes first wins (see maxBufferSize).
-
-    constructor(workerInstance: WorkerInstance, runner: IRunner) {
-        this.#workerInstance = workerInstance;
-        this.#runner = runner;
-    }
-
-    #GenLogMessage = (runner: IRunner, iteration: number) => {
-        if (!this.#logMessageDataSet[runner.id]) {
-            this.#logMessageDataSet[runner.id] = {
-                adder: 1,
-                indent: 0
-            }
-        }
-        const logMessageData = this.#logMessageDataSet[runner.id];
-
-        let message = `${' '.repeat(logMessageData.indent)} [${runner.id}] >> Hello World << ${iteration}`;
-        const colorCode = runner.asyncRunnerContext.asyncRunnerId % 4;
-        switch (colorCode) {
-        case 0:
-            message = chalk.green(`${message}`);
-            break;
-        case 1:
-            message = chalk.yellow(`${message}`);
-            break;
-        case 2:
-            message = chalk.magenta(`${message}`);
-            break;
-        case 3:
-            message = chalk.white(`${message}`);
-            break;
-        }
-
-        console.log(message);
-        runner.instrumentData.message.push(message);
-        logMessageData.indent += logMessageData.adder;
-        if (logMessageData.indent > 20) {
-            logMessageData.adder = -1;
-        } else if (logMessageData.indent === 0) {
-            logMessageData.adder = 1;
-        }
-    }
-
-    #SetupTimeout = async () => {
-        if (!this.#publishTelemetryTimeout) {
-            this.#publishTelemetryTimeout = setTimeout(async () => {
-                console.log(chalk.yellow(`   **** TIMEOUT **** `));
-                await this.#PublishTelemetryData();
-                this.#publishTelemetryCount = 0;
-                this.#publishTelemetryTimeout = null;
-            }, this.#publishTelemetryTimeoutVal).unref();
-        }
-    }
-
-    #PublishTelemetryData = async () => {
-        this.#workerInstance.PostTelemetry(this.#runner);
-
-        console.log(chalk.red(`------------------------------------------------------------------------------------------------------------`));
-
-        // Now reset any instruments ready for the next cycle
-        this.#runner.instrumentData.velocity = 0;
-        this.#runner.instrumentData.message = [ ];
-        this.#runner.instrumentData.tx = 0;
-        this.#runner.instrumentData.rx = 0;
-
-        await Sleep(0);
-    }
-
-    #ForcePublishTelemetryData = async () => {
-        console.log(chalk.magenta(`   **** FORCED PUBLISH **** `));
-        await this.#PublishTelemetryData();
-    }
-
-    #PublishTelemetry = async () => {
-        this.#publishTelemetryCount++;
-
-        console.log(chalk.red(this.#publishTelemetryCount));
-
-        if (this.#publishTelemetryCount % this.#maxBufferSize === 0) {
-            console.log(chalk.cyan(`   **** MAX COUNT REACHED **** `));
-            this.#publishTelemetryCount = 0;
-            if (this.#publishTelemetryTimeout) {
-                clearTimeout(this.#publishTelemetryTimeout);
-                this.#publishTelemetryTimeout = null;
-            }
-            await this.#PublishTelemetryData();
-        }
-
-        if (!this.#publishTelemetryTimeout) {
-            this.#SetupTimeout();
-        }
-    }
-
-    Execute = async (iteration: number): Promise<boolean> => {
-        const start = performance.now();
-        const options = this.#runner.options as IRunnerOptionsEx;
-        this.#runner.instrumentData.coreCount = 1;
-        this.#runner.instrumentData.activeRequestCount++;
-        this.#runner.instrumentData.requestCount++;
-        this.#runner.instrumentData.velocity++;
-        this.#runner.instrumentData.tx += 256000;
-        this.#runner.instrumentData.rx += 6500000;
-        if (this.#runner.instrumentData.requestCount % options.logMessageMod === 0) {
-            this.#GenLogMessage(this.#runner, iteration);
-        }
-        if (this.#runner.instrumentData.requestCount % 1000 === 0) {
-            const message = `Worker: [${this.#runner.asyncRunnerContext.threadId}], Runner: [${this.#runner.asyncRunnerContext.asyncRunnerId}] has completed: [${this.#runner.instrumentData.requestCount}] iterations of max: [${options.executionProfile.iterations}]`;
-            console.log(message);
-            this.#runner.instrumentData.message = [message]
-        }
-
-        // Here is where we would do some actual work like make a REST call etc.
-        await Sleep(options.sleepDuration);
-
-        this.#runner.instrumentData.activeRequestCount--;
-        const end = performance.now();
-        const diff = end - start;
-        this.#runner.instrumentData.duration = diff;
-
-        await this.#PublishTelemetry();
-
-        return true;
-    }
-
-    #OutputLogMessage = async (message: string): Promise<void> => {
-        const messageOutput = chalk.grey(message);
-        console.log(messageOutput);
-        this.#runner.instrumentData.message.push(messageOutput);
-        await this.#PublishTelemetry();
-    }
-
-    StartRunner = async (): Promise<boolean> => {
-        await this.#OutputLogMessage(`StartRunner [${this.#runner.id}]`);
-        await this.#ForcePublishTelemetryData();
-        return true;
-    }
-
-    StopRunner = async (): Promise<boolean> => {
-        await this.#OutputLogMessage(`StopRunner [${this.#runner.id}]`);
-        await this.#ForcePublishTelemetryData();
-        return true;
-    }
-
-    TerminateRunner = async (): Promise<boolean> => {
-        await this.#OutputLogMessage(`TerminateRunner [${this.#runner.id}]`);
-        await this.#ForcePublishTelemetryData();
-        return true;
-    }
-
-    Completed = async (): Promise<boolean> => {
-        await this.#OutputLogMessage(`Completed [${this.#runner.id}] [${JSON.stringify(this.#runner.instrumentData)}]`);
-        await this.#ForcePublishTelemetryData();
-        return true;
-    }
-
-    PauseRunner = async (): Promise<boolean> => {
-        await this.#OutputLogMessage(`PauseRunner [${this.#runner.id}]`);
-        await this.#ForcePublishTelemetryData();
-        return true;
-    }
-
-    ResumeRunner = async (): Promise<boolean> => {
-        await this.#OutputLogMessage(`ResumeRunner [${this.#runner.id}]`);
-        await this.#ForcePublishTelemetryData();
-        return true;
-    }
-
-    ResetRunner = async (): Promise<boolean> => {
-        await this.#OutputLogMessage(`ResetRunner [${this.#runner.id}]`);
-        await this.#ForcePublishTelemetryData();
-        return true;
-    }
-
-    UpdateOptions = async (): Promise<boolean> => {
-        await this.#OutputLogMessage(`UpdateOptions [${this.#runner.id}]`);
-        await this.#ForcePublishTelemetryData();
-        return true;
-    }
-}

package/src/testertesting/workerInstance.ts

@@ -1,297 +0,0 @@
-/* eslint @typescript-eslint/no-explicit-any: 0, @typescript-eslint/no-unused-vars: 0 */  // --> OFF
-import { MessagePort } from 'worker_threads';
-
-import isNode from 'detect-node'
-
-import { IIWMessagePayload, eIWMessageCommands, IIWMessagePayloadContentBase, IRunnerInstance,
-    ISTSAgentWorkerMessagePort, IRunner, ITestRunnerTelemetryPayload, IWorkerOptions
-} from './commonTypes'
-
-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;
-    #runners: Record<string, IRunnerEx2RunState> = { };
-    #options: IWorkerOptions | null = null;
-
-    #debug = (message: string) => {
-        if (this.#options) {
-            console.log(chalk.green(`pid: [${process.pid}] ${(this.#options as IWorkerOptions).id} WorkerInstance::${message}`));
-        } else {
-            console.log(chalk.green(`pid: [${process.pid}] WorkerInstance::${message}`));
-        }
-    }
-
-    constructor() {
-        this.#debug(`constructor`)
-    }
-
-    GetRandomInt = (max: number) => {
-        this.#debug(`GetRandomInt`)
-        return Math.floor(Math.random() * Math.floor(max));
-    };
-
-     
-    StartWork = async (runner: IRunner): Promise<void> => {
-        this.#debug(`StartWork`)
-        return;
-    }
-
-    PostTelemetry = (runner: IRunner) => {
-        //debug(`WorkerInstance::PostTelemetry`)
-        if (this.#collectorCollectorPort) {
-            const message: IIWMessagePayload = {
-                command: eIWMessageCommands.InstrumentTelemetry,
-                payload: {
-                    runner
-                } as ITestRunnerTelemetryPayload
-            }
-            this.#collectorCollectorPort.postMessage(message);
-        }
-    }
-
-    get CollectorCollectorPort(): MessagePort | null {
-        return this.#collectorCollectorPort;
-    }
-
-    get Options(): IWorkerInstanceOptions | null {
-        return this.#options;
-    }
-
-    #SetMessagePort = (workerMessagePort: ISTSAgentWorkerMessagePort) => {
-        this.#debug(`SetMessagePort`)
-        this.#collectorCollectorPort = workerMessagePort.port as MessagePort;
-
-        // NodeJS version
-
-        if (isNode) {
-            this.#collectorCollectorPort.on('message', (data: any) => {
-                this.#debug(`collectorCollectorPort onmessage: ${data.data}`);
-            });
-        } else {
-            (this.#collectorCollectorPort as any).onmessage = function(data: any) { // MessageEvent
-                console.log(`collectorCollectorPort onmessage: ${data.data}`);
-            }
-        }
-
-        const response: IIWMessagePayload = {
-            command: eIWMessageCommands.MessagePortResponse,
-            payload: { } as IIWMessagePayloadContentBase
-        }
-
-        this.#collectorCollectorPort.postMessage(response);
-    }
-
-    CreateAsyncRunner = (testRunnerTelemetryPayload: ITestRunnerTelemetryPayload): IRunnerInstance | null => {
-        return null;
-    }
-
-    #AddRunner = (testRunnerTelemetryPayload: ITestRunnerTelemetryPayload): IRunner => {
-        this.#debug(`AddRunner`)
-        const { runner } = testRunnerTelemetryPayload;
-        const asyncRunnerInstance = this.CreateAsyncRunner(testRunnerTelemetryPayload);
-        if (asyncRunnerInstance) {
-            this.#runners[runner.id] = {
-                runnerInstance: asyncRunnerInstance,
-                runner: testRunnerTelemetryPayload.runner,
-                iteration: 0,
-                terminate: false,
-                paused: false
-            }
-        } else {
-            //@@ exception - implementation not found
-        }
-        return runner;
-    }
-
-    #StartRunner = async (testRunnerTelemetryPayload: ITestRunnerTelemetryPayload) => {
-        const { runner } = testRunnerTelemetryPayload;
-        this.#debug(`${chalk.magenta(`runner: [${runner.id}]`)} StartRunner`)
-        this.#runners[runner.id].terminate = false;
-        this.#runners[runner.id].paused = false;
-        
-        await this.#runners[runner.id].runnerInstance.StartRunner();
-        const ExecuteLoop = async () => {
-            //console.log(`ExecuteLoop: [${runner.id}]`);
-            if (this.#runners[runner.id].iteration < this.#runners[runner.id].runner.options.executionProfile.iterations) {
-                if (!this.#runners[runner.id].paused) {
-                    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 {
-                        await Sleep(50);
-                        ExecuteLoop();
-                    }
-                }
-            } else {
-                if (this.#collectorCollectorPort) {
-                    const message: IIWMessagePayload = {
-                        command: eIWMessageCommands.Completed,
-                        payload: {
-                            runner
-                        } as ITestRunnerTelemetryPayload
-                    }
-                    this.#collectorCollectorPort.postMessage(message);
-                }
-                await this.#runners[runner.id].runnerInstance.Completed();
-            }
-        }
-        ExecuteLoop();
-    }
-
-    #StopAllRunners = async (testRunnerTelemetryPayload: ITestRunnerTelemetryPayload) => {
-        this.#debug(`StopAllRunners`);
-        for (const [, runner] of Object.entries(this.#runners)) {
-            this.#debug(`${chalk.magenta(`runner: [${runner.runner.id}]`)} StopAllRunners`)
-            runner.terminate = true;
-            await runner.runnerInstance.StopRunner();
-        }
-        await Sleep(0);
-    }
-
-    #StopRunner = async (testRunnerTelemetryPayload: ITestRunnerTelemetryPayload) => {
-        const { runner } = testRunnerTelemetryPayload;
-        this.#debug(`${chalk.magenta(`runner: [${runner.id}]`)} StopRunner`)
-        this.#runners[runner.id].terminate = true;
-        await this.#runners[runner.id].runnerInstance.StopRunner();
-        await Sleep(0);
-    }
-
-    #TerminateRunner = async (testRunnerTelemetryPayload: ITestRunnerTelemetryPayload) => {
-        const { runner } = testRunnerTelemetryPayload;
-        this.#debug(`${chalk.magenta(`runner: [${runner.id}]`)} TerminateRunner`)
-        this.#runners[runner.id].terminate = true;
-        await this.#runners[runner.id].runnerInstance.TerminateRunner();
-        await Sleep(0);
-    }
-
-    #PauseRunner = async (testRunnerTelemetryPayload: ITestRunnerTelemetryPayload) => {
-        const { runner } = testRunnerTelemetryPayload;
-        this.#debug(`${chalk.magenta(`runner: [${runner.id}]`)} PauseRunner`)
-        this.#runners[runner.id].paused = true;
-        await this.#runners[runner.id].runnerInstance.PauseRunner();
-        await Sleep(0);
-    }
-
-    #ResumeRunner = async (testRunnerTelemetryPayload: ITestRunnerTelemetryPayload) => {
-        const { runner } = testRunnerTelemetryPayload;
-        this.#debug(`${chalk.magenta(`runner: [${runner.id}]`)} ResumeRunner`)
-        this.#runners[runner.id].paused = false;
-        await this.#runners[runner.id].runnerInstance.ResumeRunner();
-        await Sleep(0);
-        //@@ todo
-    }
-
-    #ResetRunner = async (testRunnerTelemetryPayload: ITestRunnerTelemetryPayload) => {
-        const { runner } = testRunnerTelemetryPayload;
-        this.#debug(`${chalk.magenta(`runner: [${runner.id}]`)} ResetRunner`)
-        this.#runners[runner.id].terminate = true;
-        this.#runners[runner.id].iteration = 0;
-        await this.#runners[runner.id].runnerInstance.ResetRunner();
-        await Sleep(0);
-    }
-
-    // Execute a single iteration of this runners work item
-    #ExecuteRunner = async (testRunnerTelemetryPayload: ITestRunnerTelemetryPayload) => {
-        const { runner } = testRunnerTelemetryPayload;
-        this.#debug(`${chalk.magenta(`runner: [${runner.id}]`)} ExecuteRunner`)
-        await this.#runners[runner.id].runnerInstance.Execute(this.#runners[runner.id].iteration);
-        this.#runners[runner.id].iteration++;
-        await Sleep(0);
-        //@@ todo
-    }
-
-    #UpdateOptions = async (testRunnerTelemetryPayload: ITestRunnerTelemetryPayload) => {
-        const { runner } = testRunnerTelemetryPayload;
-        this.#debug(`${chalk.magenta(`runner: [${runner.id}]`)} UpdateOptions`)
-        console.log(chalk.cyan(`before: [${JSON.stringify(this.#runners[runner.id].runner.options)}]`))
-        this.#runners[runner.id].runner.options = { ...runner.options };
-        console.log(chalk.cyan(`after: [${JSON.stringify(this.#runners[runner.id].runner.options)}]`))
-        await this.#runners[runner.id].runnerInstance.UpdateOptions();
-        await Sleep(0);
-    }
-
-    // ProcessMessage = async(data: MessageEvent) => { // Browser version
-    ProcessMessage = async(data: any) => {
-        //this.#debug(`ProcessMessage: data: [${JSON.stringify(data)}]`)
-        try {
-            const payloadMessage: IIWMessagePayload = data as IIWMessagePayload;
-            switch (payloadMessage.command) {
-            case eIWMessageCommands.MessagePort :
-                this.#debug(`ProcessMessage::MessagePort`)
-                this.#SetMessagePort(payloadMessage.payload as ISTSAgentWorkerMessagePort);
-                this.#options = (payloadMessage.payload as ISTSAgentWorkerMessagePort).options;
-                this.#debug(`ProcessMessage::#options: [${JSON.stringify(this.#options)}]`)
-                break;
-            case eIWMessageCommands.AddRunner :
-                this.#debug(`ProcessMessage::AddRunner`)
-                this.#AddRunner(payloadMessage.payload as ITestRunnerTelemetryPayload);
-                break;
-            case eIWMessageCommands.StopAllRunners :
-                this.#debug(`ProcessMessage::StopAllRunners`)
-                this.#StopAllRunners(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.TerminateRunner :
-                this.#debug(`ProcessMessage::TerminateRunner`)
-                this.#TerminateRunner(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;  
-            case eIWMessageCommands.UpdateOptions :
-                this.#debug(`ProcessMessage::UpdateOptions`)
-                this.#UpdateOptions(payloadMessage.payload as ITestRunnerTelemetryPayload);
-                break;  
-            default :
-                this.#debug(`ProcessMessage::default`)
-                this.#debug(`Invalid payloadMessage.command: [${payloadMessage.command}] - Ignoring`);
-            }
-        } catch (error) {
-            console.log(error);
-        }
-    }
-}