@nsshunt/ststestrunner 1.1.105 → 1.1.107

package/dist/ststestrunner.mjs

@@ -2,11 +2,12 @@ import { AbstractRunnerExecutionWorker } from "@nsshunt/stsrunnerframework";
 import { STSAxiosConfig, Sleep, createAgentManager, isNode } from "@nsshunt/stsutils";
 import chalk from "chalk";
 import axios from "axios";
-import { FhirRESTClient, FhirSocketClientAllInOne, FhirSocketClientIndividual, createRetryAxiosClient } from "@nsshunt/stsfhirclient";
 import http from "node:http";
 import https from "node:https";
+import { FhirRESTClient, FhirSocketClientAllInOne, FhirSocketClientIndividual, createRetryAxiosClient } from "@nsshunt/stsfhirclient";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
 var __exportAll = (all, no_symbols) => {
 	let target = {};
 	for (var name in all) __defProp(target, name, {
@@ -469,14 +470,14 @@ var TestCaseFhirBase = class {
 				if (axiosError.response.status === StatusCodes.UNAUTHORIZED) {
 					this.runner.instrumentData.authenticationErrorCount++;
 					this.Error(chalk.red(`TestCaseFhirBase:HandleError(): [${this._id}] UNAUTHORIZED - Reset Access Token`));
-					this.runnerExecutionWorker.ResetAccessToken();
+					this.runnerExecutionWorker.authHelper.ResetAccessToken();
 					return true;
 				}
 			} else this.Error(chalk.red(`TestCaseFhirBase:HandleError(): [${this._id}] AXIOS Error = [${axiosError}]`));
 		} else if (error.message === "UNAUTHORIZED") {
 			this.runner.instrumentData.authenticationErrorCount++;
 			this.Error(chalk.red(`TestCaseFhirBase:HandleError(): [${this._id}] UNAUTHORIZED - Reset Access Token`));
-			this.runnerExecutionWorker.ResetAccessToken();
+			this.runnerExecutionWorker.authHelper.ResetAccessToken();
 			return true;
 		}
 		return false;
@@ -703,9 +704,9 @@ var TestCaseFhirQueryBase = class extends TestCaseFhirBase {
 var TestCaseFhir01 = class extends TestCaseFhirQueryBase {
 	PerformExecuteQuery = async () => {
 		const __snapshot1 = performance.now();
-		await this.runnerExecutionWorker.GetAccessToken();
+		await this.runnerExecutionWorker.authHelper.GetAccessToken();
 		this._CheckOutputLongDurationError(__snapshot1, "await this.GetAccessToken()");
-		this.runnerExecutionWorker.ResetAccessToken();
+		this.runnerExecutionWorker.authHelper.ResetAccessToken();
 		return null;
 	};
 };
@@ -36033,78 +36034,99 @@ var ResourceDataGenerator = class {
 	};
 };
 //#endregion
-//#region src/libmodule/workerFhirTestCases.ts
-var WorkerFhirTestCases = class extends AbstractRunnerExecutionWorker {
+//#region src/libmodule/lockHelper.ts
+var import_tiny_emitter = (/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function E() {}
+	E.prototype = {
+		on: function(name, callback, ctx) {
+			var e = this.e || (this.e = {});
+			(e[name] || (e[name] = [])).push({
+				fn: callback,
+				ctx
+			});
+			return this;
+		},
+		once: function(name, callback, ctx) {
+			var self = this;
+			function listener() {
+				self.off(name, listener);
+				callback.apply(ctx, arguments);
+			}
+			listener._ = callback;
+			return this.on(name, listener, ctx);
+		},
+		emit: function(name) {
+			var data = [].slice.call(arguments, 1);
+			var evtArr = ((this.e || (this.e = {}))[name] || []).slice();
+			var i = 0;
+			var len = evtArr.length;
+			for (; i < len; i++) evtArr[i].fn.apply(evtArr[i].ctx, data);
+			return this;
+		},
+		off: function(name, callback) {
+			var e = this.e || (this.e = {});
+			var evts = e[name];
+			var liveEvents = [];
+			if (evts && callback) {
+				for (var i = 0, len = evts.length; i < len; i++) if (evts[i].fn !== callback && evts[i].fn._ !== callback) liveEvents.push(evts[i]);
+			}
+			liveEvents.length ? e[name] = liveEvents : delete e[name];
+			return this;
+		}
+	};
+	module.exports = E;
+	module.exports.TinyEmitter = E;
+})))();
+var LockHelper = class {
+	_onHoldKeys = {};
+	GetOnHold = (holdKey) => {
+		if (this._onHoldKeys[holdKey]) return true;
+		return false;
+	};
+	WaitOnHold = async (holdKey, timeout) => {
+		const start = performance.now();
+		for (;;) {
+			if (this._onHoldKeys[holdKey]) await Sleep(100);
+			else break;
+			if (performance.now() - start > timeout) throw new Error(`WorkerFhirTestCases:WaitOnHold(): Timeout: [${timeout}] reached.`);
+		}
+		return true;
+	};
+	SetOnHold = (holdKey) => {
+		this._onHoldKeys[holdKey] = true;
+	};
+	ReleaseOnHold = (holdKey) => {
+		delete this._onHoldKeys[holdKey];
+	};
+};
+//#endregion
+//#region src/libmodule/authHelper.ts
+var AuthHelper = class extends import_tiny_emitter.TinyEmitter {
 	_options;
-	_resourceDataGenerator;
-	fhirClient = void 0;
 	_id = crypto.randomUUID();
-	_onHoldKeys = {};
+	_lockHelper = new LockHelper();
 	#accesssToken = null;
 	_authMaxTimeout = 5e3;
 	#originRegex = /^(api:\/\/\w+)/;
 	#authAgentManager;
-	restFhirClient = null;
 	logPrefix = `WorkerFhirTestCases:[${this._id}]:`;
 	constructor(options) {
 		super();
 		this._options = options;
-		this._resourceDataGenerator = new ResourceDataGenerator();
 		this.#authAgentManager = this.GetAuthAgentManager();
 	}
 	Warning = (message) => {
-		this.logger.warn(`${this.logPrefix}${message}`);
+		this._options.logger.warn(`${this.logPrefix}${message}`);
 	};
 	Error = (message) => {
-		this.logger.error(`${this.logPrefix}${message}`);
+		this._options.logger.error(`${this.logPrefix}${message}`);
 	};
 	Debug = (message) => {
-		this.logger.debug(`${this.logPrefix}${message}`);
+		this._options.logger.debug(`${this.logPrefix}${message}`);
 	};
 	get id() {
 		return this._id;
 	}
-	get resourceDataGenerator() {
-		return this._resourceDataGenerator;
-	}
-	get logger() {
-		return this._options.logger;
-	}
-	CreateAsyncRunner = async (testRunnerTelemetryPayload) => {
-		return AsyncRunnerFactory.CreateAsyncRunner(this, testRunnerTelemetryPayload);
-	};
-	async ProcessPreTerminateWorkerMessage(messagePayload) {
-		this.logger.debug(chalk.rgb(220, 100, 0)(`ProcessPreTerminateWorkerMessage(): [${JSON.stringify(messagePayload, null, 2)}]`));
-		if (this.fhirClient) {
-			this.logger.debug(chalk.rgb(220, 100, 0)(`ProcessPreTerminateWorkerMessage(): ResetSocket()`));
-			this.fhirClient.ResetSocket();
-			this.fhirClient = void 0;
-		}
-		await Sleep(250);
-		return {
-			originalMessage: { ...messagePayload },
-			myresponsepreterminate: `I got: [${JSON.stringify(messagePayload.payload.data)}]`
-		};
-	}
-	GetOnHold = (holdKey) => {
-		if (this._onHoldKeys[holdKey]) return true;
-		return false;
-	};
-	WaitOnHold = async (holdKey, timeout) => {
-		const start = performance.now();
-		for (;;) {
-			if (this._onHoldKeys[holdKey]) await Sleep(100);
-			else break;
-			if (performance.now() - start > timeout) throw new Error(`WorkerFhirTestCases:WaitOnHold(): Timeout: [${timeout}] reached.`);
-		}
-		return true;
-	};
-	SetOnHold = (holdKey) => {
-		this._onHoldKeys[holdKey] = true;
-	};
-	ReleaseOnHold = (holdKey) => {
-		delete this._onHoldKeys[holdKey];
-	};
 	defaultAgentOptions = {
 		keepAlive: true,
 		maxSockets: 10,
@@ -36160,9 +36182,6 @@ var WorkerFhirTestCases = class extends AbstractRunnerExecutionWorker {
 		});
 		return agentManager;
 	};
-	GetFhirAgentManager = () => {
-		return this.GetAgentManager(this._options.fhirOptions.stsfhiragentOptions);
-	};
 	GetAuthAgentManager = () => {
 		return this.GetAgentManager(this._options.authOptions.asagentoptions);
 	};
@@ -36218,14 +36237,14 @@ var WorkerFhirTestCases = class extends AbstractRunnerExecutionWorker {
 				retryJitterMs: 150,
 				maxRetryDurationMs: 5e3,
 				onRetryAttempt: (attempt, error, delayMs) => {
-					this._options.runner.instrumentData.authenticationErrorCount++;
-					this._options.runner.instrumentData.authenticationRetryCount++;
+					this.emit("authenticationErrorCount", 1);
+					this.emit("authenticationRetryCount", 1);
 					const message = `GetAPITokenFromAuthServerUsingScope(): [${this._id}] Retry #${attempt} after ${delayMs}ms due to ${error.code || error.response?.status}`;
 					this.Warning(message);
-					this._options.runner.instrumentData.message.push(chalk.red(message));
+					this.emit("logMessage", chalk.red(message));
 				}
 			})(url, axiosConfig.config);
-			this._options.runner.instrumentData.authenticationCount++;
+			this.emit("authenticationCount", 1);
 			stage = "7";
 			if (retVal.status) {
 				if (retVal.status !== 200) this.Warning(chalk.magenta(`GetAPITokenFromAuthServerUsingScope(): [${this._id}] Invalid response from server: [${retVal.status}]`));
@@ -36263,11 +36282,11 @@ var WorkerFhirTestCases = class extends AbstractRunnerExecutionWorker {
 			if (this.#accesssToken) return this.#accesssToken;
 			const lockKey = "GetAccessToken";
 			const lockTimeout = 6e4;
-			if (this.GetOnHold(lockKey) === true) {
+			if (this._lockHelper.GetOnHold(lockKey) === true) {
 				this.Debug(chalk.magenta(`GetAccessToken(): accesssToken does not exist - some other client setting up the new accesssToken (on hold/lock), lock key: [${lockKey}] - waiting ...`));
 				try {
 					const miniStart = performance.now();
-					await this.WaitOnHold(lockKey, lockTimeout);
+					await this._lockHelper.WaitOnHold(lockKey, lockTimeout);
 					this.Debug(chalk.yellow(`GetAccessToken(): hold (lock) released after: [${performance.now() - miniStart}ms], lock key: [${lockKey}]`));
 					if (this.#accesssToken) {
 						this.Debug(chalk.green(`GetAccessToken(): Getting existing accesssToken (post hold release), lock key: [${lockKey}]`));
@@ -36282,7 +36301,7 @@ var WorkerFhirTestCases = class extends AbstractRunnerExecutionWorker {
 			}
 			this.Debug(chalk.yellow(`GetAccessToken(): accesssToken does not exist - setting up new accesssToken`));
 			this.Debug(chalk.yellow(`GetAccessToken(): setting hold (lock), lock key: [${lockKey}]`));
-			this.SetOnHold(lockKey);
+			this._lockHelper.SetOnHold(lockKey);
 			timeout = setTimeout(() => {
 				this.Warning(chalk.magenta(`GetAccessToken(): Timeout: [${this._authMaxTimeout}] exceeded for getting access token ...`));
 			}, this._authMaxTimeout);
@@ -36298,8 +36317,8 @@ var WorkerFhirTestCases = class extends AbstractRunnerExecutionWorker {
 			const totalTime = performance.now() - start;
 			if (totalTime > this._authMaxTimeout) this.Warning(chalk.magenta(`GetAccessToken(): The total time for getting the access token: [${totalTime}]`));
 			this.#accesssToken = workingAaccesssToken;
-			this.ReleaseOnHold(lockKey);
-			this.Debug(chalk.yellow(`GetAccessToken(): release hold (lock) Time taken for get access token: [${performance.now() - start}ms]`));
+			this._lockHelper.ReleaseOnHold(lockKey);
+			this.Debug(chalk.yellow(`GetAccessToken(): release hold (lock) Time taken for get access token: [${performance.now() - start}ms], lock key: [${lockKey}]`));
 			return this.#accesssToken;
 		} catch (error) {
 			if (timeout) clearTimeout(timeout);
@@ -36336,16 +36355,100 @@ var WorkerFhirTestCases = class extends AbstractRunnerExecutionWorker {
 	ResetAccessToken = () => {
 		this.#accesssToken = null;
 	};
+};
+//#endregion
+//#region src/libmodule/clientHelper.ts
+var ClientHelper = class extends import_tiny_emitter.TinyEmitter {
+	_options;
+	fhirClient = void 0;
+	_id = crypto.randomUUID();
+	_lockHelper = new LockHelper();
+	restFhirClient = null;
+	logPrefix = `WorkerFhirTestCases:[${this._id}]:`;
+	constructor(options) {
+		super();
+		this._options = options;
+	}
+	Warning = (message) => {
+		this._options.logger.warn(`${this.logPrefix}${message}`);
+	};
+	Error = (message) => {
+		this._options.logger.error(`${this.logPrefix}${message}`);
+	};
+	Debug = (message) => {
+		this._options.logger.debug(`${this.logPrefix}${message}`);
+	};
+	get id() {
+		return this._id;
+	}
+	defaultAgentOptions = {
+		keepAlive: true,
+		maxSockets: 10,
+		maxTotalSockets: 20,
+		maxFreeSockets: 10,
+		timeout: 6e4,
+		rejectUnauthorized: false
+	};
+	stressTestAgentOptions = {
+		keepAlive: true,
+		maxSockets: 200,
+		maxTotalSockets: 500,
+		maxFreeSockets: 50,
+		timeout: 3e4,
+		rejectUnauthorized: false
+	};
+	stressTestExtremeAgentOptions = {
+		keepAlive: true,
+		maxSockets: 500,
+		maxTotalSockets: 1e3,
+		maxFreeSockets: 500,
+		timeout: 3e4,
+		rejectUnauthorized: false
+	};
+	GetAgentManager = (testingAgentOptions) => {
+		let agentManager = void 0;
+		let agentOptions = void 0;
+		switch (testingAgentOptions.nodeAgentMode) {
+			case "no-agent": break;
+			case "custom-agent-options":
+				if (testingAgentOptions.nodeAgentCustomOptions) agentOptions = { ...testingAgentOptions.nodeAgentCustomOptions };
+				else agentOptions = { ...this.defaultAgentOptions };
+				break;
+			case "default-agent-options":
+				agentOptions = { ...this.defaultAgentOptions };
+				break;
+			case "stress-test-agent-options":
+				agentOptions = { ...this.stressTestAgentOptions };
+				break;
+			case "stress-test-extreme-agent-options":
+				agentOptions = { ...this.stressTestExtremeAgentOptions };
+				break;
+			default: throw new Error(`TestCaseFhirBase:GetAgentManager(): [${this._id}] unknown nodeAgentMode: [${testingAgentOptions.nodeAgentMode}]`);
+		}
+		if (agentOptions) agentManager = createAgentManager({
+			agentOptions,
+			httpAgentFactory(options) {
+				return new http.Agent(options);
+			},
+			httpsAgentFactory(options) {
+				return new https.Agent(options);
+			}
+		});
+		return agentManager;
+	};
+	GetFhirAgentManager = () => {
+		return this.GetAgentManager(this._options.fhirOptions.stsfhiragentOptions);
+	};
 	GetFhirSocketClient = async () => {
 		try {
 			if (this.fhirClient) return this.fhirClient;
 			const lockKey = "GetFhirSocketClient";
 			const lockTimeout = 6e4;
-			if (this.GetOnHold(lockKey) === true) {
+			if (this._lockHelper.GetOnHold(lockKey) === true) {
 				this.Debug(chalk.magenta(`GetFhirSocketClient(): fhir client does not exist - some other client setting up the new client (on hold/lock), lock key: [${lockKey}] - waiting ...`));
 				try {
 					const start = performance.now();
-					await this.WaitOnHold(lockKey, lockTimeout);
+					await this._lockHelper.WaitOnHold(lockKey, lockTimeout);
 					this.Debug(chalk.yellow(`GetFhirSocketClient(): hold (lock) released after: [${performance.now() - start}ms], lock key: [${lockKey}]`));
 					if (this.fhirClient) {
 						this.Debug(chalk.green(`GetFhirSocketClient(): Getting existing fhir client (post hold release), lock key: [${lockKey}]`));
@@ -36361,7 +36464,7 @@ var WorkerFhirTestCases = class extends AbstractRunnerExecutionWorker {
 			const start = performance.now();
 			this.Debug(chalk.yellow(`GetFhirSocketClient(): fhir client does not exist - setting up new client`));
 			this.Debug(chalk.yellow(`GetFhirSocketClient(): setting hold (lock), lock key: [${lockKey}]`));
-			this.SetOnHold(lockKey);
+			this._lockHelper.SetOnHold(lockKey);
 			const fhirOptions = this._options.fhirOptions;
 			const options = {
 				fhirServerEndpoint: fhirOptions.stsfhirserverendpoint,
@@ -36373,18 +36476,18 @@ var WorkerFhirTestCases = class extends AbstractRunnerExecutionWorker {
 				baseUrl: fhirOptions.stsfhirbaseurl,
 				agentManager: this.GetFhirAgentManager(),
 				joinRooms: [],
-				logger: this.logger,
+				logger: this._options.logger,
 				verboseLogging: true,
-				GetConnectionAccessToken: this.GetAccessTokenForSocketClientAccess,
-				GetAccessToken: this.GetAccessToken
+				GetConnectionAccessToken: this._options.authHelper.GetAccessTokenForSocketClientAccess,
+				GetAccessToken: this._options.authHelper.GetAccessToken
 			};
 			let workingFhirClient;
-			if (this._options.runner.options.fhirOptions.stsfhirsocketclientmode === "socket-client-all-in-one") workingFhirClient = new FhirSocketClientAllInOne("FhirSocketClient", options);
+			if (this._options.fhirOptions.stsfhirsocketclientmode === "socket-client-all-in-one") workingFhirClient = new FhirSocketClientAllInOne("FhirSocketClient", options);
 			else workingFhirClient = new FhirSocketClientIndividual("FhirSocketClient", options);
 			await workingFhirClient.WaitForSocketConnected();
 			this.Debug(chalk.yellow(`GetFhirSocketClient(): setting fhir client into object`));
 			this.fhirClient = workingFhirClient;
-			this.ReleaseOnHold(lockKey);
+			this._lockHelper.ReleaseOnHold(lockKey);
 			this.Debug(chalk.yellow(`GetFhirSocketClient(): release hold (lock) Time taken for socket connection and set object: [${performance.now() - start}ms], lock key: [${lockKey}]`));
 			return this.fhirClient;
 		} catch (error) {
@@ -36395,20 +36498,18 @@ var WorkerFhirTestCases = class extends AbstractRunnerExecutionWorker {
 	GetRESTClient = async () => {
 		if (this.restFhirClient) return this.restFhirClient;
 		const onRetryAttempt = (attempt, error, delayMs) => {
-			this._options.runner.instrumentData.errorCount++;
-			this._options.runner.instrumentData.requestCount++;
 			const message = `TestCaseFhirBase:onRetryAttempt(): [${this._id}] Retry #${attempt} after ${delayMs}ms due to ${error.code || error.response?.status}`;
 			this.Warning(message);
-			this._options.runner.instrumentData.message.push(chalk.red(message));
+			this.emit("retry", message);
 		};
 		const fhirOptions = this._options.fhirOptions;
 		const fhirRESTClient = new FhirRESTClient({
-			GetAccessToken: this.GetAccessToken,
+			GetAccessToken: this._options.authHelper.GetAccessToken,
 			user: "USR_user01@stsmda.com.au",
 			endpoint: fhirOptions.stsfhirserverendpoint,
 			stsfhirapiroot: fhirOptions.stsfhirapiroot,
 			stsfhirport: fhirOptions.stsfhirport,
-			logger: this.logger,
+			logger: this._options.logger,
 			agentManager: this.GetFhirAgentManager(),
 			onRetryAttempt
 		});
@@ -36417,12 +36518,136 @@ var WorkerFhirTestCases = class extends AbstractRunnerExecutionWorker {
 	};
 	GetClient = async () => {
 		let client;
-		if (this._options.runner.options.fhirOptions.stsfhirsocketclientmode === "no-socket-client") client = await this.GetRESTClient();
+		if (this._options.fhirOptions.stsfhirsocketclientmode === "no-socket-client") client = await this.GetRESTClient();
 		else client = await this.GetFhirSocketClient();
 		return client;
 	};
 };
 //#endregion
+//#region src/libmodule/workerFhirTestCases.ts
+var WorkerFhirTestCases = class extends AbstractRunnerExecutionWorker {
+	_options;
+	_resourceDataGenerator;
+	fhirClient = void 0;
+	_id = crypto.randomUUID();
+	_clientHelper;
+	_authHelper;
+	restFhirClient = null;
+	logPrefix = `WorkerFhirTestCases:[${this._id}]:`;
+	constructor(options) {
+		super();
+		this._options = options;
+		this._resourceDataGenerator = new ResourceDataGenerator();
+		this._authHelper = new AuthHelper({
+			authOptions: options.authOptions,
+			logger: options.logger
+		});
+		this._clientHelper = new ClientHelper({
+			authHelper: this._authHelper,
+			logger: options.logger,
+			fhirOptions: options.fhirOptions
+		});
+	}
+	get authHelper() {
+		return this._authHelper;
+	}
+	Warning = (message) => {
+		this.logger.warn(`${this.logPrefix}${message}`);
+	};
+	Error = (message) => {
+		this.logger.error(`${this.logPrefix}${message}`);
+	};
+	Debug = (message) => {
+		this.logger.debug(`${this.logPrefix}${message}`);
+	};
+	get id() {
+		return this._id;
+	}
+	get resourceDataGenerator() {
+		return this._resourceDataGenerator;
+	}
+	get logger() {
+		return this._options.logger;
+	}
+	CreateAsyncRunner = async (testRunnerTelemetryPayload) => {
+		return AsyncRunnerFactory.CreateAsyncRunner(this, testRunnerTelemetryPayload);
+	};
+	async ProcessPreTerminateWorkerMessage(messagePayload) {
+		this.logger.debug(chalk.rgb(220, 100, 0)(`ProcessPreTerminateWorkerMessage(): [${JSON.stringify(messagePayload, null, 2)}]`));
+		if (this.fhirClient) {
+			this.logger.debug(chalk.rgb(220, 100, 0)(`ProcessPreTerminateWorkerMessage(): ResetSocket()`));
+			this.fhirClient.ResetSocket();
+			this.fhirClient = void 0;
+		}
+		await Sleep(250);
+		return {
+			originalMessage: { ...messagePayload },
+			myresponsepreterminate: `I got: [${JSON.stringify(messagePayload.payload.data)}]`
+		};
+	}
+	defaultAgentOptions = {
+		keepAlive: true,
+		maxSockets: 10,
+		maxTotalSockets: 20,
+		maxFreeSockets: 10,
+		timeout: 6e4,
+		rejectUnauthorized: false
+	};
+	stressTestAgentOptions = {
+		keepAlive: true,
+		maxSockets: 200,
+		maxTotalSockets: 500,
+		maxFreeSockets: 50,
+		timeout: 3e4,
+		rejectUnauthorized: false
+	};
+	stressTestExtremeAgentOptions = {
+		keepAlive: true,
+		maxSockets: 500,
+		maxTotalSockets: 1e3,
+		maxFreeSockets: 500,
+		timeout: 3e4,
+		rejectUnauthorized: false
+	};
+	GetAgentManager = (testingAgentOptions) => {
+		let agentManager = void 0;
+		let agentOptions = void 0;
+		switch (testingAgentOptions.nodeAgentMode) {
+			case "no-agent": break;
+			case "custom-agent-options":
+				if (testingAgentOptions.nodeAgentCustomOptions) agentOptions = { ...testingAgentOptions.nodeAgentCustomOptions };
+				else agentOptions = { ...this.defaultAgentOptions };
+				break;
+			case "default-agent-options":
+				agentOptions = { ...this.defaultAgentOptions };
+				break;
+			case "stress-test-agent-options":
+				agentOptions = { ...this.stressTestAgentOptions };
+				break;
+			case "stress-test-extreme-agent-options":
+				agentOptions = { ...this.stressTestExtremeAgentOptions };
+				break;
+			default: throw new Error(`TestCaseFhirBase:GetAgentManager(): [${this._id}] unknown nodeAgentMode: [${testingAgentOptions.nodeAgentMode}]`);
+		}
+		if (agentOptions) agentManager = createAgentManager({
+			agentOptions,
+			httpAgentFactory(options) {
+				return new http.Agent(options);
+			},
+			httpsAgentFactory(options) {
+				return new https.Agent(options);
+			}
+		});
+		return agentManager;
+	};
+	GetFhirAgentManager = () => {
+		return this.GetAgentManager(this._options.fhirOptions.stsfhiragentOptions);
+	};
+	GetClient = async () => {
+		return this._clientHelper.GetClient();
+	};
+};
+//#endregion
 export { WorkerFhirTestCases };
 
 //# sourceMappingURL=ststestrunner.mjs.map