@nsshunt/stsappframework 3.1.160 → 3.1.162

package/src/testertesting/workerInstance.ts

@@ -0,0 +1,165 @@
+/* eslint @typescript-eslint/no-explicit-any: 0, @typescript-eslint/no-unused-vars: 0 */  // --> OFF
+import { MessagePort } from 'worker_threads';
+
+import { IIWMessagePayload, eIWMessageCommands, IIWMessagePayloadContentBase, IRunnerState,
+    ISTSAgentWorkerMessagePort, IRunner, ITestRunnerTelemetryPayload
+} from './commonTypes'
+
+import { RequestResponseHelper } from './requestResponseHelper'
+
+import chalk from 'chalk';
+// Force chalk level
+chalk.level = 3;
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export interface IWorkerInstanceOptions {
+
+}
+
+export abstract class WorkerInstance {
+    #collectorCollectorPort: MessagePort | null = null;
+    #requestResponseHelper: RequestResponseHelper | null = null;
+    #runners: Record<string, IRunner> = { };
+    #options: IWorkerInstanceOptions | null = null;
+
+    #debug = (message: string) => {
+        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 RequestResponseHelper(): RequestResponseHelper | null {
+        return this.#requestResponseHelper;
+    }
+
+    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
+        this.#collectorCollectorPort.on('message', (data: any) => {
+            this.#debug(`collectorCollectorPort onmessage: ${data.data}`);
+        });
+
+        // Browser Version
+        /*
+        this.#collectorCollectorPort.onmessage = function(data: MessageEvent) {
+            console.log(`collectorCollectorPort onmessage: ${data.data}`);
+        }
+        */
+
+        this.#requestResponseHelper = new RequestResponseHelper(this.#collectorCollectorPort);
+
+        const response: IIWMessagePayload = {
+            command: eIWMessageCommands.MessagePortResponse,
+            payload: { } as IIWMessagePayloadContentBase
+        }
+
+        this.#collectorCollectorPort.postMessage(response);
+    }
+
+    StartRunner = async (runner: IRunner) => {
+        this.#debug(`StartRunner`)
+        this.#debug(`StartTests: [${JSON.stringify(runner)}]`);
+        runner.state = IRunnerState.running;
+        this.StartWork(runner);
+    }
+
+    #AddAsyncRunner = (testRunnerTelemetryPayload: ITestRunnerTelemetryPayload): IRunner => {
+        this.#debug(`AddAsyncRunner`)
+        const { runner } = testRunnerTelemetryPayload;
+        this.#runners[runner.id] = runner;
+        return runner;
+        //this.StartRunner(runner);
+    }
+
+    #StartRunner = (testRunnerTelemetryPayload: ITestRunnerTelemetryPayload): IRunner => {
+        this.#debug(`StartRunner`)
+        const { runner } = testRunnerTelemetryPayload;
+        this.StartRunner(runner);
+        return runner;
+    }
+
+    #StopRunners = (testRunnerTelemetryPayload: ITestRunnerTelemetryPayload) => {
+        this.#debug(`StopRunners`)
+        if (testRunnerTelemetryPayload === null) {
+            for (const [, testRunner] of Object.entries(this.#runners)) {
+                testRunner.state = IRunnerState.stopped;
+            }
+        } else {
+            const runner: IRunner = this.#runners[testRunnerTelemetryPayload.runner.id];
+            if (runner) {
+                runner.state = IRunnerState.stopped;
+            }
+        }
+    }
+
+    // ProcessMessage = async(data: MessageEvent) => { // Browser version
+    ProcessMessage = async(data: any) => {
+        this.#debug(`ProcessMessage: data: [${JSON.stringify(data)}]`)
+        try {
+            // const payloadMessage: IIWMessagePayload = data.data as IIWMessagePayload; // browser version
+            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.AddAsyncRunner :
+                this.#debug(`ProcessMessage::AddAsyncRunner`)
+                this.#AddAsyncRunner(payloadMessage.payload as ITestRunnerTelemetryPayload);
+                break;
+            case eIWMessageCommands.StopAllAsyncRunners :
+                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;
+            default :
+                this.#debug(`ProcessMessage::default`)
+                this.#debug(`Invalid payloadMessage.command: [${payloadMessage.command}] - Ignoring`);
+            }
+        } catch (error) {
+            console.log(error);
+        }
+    }
+}

package/src/testertesting/workerManager.ts

@@ -0,0 +1,386 @@
+/* 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 { IAsyncRunnerContext, IIWMessagePayload, IIWMessagePayloadContentBase, 
+    IIWMessageCommand, eIWMessageCommands, IWorkerState, IRunnerState,
+    ISTSAgentWorkerMessagePort, IWorkerEx, IRunner, IRunnerEx,
+    ITestRunnerTelemetryPayload, IRunnerOptions, IRunnerTelemetry,
+    IWorkerManagerOptions, IWorkerFactory 
+} from './commonTypes'
+
+import { ModelDelimeter } from '@nsshunt/stsutils'
+
+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 {
+    //#agentSession: string = null;
+    #workersEx: Record<string, IWorkerEx> = { };
+    #runner = 0;
+    #workerId = 0;
+    #options: IWorkerManagerOptions;
+    #STSInstrumentController: PublishInstrumentController
+    #telemetryProcessor: TelemetryProcessor
+    #app: any
+     
+    constructor(app: any, options?: IWorkerManagerOptions) {
+        this.#app = app;
+        if (options) {
+            this.#options = options;
+        } else {
+            this.#options = { } as IWorkerManagerOptions;
+        }
+
+        this.#STSInstrumentController = this.#options.publishInstrumentController;
+        this.#telemetryProcessor = new TelemetryProcessor();
+    }
+    
+    #debug = (message: string) => {
+        console.log(chalk.cyan(`pid: [${process.pid}] STSWorkerManager::${message}`));
+    }
+
+    get WorkersEx(): Record<string, IWorkerEx> {
+        return this.#workersEx;
+    }
+
+    AddWorker = async (useWorkerFactory?: IWorkerFactory): Promise<IWorkerEx> => {
+        let workerFactory: IWorkerFactory;
+        if (useWorkerFactory) {
+            // Use the supplied workFactory
+            workerFactory = useWorkerFactory;
+        } else {
+            // Use the default workFactory
+            workerFactory = this.#options.workerFactory
+        }
+
+        const workerId = this.#workerId++;
+        const stsWorkerEx: IWorkerEx = {
+            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>,
+            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),
+            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}]`);
+
+        /*
+        stsWorkerEx.worker.onmessage = function(data: MessageEvent) {
+            console.log(data.data);
+        }
+
+        stsWorkerEx.worker.onerror = function(error) {
+            console.log(error);
+        };
+        */
+
+        const { 
+            port1, // process message port
+            port2  // collector message port
+        } = new MessageChannel();
+
+        const workerPort = port1;
+        
+        this.#debug(`AddWorker::workerThreadWorkerOptions: [${JSON.stringify(stsWorkerEx.workerThreadWorkerOptions)}]`);
+
+        this.#PostMessageToWorker(stsWorkerEx, eIWMessageCommands.MessagePort, {
+            port: port2,
+            //applicationStoreState: stateCopy,
+            options: { ...stsWorkerEx.workerThreadWorkerOptions }
+        } as ISTSAgentWorkerMessagePort, port2);
+    
+        // Process messages received back from the worker
+        //workerPort.onmessage = async (data: MessageEvent) => {
+        workerPort.on('message', (data: any) => {
+            // const publishMessagePayload: IIWMessagePayload = data.data as IIWMessagePayload; browser version
+            const publishMessagePayload: IIWMessagePayload = data as IIWMessagePayload;
+            switch (publishMessagePayload.command) {
+            case eIWMessageCommands.MessagePortResponse : 
+                this.#debug(`AddWorker::eIWMessageCommands.MessagePortResponse`);
+                stsWorkerEx.state = IWorkerState.started;
+                break;
+            case eIWMessageCommands.InstrumentTelemetry :
+                this.#debug(`AddWorker::eIWMessageCommands.InstrumentTelemetry`);
+                this.#ProcessTelemetry(stsWorkerEx, publishMessagePayload.payload as ITestRunnerTelemetryPayload);
+                break;
+            default :
+                this.#debug(`AddWorker::default`);
+                stsWorkerEx.primaryWorker.ProcessMessageFromWorker(workerPort, publishMessagePayload);
+            }
+        });
+
+        this.#workersEx[stsWorkerEx.id] = stsWorkerEx;
+
+        this.#debug(`Added worker: [${stsWorkerEx.id}]`);
+
+        return stsWorkerEx;
+    }
+
+    AddRunnerToWorker = (stsWorkerEx: IWorkerEx, runnerOptions: IRunnerOptions): IRunnerEx => {
+        const runnerEx: IRunnerEx = this.#CreateAsyncRunner(stsWorkerEx, runnerOptions);
+        stsWorkerEx.runnersEx[runnerEx.id] = runnerEx;
+        this.#SetRunnerIntoWorker(stsWorkerEx, runnerEx);
+        runnerEx.publishInstrumentController.LogEx(chalk.green(`Added runner: [${runnerEx.id}] into worker: [${stsWorkerEx.id}]`));
+        return runnerEx;
+    }
+
+    #CreateRunnerCopy(runnerEx: IRunnerEx): IRunner {
+        return {
+            id: runnerEx.id,
+            asyncRunnerContext: { ...runnerEx.asyncRunnerContext },
+            options: { ...runnerEx.options },
+            state: runnerEx.state,
+            instrumentData: { ...runnerEx.instrumentData }
+        } as IRunner
+    }
+
+    #SetRunnerIntoWorker = (workerEx: IWorkerEx, runnerEx: IRunnerEx): void => {
+        // Now that the worker is setup, send the options
+        //@@ wait until worker in running state
+        const payload: ITestRunnerTelemetryPayload = {
+            runner: this.#CreateRunnerCopy(runnerEx)
+        }
+        this.#PostMessageToWorker(workerEx, eIWMessageCommands.AddAsyncRunner, payload);
+    }
+
+    #ProcessTelemetry = (workerEx: IWorkerEx, payloadContents: ITestRunnerTelemetryPayload): void => {
+        //const store = TelemetryStore();
+
+        const { runner } = payloadContents;
+
+        if (workerEx.runnersEx[runner.id]) {
+            const runnerEx: IRunnerEx = workerEx.runnersEx[runner.id];
+
+            // 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 = [ ];
+            }
+
+            const update = this.#telemetryProcessor.ProcessTelemetry(runnerEx.publishInstrumentController, runnerEx.instrumentData);
+
+            if (update) {
+                //store.Update(workerEx, runnerEx);
+            }
+        }
+    }
+
+    #CreateAsyncRunner = (workerEx: IWorkerEx, runnerOptions: IRunnerOptions): IRunnerEx => {
+        //const applicationStore = ApplicationStore();
+        this.#runner++; // The runner number always increases
+        this.#STSInstrumentController.LogEx(chalk.yellow(`Creating new async runner: [${this.#runner}]`));
+        const asyncRunnerContext: IAsyncRunnerContext = {
+            nid: `\
+${workerEx.workerThreadWorkerOptions.hostName}${ModelDelimeter.COMPONENT_SEPERATOR}${workerEx.workerThreadWorkerOptions.agentId}-${workerEx.workerThreadWorkerOptions.userAgent}\
+${ModelDelimeter.NID_SEPERATOR}\
+worker${workerEx.id}\
+${ModelDelimeter.SEPERATOR}\
+${this.#runner}`,
+            id: this.#runner.toString(),
+            hostName: (workerEx.workerThreadWorkerOptions.hostName ? workerEx.workerThreadWorkerOptions.hostName : 'host'),
+            agentName: `${workerEx.workerThreadWorkerOptions.agentId}-${workerEx.workerThreadWorkerOptions.userAgent}`,
+            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,
+                errorCount: 0,
+                retryCount: 0,
+                authenticationCount: 0,
+                authenticationErrorCount: 0,
+                authenticationRetryCount: 0,
+                velocity: 0,
+                coreCount: 0,
+                timer: 0,
+                duration: 0,
+                latency: 0,
+                activeRequestCount: 0,
+                message: [ ],
+                childCount: 0,
+                rx: 0,
+                tx: 0
+            } as IRunnerTelemetry,
+            Stop: async (): Promise<boolean> => this.#StopRunner(workerEx, runnerEx),
+            Start: async (): Promise<boolean> => this.#StartRunner(workerEx, runnerEx),
+            Pause: async (): Promise<boolean> => this.#PauseRunner(workerEx, runnerEx),
+            Resume: async (): Promise<boolean> => this.#ResumeRunner(workerEx, runnerEx),
+            ApplyConfig: async (config: IRunnerOptions): Promise<boolean> => {
+                runnerEx.options = config;
+                return true;
+            },
+            GetConfig: (): IRunnerOptions => runnerEx.options
+        }
+        return runnerEx;
+    }
+
+     
+    #PostMessageToWorker = (workerEx: IWorkerEx, command: IIWMessageCommand, payload: IIWMessagePayloadContentBase | null, transferObject?: any) => {
+        if (transferObject) {
+            this.#debug(`#PostMessageToWorker with transfer object`);
+            workerEx.worker.postMessage({ command, payload }, [transferObject]);
+            this.#debug(`#PostMessageToWorker with transfer object - done...`);
+        } else {
+            this.#debug(`#PostMessageToWorker`);
+            workerEx.worker.postMessage({ command, payload });
+        }
+    }
+
+    #TerminateWorker = (workerEx: IWorkerEx) => {
+        if (workerEx.worker) {
+            //const store = TelemetryStore();
+            workerEx.worker.terminate();
+            this.#debug(`Terminated worker: [${workerEx.id}]`);
+            //store.RemoveWorker(workerEx);
+            delete this.#workersEx[workerEx.id];
+        } else {
+            // Some other runner has already removed the parent worker, do nothing
+            // console.log(`WORKER ALREADY NULL`);
+        }
+    }
+
+    #StartRunner = async (workerEx: IWorkerEx, runnerEx: IRunnerEx): Promise<boolean> => {
+        this.#PostMessageToWorker(workerEx, eIWMessageCommands.StartRunner, {
+            runner: this.#CreateRunnerCopy(runnerEx)
+        } as ITestRunnerTelemetryPayload);
+        return true;
+    }
+
+    #StopRunner = 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);
+            if (ids.length > 0) {
+                const id = ids[0];
+                runnerEx = workerEx.runnersEx[id];
+            }
+        }
+        if (runnerEx !== null) {
+            this.#PostMessageToWorker(workerEx, eIWMessageCommands.StopAllAsyncRunners, {
+                runner: this.#CreateRunnerCopy(runnerEx)
+            } as ITestRunnerTelemetryPayload);
+
+            runnerEx.publishInstrumentController.LogEx(`Terminating runner: [${runnerEx.id}]`);
+            
+            const promArray: Promise<boolean>[] = [ ];
+
+            promArray.push((async (): Promise<boolean> => {
+                await Sleep(100);
+                return runnerEx.publishInstrumentController.EndPublish() as Promise<boolean>
+            })());
+
+            //const store = TelemetryStore();
+            //store.RemoveRunner(workerEx, runnerEx);
+
+            delete workerEx.runnersEx[runnerEx.id];
+
+            const retVal = await Promise.all(promArray);
+            console.log(`Removed instrument workers: [${retVal}]`);
+        }
+        return true;
+    }
+
+    #PauseRunner = async (workerEx: IWorkerEx, runnerEx: IRunnerEx | null = null): Promise<boolean> => {
+        return true;
+    }
+
+    #ResumeRunner = async (workerEx: IWorkerEx, runnerEx: IRunnerEx | null = null): Promise<boolean> => {
+        return true;
+    }
+
+    #StopWorker = async (workerEx: IWorkerEx): Promise<boolean> => {
+        try {
+            if (workerEx.state !== IWorkerState.stopped) {
+                this.#PostMessageToWorker(workerEx, eIWMessageCommands.StopAllAsyncRunners, null);
+    
+                //@@ Now wait until we get an ack back from the worker
+                // This is because we may be trying to stop BEFORE the worker has had a chance to startup ...
+    
+                console.log(`Terminating worker: [${workerEx.id}]`);
+                const promArray: Promise<boolean>[] = [ ];
+    
+                // Terminate only those that are currently running...
+                const ids: string[] = Object.keys(workerEx.runnersEx);
+
+                ids.forEach((id) => {
+                    const runnerEx: IRunnerEx = workerEx.runnersEx[id];
+                    promArray.push(this.#StopRunner(workerEx, runnerEx));
+                });
+                await Promise.all(promArray);
+
+                this.#TerminateWorker(workerEx);
+            }
+            return true;
+        } catch (error) {
+            console.log(`Error in STSTestWorker:StopWorker: [${error}]`);
+            return false;
+        }
+    }
+
+    GetNextAvailableWorker = (): IWorkerEx | null => {
+        // Calculate the worker with the least runners
+        let leastRunnerWorker: IWorkerEx | null = null;
+        for (const [, stsWorker] of Object.entries(this.WorkersEx)) {
+            if (leastRunnerWorker) {
+                if (Object.keys(stsWorker.runnersEx).length < Object.keys(leastRunnerWorker.runnersEx).length) {
+                    leastRunnerWorker = stsWorker;
+                }
+            } else {
+                leastRunnerWorker = stsWorker;
+            }
+        }
+        return leastRunnerWorker;
+    }
+
+    GetBusyWorker = (): IWorkerEx | null => {
+        // Calculate the worker with the least runners
+        let busyWorker: IWorkerEx | null = null;
+        for (const [, stsWorker] of Object.entries(this.WorkersEx)) {
+            if (busyWorker) {
+                if (Object.keys(stsWorker.runnersEx).length > Object.keys(busyWorker.runnersEx).length) {
+                    busyWorker = stsWorker;
+                }
+            } else {
+                busyWorker = stsWorker;
+            }
+        }
+        return busyWorker;
+    }
+
+    get Options(): IWorkerManagerOptions {
+        return this.#options;
+    }
+
+    set Options(options: IWorkerManagerOptions) {
+        this.#options = options;
+    }
+
+    StopAllWorkers = async () => {
+        const promArray = [ ];
+        for (const [, stsWorker] of Object.entries(this.WorkersEx)) {
+            promArray.push(stsWorker.Stop());
+        }
+        await Promise.all(promArray);
+    }
+}

package/src/testertesting/workerPrimaryTestRunner01.ts

@@ -0,0 +1,81 @@
+import { MessagePort } from 'worker_threads';
+
+import chalk from 'chalk';
+// Force chalk level
+chalk.level = 3;
+
+import { IPrimaryWorker, IWorkerOptions, PublishMessageCommandsTestRunner, 
+    IIWMessagePayload, IIWMessagePayloadContentBase } from './commonTypes'
+
+//import { STSOAuth2Manager, STSOAuth2ManagerPluginKey } from '@nsshunt/stsoauth2plugin'
+
+// This will execute within the primary thread context and have access to plugins and other Vue application features
+export class WorkerPrimaryTestRunner01 implements IPrimaryWorker {
+//    #STSOAuth2Manager: STSOAuth2Manager
+    #options: IWorkerOptions
+
+    #debug = (message: string) => {
+        console.log(chalk.magenta(`pid: [${process.pid}] WorkerPrimaryTestRunner01::${message}`));
+    }
+
+    // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+    constructor(app: any, options: IWorkerOptions) {
+        this.#debug(`constructor`)
+        this.#options = options;
+        this.#debug(`constructor::options: [${JSON.stringify(this.#options)}]`);
+        //        this.#STSOAuth2Manager = app.config.globalProperties.$sts[STSOAuth2ManagerPluginKey]
+    }
+
+    async ProcessMessageFromWorker(workerPort: MessagePort, publishMessagePayload: IIWMessagePayload) {
+        this.#debug(`ProcessMessageFromWorker`)
+        // Process messages received back from the worker
+        switch (publishMessagePayload.command as PublishMessageCommandsTestRunner) {
+        case PublishMessageCommandsTestRunner.GetAccessToken : {
+            //const access_token = await this.#GetAccessToken();
+            const access_token = '1234';
+            workerPort.postMessage({ 
+                command: PublishMessageCommandsTestRunner.GetAccessTokenResponse,
+                payload: {
+                    messageId: publishMessagePayload.payload.messageId,
+                    access_token
+                } as IIWMessagePayloadContentBase
+            })}
+            break;
+        case PublishMessageCommandsTestRunner.ExecuteRefreshToken : {
+            //const access_token = await this.#ExecuteRefreshToken();
+            const access_token = '5678';
+            workerPort.postMessage({ 
+                command: PublishMessageCommandsTestRunner.ExecuteRefreshTokenResponse,
+                payload: {
+                    messageId: publishMessagePayload.payload.messageId,
+                    access_token
+                } as IIWMessagePayloadContentBase
+            })}
+            break;
+        default :
+            throw new Error(`publishMessagePayload.command: [${publishMessagePayload.command}] not allowed`);
+        }
+    }
+
+    /*
+    #GetAccessToken = async() : Promise<string | null> => {
+        debug(`WorkerPrimaryTestRunner01::GetAccessToken`)
+        return await this.#STSOAuth2Manager.GetAccessToken();
+    }
+
+    #ExecuteRefreshToken = async (): Promise<string | null> => {
+        debug(`WorkerPrimaryTestRunner01::ExecuteRefreshToken`)
+        const retVal  = await this.#STSOAuth2Manager.ExecuteRefreshToken();
+        if (retVal) {
+            const access_token = await this.#STSOAuth2Manager.GetAccessToken();
+            if (access_token) {
+                return access_token;
+            } else {
+                return null;
+            }
+        } else {
+            return null;
+        }
+    }
+        */
+}