@git.zone/tstest 1.4.0 → 1.7.0

package/dist_ts_tapbundle/webhelpers.js

@@ -0,0 +1,35 @@
+import * as plugins from './tapbundle.plugins.js';
+import { tap } from './tapbundle.classes.tap.js';
+class WebHelpers {
+    constructor() {
+        const smartenv = new plugins.smartenv.Smartenv();
+        // Initialize HTML template tag function
+        this.html = (strings, ...values) => {
+            let result = '';
+            for (let i = 0; i < strings.length; i++) {
+                result += strings[i];
+                if (i < values.length) {
+                    result += values[i];
+                }
+            }
+            return result;
+        };
+        // Initialize fixture function based on environment
+        if (smartenv.isBrowser) {
+            this.fixture = async (htmlString) => {
+                const container = document.createElement('div');
+                container.innerHTML = htmlString.trim();
+                const element = container.firstChild;
+                return element;
+            };
+        }
+        else {
+            // Node.js environment - provide a stub or alternative implementation
+            this.fixture = async (htmlString) => {
+                throw new Error('WebHelpers.fixture is only available in browser environment');
+            };
+        }
+    }
+}
+export const webhelpers = new WebHelpers();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2ViaGVscGVycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX3RhcGJ1bmRsZS93ZWJoZWxwZXJzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sd0JBQXdCLENBQUM7QUFDbEQsT0FBTyxFQUFFLEdBQUcsRUFBRSxNQUFNLDRCQUE0QixDQUFDO0FBRWpELE1BQU0sVUFBVTtJQUlkO1FBQ0UsTUFBTSxRQUFRLEdBQUcsSUFBSSxPQUFPLENBQUMsUUFBUSxDQUFDLFFBQVEsRUFBRSxDQUFDO1FBRWpELHdDQUF3QztRQUN4QyxJQUFJLENBQUMsSUFBSSxHQUFHLENBQUMsT0FBNkIsRUFBRSxHQUFHLE1BQWEsRUFBRSxFQUFFO1lBQzlELElBQUksTUFBTSxHQUFHLEVBQUUsQ0FBQztZQUNoQixLQUFLLElBQUksQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLEdBQUcsT0FBTyxDQUFDLE1BQU0sRUFBRSxDQUFDLEVBQUUsRUFBRSxDQUFDO2dCQUN4QyxNQUFNLElBQUksT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUFDO2dCQUNyQixJQUFJLENBQUMsR0FBRyxNQUFNLENBQUMsTUFBTSxFQUFFLENBQUM7b0JBQ3RCLE1BQU0sSUFBSSxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUM7Z0JBQ3RCLENBQUM7WUFDSCxDQUFDO1lBQ0QsT0FBTyxNQUFNLENBQUM7UUFDaEIsQ0FBQyxDQUFDO1FBRUYsbURBQW1EO1FBQ25ELElBQUksUUFBUSxDQUFDLFNBQVMsRUFBRSxDQUFDO1lBQ3ZCLElBQUksQ0FBQyxPQUFPLEdBQUcsS0FBSyxFQUFFLFVBQWtCLEVBQXdCLEVBQUU7Z0JBQ2hFLE1BQU0sU0FBUyxHQUFHLFFBQVEsQ0FBQyxhQUFhLENBQUMsS0FBSyxDQUFDLENBQUM7Z0JBQ2hELFNBQVMsQ0FBQyxTQUFTLEdBQUcsVUFBVSxDQUFDLElBQUksRUFBRSxDQUFDO2dCQUN4QyxNQUFNLE9BQU8sR0FBRyxTQUFTLENBQUMsVUFBeUIsQ0FBQztnQkFDcEQsT0FBTyxPQUFPLENBQUM7WUFDakIsQ0FBQyxDQUFDO1FBQ0osQ0FBQzthQUFNLENBQUM7WUFDTixxRUFBcUU7WUFDckUsSUFBSSxDQUFDLE9BQU8sR0FBRyxLQUFLLEVBQUUsVUFBa0IsRUFBZ0IsRUFBRTtnQkFDeEQsTUFBTSxJQUFJLEtBQUssQ0FBQyw2REFBNkQsQ0FBQyxDQUFDO1lBQ2pGLENBQUMsQ0FBQztRQUNKLENBQUM7SUFDSCxDQUFDO0NBQ0Y7QUFFRCxNQUFNLENBQUMsTUFBTSxVQUFVLEdBQUcsSUFBSSxVQUFVLEVBQUUsQ0FBQyJ9

package/dist_ts_tapbundle_node/classes.tapnodetools.d.ts

@@ -0,0 +1,25 @@
+import { TestFileProvider } from './classes.testfileprovider.js';
+import * as plugins from './plugins.js';
+declare class TapNodeTools {
+    private smartshellInstance;
+    testFileProvider: TestFileProvider;
+    constructor();
+    private qenv;
+    getQenv(): Promise<plugins.qenv.Qenv>;
+    getEnvVarOnDemand(envVarNameArg: string): Promise<string>;
+    runCommand(commandArg: string): Promise<any>;
+    createHttpsCert(commonName?: string, allowSelfSigned?: boolean): Promise<{
+        key: string;
+        cert: string;
+    }>;
+    /**
+     * create and return a smartmongo instance
+     */
+    createSmartmongo(): Promise<import("@push.rocks/smartmongo").SmartMongo>;
+    /**
+     * create and return a smarts3 instance
+     */
+    createSmarts3(): Promise<import("@push.rocks/smarts3").Smarts3>;
+}
+export declare const tapNodeTools: TapNodeTools;
+export {};

package/dist_ts_tapbundle_node/classes.tapnodetools.js

@@ -0,0 +1,81 @@
+import { TestFileProvider } from './classes.testfileprovider.js';
+import * as plugins from './plugins.js';
+class TapNodeTools {
+    constructor() {
+        this.testFileProvider = new TestFileProvider();
+    }
+    async getQenv() {
+        this.qenv = this.qenv || new plugins.qenv.Qenv('./', '.nogit/');
+        return this.qenv;
+    }
+    async getEnvVarOnDemand(envVarNameArg) {
+        const qenv = await this.getQenv();
+        return qenv.getEnvVarOnDemand(envVarNameArg);
+    }
+    async runCommand(commandArg) {
+        if (!this.smartshellInstance) {
+            this.smartshellInstance = new plugins.smartshell.Smartshell({
+                executor: 'bash',
+            });
+        }
+        const result = await this.smartshellInstance.exec(commandArg);
+        return result;
+    }
+    async createHttpsCert(commonName = 'localhost', allowSelfSigned = true) {
+        if (allowSelfSigned) {
+            // set node to allow self-signed certificates
+            process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+        }
+        // Generate a key pair
+        const keys = plugins.smartcrypto.nodeForge.pki.rsa.generateKeyPair(2048);
+        // Create a self-signed certificate
+        const cert = plugins.smartcrypto.nodeForge.pki.createCertificate();
+        cert.publicKey = keys.publicKey;
+        cert.serialNumber = '01';
+        cert.validity.notBefore = new Date();
+        cert.validity.notAfter = new Date();
+        cert.validity.notAfter.setFullYear(cert.validity.notBefore.getFullYear() + 1);
+        const attrs = [
+            { name: 'commonName', value: commonName },
+            { name: 'countryName', value: 'US' },
+            { shortName: 'ST', value: 'California' },
+            { name: 'localityName', value: 'San Francisco' },
+            { name: 'organizationName', value: 'My Company' },
+            { shortName: 'OU', value: 'Dev' },
+        ];
+        cert.setSubject(attrs);
+        cert.setIssuer(attrs);
+        // Sign the certificate with its own private key (self-signed)
+        cert.sign(keys.privateKey, plugins.smartcrypto.nodeForge.md.sha256.create());
+        // PEM encode the private key and certificate
+        const pemKey = plugins.smartcrypto.nodeForge.pki.privateKeyToPem(keys.privateKey);
+        const pemCert = plugins.smartcrypto.nodeForge.pki.certificateToPem(cert);
+        return {
+            key: pemKey,
+            cert: pemCert,
+        };
+    }
+    /**
+     * create and return a smartmongo instance
+     */
+    async createSmartmongo() {
+        const smartmongoMod = await import('@push.rocks/smartmongo');
+        const smartmongoInstance = new smartmongoMod.SmartMongo();
+        await smartmongoInstance.start();
+        return smartmongoInstance;
+    }
+    /**
+     * create and return a smarts3 instance
+     */
+    async createSmarts3() {
+        const smarts3Mod = await import('@push.rocks/smarts3');
+        const smarts3Instance = new smarts3Mod.Smarts3({
+            port: 3003,
+            cleanSlate: true,
+        });
+        await smarts3Instance.start();
+        return smarts3Instance;
+    }
+}
+export const tapNodeTools = new TapNodeTools();
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_tapbundle_node/classes.testfileprovider.d.ts

@@ -0,0 +1,6 @@
+export declare const fileUrls: {
+    dockerAlpineImage: string;
+};
+export declare class TestFileProvider {
+    getDockerAlpineImageAsLocalTarball(): Promise<string>;
+}

package/dist_ts_tapbundle_node/classes.testfileprovider.js

@@ -0,0 +1,16 @@
+import * as plugins from './plugins.js';
+import * as paths from './paths.js';
+export const fileUrls = {
+    dockerAlpineImage: 'https://code.foss.global/testassets/docker/raw/branch/main/alpine.tar',
+};
+export class TestFileProvider {
+    async getDockerAlpineImageAsLocalTarball() {
+        const filePath = plugins.path.join(paths.testFilesDir, 'alpine.tar');
+        // fetch the docker alpine image
+        const response = await plugins.smartrequest.getBinary(fileUrls.dockerAlpineImage);
+        await plugins.smartfile.fs.ensureDir(paths.testFilesDir);
+        await plugins.smartfile.memory.toFs(response.body, filePath);
+        return filePath;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy50ZXN0ZmlsZXByb3ZpZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHNfdGFwYnVuZGxlX25vZGUvY2xhc3Nlcy50ZXN0ZmlsZXByb3ZpZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sY0FBYyxDQUFDO0FBQ3hDLE9BQU8sS0FBSyxLQUFLLE1BQU0sWUFBWSxDQUFDO0FBRXBDLE1BQU0sQ0FBQyxNQUFNLFFBQVEsR0FBRztJQUN0QixpQkFBaUIsRUFBRSx1RUFBdUU7Q0FDM0YsQ0FBQTtBQUVELE1BQU0sT0FBTyxnQkFBZ0I7SUFDcEIsS0FBSyxDQUFDLGtDQUFrQztRQUM3QyxNQUFNLFFBQVEsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsWUFBWSxFQUFFLFlBQVksQ0FBQyxDQUFBO1FBQ3BFLGdDQUFnQztRQUNoQyxNQUFNLFFBQVEsR0FBRyxNQUFNLE9BQU8sQ0FBQyxZQUFZLENBQUMsU0FBUyxDQUFDLFFBQVEsQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDO1FBQ2xGLE1BQU0sT0FBTyxDQUFDLFNBQVMsQ0FBQyxFQUFFLENBQUMsU0FBUyxDQUFDLEtBQUssQ0FBQyxZQUFZLENBQUMsQ0FBQztRQUN6RCxNQUFNLE9BQU8sQ0FBQyxTQUFTLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsSUFBSSxFQUFFLFFBQVEsQ0FBQyxDQUFDO1FBQzdELE9BQU8sUUFBUSxDQUFDO0lBQ2xCLENBQUM7Q0FDRiJ9

package/dist_ts_tapbundle_node/index.d.ts

@@ -0,0 +1 @@
+export * from './classes.tapnodetools.js';

package/dist_ts_tapbundle_node/index.js

@@ -0,0 +1,2 @@
+export * from './classes.tapnodetools.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c190YXBidW5kbGVfbm9kZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDJCQUEyQixDQUFDIn0=

package/dist_ts_tapbundle_node/paths.d.ts

@@ -0,0 +1,2 @@
+export declare const cwd: string;
+export declare const testFilesDir: string;

package/dist_ts_tapbundle_node/paths.js

@@ -0,0 +1,4 @@
+import * as plugins from './plugins.js';
+export const cwd = process.cwd();
+export const testFilesDir = plugins.path.join(cwd, './.nogit/testfiles/');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGF0aHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c190YXBidW5kbGVfbm9kZS9wYXRocy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLGNBQWMsQ0FBQztBQUV4QyxNQUFNLENBQUMsTUFBTSxHQUFHLEdBQUcsT0FBTyxDQUFDLEdBQUcsRUFBRSxDQUFDO0FBQ2pDLE1BQU0sQ0FBQyxNQUFNLFlBQVksR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxHQUFHLEVBQUUscUJBQXFCLENBQUMsQ0FBQyJ9

package/dist_ts_tapbundle_node/plugins.d.ts

@@ -0,0 +1,11 @@
+import * as crypto from 'crypto';
+import * as fs from 'fs';
+import * as path from 'path';
+export { crypto, fs, path, };
+import * as qenv from '@push.rocks/qenv';
+import * as smartcrypto from '@push.rocks/smartcrypto';
+import * as smartfile from '@push.rocks/smartfile';
+import * as smartpath from '@push.rocks/smartpath';
+import * as smartrequest from '@push.rocks/smartrequest';
+import * as smartshell from '@push.rocks/smartshell';
+export { qenv, smartcrypto, smartfile, smartpath, smartrequest, smartshell, };

package/dist_ts_tapbundle_node/plugins.js

@@ -0,0 +1,14 @@
+// node native
+import * as crypto from 'crypto';
+import * as fs from 'fs';
+import * as path from 'path';
+export { crypto, fs, path, };
+// @push.rocks scope
+import * as qenv from '@push.rocks/qenv';
+import * as smartcrypto from '@push.rocks/smartcrypto';
+import * as smartfile from '@push.rocks/smartfile';
+import * as smartpath from '@push.rocks/smartpath';
+import * as smartrequest from '@push.rocks/smartrequest';
+import * as smartshell from '@push.rocks/smartshell';
+export { qenv, smartcrypto, smartfile, smartpath, smartrequest, smartshell, };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX3RhcGJ1bmRsZV9ub2RlL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYztBQUNkLE9BQU8sS0FBSyxNQUFNLE1BQU0sUUFBUSxDQUFDO0FBQ2pDLE9BQU8sS0FBSyxFQUFFLE1BQU0sSUFBSSxDQUFDO0FBQ3pCLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBRTdCLE9BQU8sRUFBRSxNQUFNLEVBQUMsRUFBRSxFQUFFLElBQUksR0FBRyxDQUFDO0FBRTVCLG9CQUFvQjtBQUNwQixPQUFPLEtBQUssSUFBSSxNQUFNLGtCQUFrQixDQUFDO0FBQ3pDLE9BQU8sS0FBSyxXQUFXLE1BQU0seUJBQXlCLENBQUM7QUFDdkQsT0FBTyxLQUFLLFNBQVMsTUFBTSx1QkFBdUIsQ0FBQztBQUNuRCxPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBQ25ELE9BQU8sS0FBSyxZQUFZLE1BQU0sMEJBQTBCLENBQUM7QUFDekQsT0FBTyxLQUFLLFVBQVUsTUFBTSx3QkFBd0IsQ0FBQztBQUVyRCxPQUFPLEVBQUUsSUFBSSxFQUFFLFdBQVcsRUFBRSxTQUFTLEVBQUUsU0FBUyxFQUFFLFlBQVksRUFBRSxVQUFVLEdBQUcsQ0FBQyJ9

package/dist_ts_tapbundle_node/ts_tapbundle/tapbundle.classes.taptest.d.ts

@@ -0,0 +1,38 @@
+import { TapTools } from './tapbundle.classes.taptools.js';
+import { HrtMeasurement } from '@push.rocks/smarttime';
+export type TTestStatus = 'success' | 'error' | 'pending' | 'errorAfterSuccess' | 'timeout' | 'skipped';
+export interface ITestFunction<T> {
+    (tapTools?: TapTools): Promise<T>;
+}
+export declare class TapTest<T = unknown> {
+    description: string;
+    failureAllowed: boolean;
+    hrtMeasurement: HrtMeasurement;
+    parallel: boolean;
+    status: TTestStatus;
+    tapTools: TapTools;
+    testFunction: ITestFunction<T>;
+    testKey: number;
+    timeoutMs?: number;
+    isTodo: boolean;
+    todoReason?: string;
+    tags: string[];
+    priority: 'high' | 'medium' | 'low';
+    fileName?: string;
+    private testDeferred;
+    testPromise: Promise<TapTest<T>>;
+    private testResultDeferred;
+    testResultPromise: Promise<T>;
+    /**
+     * constructor
+     */
+    constructor(optionsArg: {
+        description: string;
+        testFunction: ITestFunction<T>;
+        parallel: boolean;
+    });
+    /**
+     * run the test
+     */
+    run(testKeyArg: number): Promise<void>;
+}

package/dist_ts_tapbundle_node/ts_tapbundle/tapbundle.classes.taptest.js

@@ -0,0 +1,110 @@
+import * as plugins from './tapbundle.plugins.js';
+import { tapCreator } from './tapbundle.tapcreator.js';
+import { TapTools, SkipError } from './tapbundle.classes.taptools.js';
+// imported interfaces
+import { Deferred } from '@push.rocks/smartpromise';
+import { HrtMeasurement } from '@push.rocks/smarttime';
+export class TapTest {
+    /**
+     * constructor
+     */
+    constructor(optionsArg) {
+        this.isTodo = false;
+        this.tags = [];
+        this.priority = 'medium';
+        this.testDeferred = plugins.smartpromise.defer();
+        this.testPromise = this.testDeferred.promise;
+        this.testResultDeferred = plugins.smartpromise.defer();
+        this.testResultPromise = this.testResultDeferred.promise;
+        this.description = optionsArg.description;
+        this.hrtMeasurement = new HrtMeasurement();
+        this.parallel = optionsArg.parallel;
+        this.status = 'pending';
+        this.tapTools = new TapTools(this);
+        this.testFunction = optionsArg.testFunction;
+    }
+    /**
+     * run the test
+     */
+    async run(testKeyArg) {
+        this.testKey = testKeyArg;
+        const testNumber = testKeyArg + 1;
+        // Handle todo tests
+        if (this.isTodo) {
+            const todoText = this.todoReason ? `# TODO ${this.todoReason}` : '# TODO';
+            console.log(`ok ${testNumber} - ${this.description} ${todoText}`);
+            this.status = 'success';
+            this.testDeferred.resolve(this);
+            return;
+        }
+        // Run test with retries
+        let lastError;
+        const maxRetries = this.tapTools.maxRetries;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            this.hrtMeasurement.start();
+            try {
+                // Set up timeout if specified
+                let timeoutHandle;
+                let timeoutPromise = null;
+                if (this.timeoutMs) {
+                    timeoutPromise = new Promise((_, reject) => {
+                        timeoutHandle = setTimeout(() => {
+                            this.status = 'timeout';
+                            reject(new Error(`Test timed out after ${this.timeoutMs}ms`));
+                        }, this.timeoutMs);
+                    });
+                }
+                // Run the test function with potential timeout
+                const testPromise = this.testFunction(this.tapTools);
+                const testReturnValue = timeoutPromise
+                    ? await Promise.race([testPromise, timeoutPromise])
+                    : await testPromise;
+                // Clear timeout if test completed
+                if (timeoutHandle) {
+                    clearTimeout(timeoutHandle);
+                }
+                this.hrtMeasurement.stop();
+                console.log(`ok ${testNumber} - ${this.description} # time=${this.hrtMeasurement.milliSeconds}ms`);
+                this.status = 'success';
+                this.testDeferred.resolve(this);
+                this.testResultDeferred.resolve(testReturnValue);
+                return; // Success, exit retry loop
+            }
+            catch (err) {
+                this.hrtMeasurement.stop();
+                // Handle skip
+                if (err instanceof SkipError || err.name === 'SkipError') {
+                    console.log(`ok ${testNumber} - ${this.description} # SKIP ${err.message.replace('Skipped: ', '')}`);
+                    this.status = 'skipped';
+                    this.testDeferred.resolve(this);
+                    return;
+                }
+                lastError = err;
+                // If we have retries left, try again
+                if (attempt < maxRetries) {
+                    console.log(`# Retry ${attempt + 1}/${maxRetries} for test: ${this.description}`);
+                    this.tapTools._incrementRetryCount();
+                    continue;
+                }
+                // Final failure
+                console.log(`not ok ${testNumber} - ${this.description} # time=${this.hrtMeasurement.milliSeconds}ms`);
+                this.testDeferred.resolve(this);
+                this.testResultDeferred.resolve(err);
+                // if the test has already succeeded before
+                if (this.status === 'success') {
+                    this.status = 'errorAfterSuccess';
+                    console.log('!!! ALERT !!!: weird behaviour, since test has been already successfull');
+                }
+                else {
+                    this.status = 'error';
+                }
+                // if the test is allowed to fail
+                if (this.failureAllowed) {
+                    console.log(`please note: failure allowed!`);
+                }
+                console.log(err);
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_tapbundle_node/ts_tapbundle/tapbundle.classes.taptools.d.ts

@@ -0,0 +1,109 @@
+import * as plugins from './tapbundle.plugins.js';
+import { TapTest } from './tapbundle.classes.taptest.js';
+export interface IPromiseFunc {
+    (): Promise<any>;
+}
+export declare class SkipError extends Error {
+    constructor(message: string);
+}
+export declare class TapTools {
+    /**
+     * the referenced TapTest
+     */
+    private _tapTest;
+    private _retries;
+    private _retryCount;
+    testData: any;
+    private static _sharedContext;
+    private _snapshotPath;
+    private static _pathHelpers;
+    static setPathHelpers(helpers: typeof TapTools._pathHelpers): void;
+    constructor(TapTestArg: TapTest<any>);
+    /**
+     * allow failure
+     */
+    allowFailure(): void;
+    /**
+     * skip the rest of the test
+     */
+    skip(reason?: string): never;
+    /**
+     * conditionally skip the rest of the test
+     */
+    skipIf(condition: boolean, reason?: string): void;
+    /**
+     * mark test as todo
+     */
+    todo(reason?: string): void;
+    /**
+     * set the number of retries for this test
+     */
+    retry(count: number): void;
+    /**
+     * get the current retry count
+     */
+    get retryCount(): number;
+    /**
+     * internal: increment retry count
+     */
+    _incrementRetryCount(): void;
+    /**
+     * get the maximum retries
+     */
+    get maxRetries(): number;
+    /**
+     * async/await delay method
+     */
+    delayFor(timeMilliArg: number): Promise<void>;
+    delayForRandom(timeMilliMinArg: number, timeMilliMaxArg: number): Promise<void>;
+    coloredString(...args: Parameters<typeof plugins.consolecolor.coloredString>): Promise<string>;
+    /**
+     * set a timeout for the test
+     */
+    timeout(timeMilliArg: number): void;
+    /**
+     * wait for a timeout (used internally)
+     */
+    waitForTimeout(timeMilliArg: number): Promise<void>;
+    returnError(throwingFuncArg: IPromiseFunc): Promise<Error>;
+    defer(): plugins.smartpromise.Deferred<unknown>;
+    cumulativeDefer(): plugins.smartpromise.CumulativeDeferred;
+    smartjson: typeof plugins.smartjson;
+    /**
+     * shared context for data sharing between tests
+     */
+    context: {
+        get: (key: string) => any;
+        set: (key: string, value: any) => void;
+        delete: (key: string) => boolean;
+        clear: () => void;
+    };
+    /**
+     * Snapshot testing - compares output with saved snapshot
+     */
+    matchSnapshot(value: any, snapshotName?: string): Promise<void>;
+    /**
+     * Test fixtures - create test data instances
+     */
+    private static _fixtureData;
+    private static _fixtureFactories;
+    /**
+     * Define a fixture factory
+     */
+    static defineFixture<T>(name: string, factory: (data?: Partial<T>) => T | Promise<T>): void;
+    /**
+     * Create a fixture instance
+     */
+    fixture<T>(name: string, data?: Partial<T>): Promise<T>;
+    /**
+     * Factory pattern for creating multiple fixtures
+     */
+    factory<T>(name: string): {
+        create: (data?: Partial<T>) => Promise<T>;
+        createMany: (count: number, dataOverrides?: Partial<T>[] | ((index: number) => Partial<T>)) => Promise<T[]>;
+    };
+    /**
+     * Clear all fixtures (typically called in afterEach)
+     */
+    static cleanupFixtures(): Promise<void>;
+}