@git.zone/tstest 1.5.0 → 1.7.0

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>;
+}

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

@@ -0,0 +1,241 @@
+import * as plugins from './tapbundle.plugins.js';
+import { TapTest } from './tapbundle.classes.taptest.js';
+export class SkipError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'SkipError';
+    }
+}
+export class TapTools {
+    static { this._sharedContext = new Map(); }
+    static { this._pathHelpers = null; }
+    static setPathHelpers(helpers) {
+        TapTools._pathHelpers = helpers;
+    }
+    constructor(TapTestArg) {
+        this._retries = 0;
+        this._retryCount = 0;
+        this.testData = {};
+        this._snapshotPath = '';
+        this.smartjson = plugins.smartjson;
+        /**
+         * shared context for data sharing between tests
+         */
+        this.context = {
+            get: (key) => {
+                return TapTools._sharedContext.get(key);
+            },
+            set: (key, value) => {
+                TapTools._sharedContext.set(key, value);
+            },
+            delete: (key) => {
+                return TapTools._sharedContext.delete(key);
+            },
+            clear: () => {
+                TapTools._sharedContext.clear();
+            }
+        };
+        this._tapTest = TapTestArg;
+        // Generate snapshot path based on test file and test name
+        // Snapshot path will be set by Node.js environment if available
+        if (TapTools._pathHelpers && typeof process !== 'undefined' && process.cwd) {
+            const testFile = TapTestArg.fileName || 'unknown';
+            const testName = TapTestArg.description.replace(/[^a-zA-Z0-9]/g, '_');
+            this._snapshotPath = TapTools._pathHelpers.join(process.cwd(), '.nogit', 'test_snapshots', testFile, `${testName}.snap`);
+        }
+    }
+    /**
+     * allow failure
+     */
+    allowFailure() {
+        this._tapTest.failureAllowed = true;
+    }
+    /**
+     * skip the rest of the test
+     */
+    skip(reason) {
+        const skipMessage = reason ? `Skipped: ${reason}` : 'Skipped';
+        throw new SkipError(skipMessage);
+    }
+    /**
+     * conditionally skip the rest of the test
+     */
+    skipIf(condition, reason) {
+        if (condition) {
+            this.skip(reason);
+        }
+    }
+    /**
+     * mark test as todo
+     */
+    todo(reason) {
+        this._tapTest.isTodo = true;
+        this._tapTest.todoReason = reason;
+    }
+    /**
+     * set the number of retries for this test
+     */
+    retry(count) {
+        this._retries = count;
+    }
+    /**
+     * get the current retry count
+     */
+    get retryCount() {
+        return this._retryCount;
+    }
+    /**
+     * internal: increment retry count
+     */
+    _incrementRetryCount() {
+        this._retryCount++;
+    }
+    /**
+     * get the maximum retries
+     */
+    get maxRetries() {
+        return this._retries;
+    }
+    /**
+     * async/await delay method
+     */
+    async delayFor(timeMilliArg) {
+        await plugins.smartdelay.delayFor(timeMilliArg);
+    }
+    async delayForRandom(timeMilliMinArg, timeMilliMaxArg) {
+        await plugins.smartdelay.delayForRandom(timeMilliMinArg, timeMilliMaxArg);
+    }
+    async coloredString(...args) {
+        return plugins.consolecolor.coloredString(...args);
+    }
+    /**
+     * set a timeout for the test
+     */
+    timeout(timeMilliArg) {
+        this._tapTest.timeoutMs = timeMilliArg;
+    }
+    /**
+     * wait for a timeout (used internally)
+     */
+    async waitForTimeout(timeMilliArg) {
+        const timeout = new plugins.smartdelay.Timeout(timeMilliArg);
+        timeout.makeUnrefed();
+        await timeout.promise;
+        if (this._tapTest.status === 'pending') {
+            this._tapTest.status = 'timeout';
+        }
+    }
+    async returnError(throwingFuncArg) {
+        let funcErr;
+        try {
+            await throwingFuncArg();
+        }
+        catch (err) {
+            funcErr = err;
+        }
+        return funcErr;
+    }
+    defer() {
+        return plugins.smartpromise.defer();
+    }
+    cumulativeDefer() {
+        return plugins.smartpromise.cumulativeDefer();
+    }
+    /**
+     * Snapshot testing - compares output with saved snapshot
+     */
+    async matchSnapshot(value, snapshotName) {
+        if (!this._snapshotPath || !TapTools._pathHelpers) {
+            console.log('Snapshot testing is only available in Node.js environment');
+            return;
+        }
+        const snapshotPath = snapshotName
+            ? this._snapshotPath.replace('.snap', `_${snapshotName}.snap`)
+            : this._snapshotPath;
+        const serializedValue = typeof value === 'string'
+            ? value
+            : JSON.stringify(value, null, 2);
+        try {
+            // Try to read existing snapshot
+            const existingSnapshot = await plugins.smartfile.fs.toStringSync(snapshotPath);
+            if (existingSnapshot !== serializedValue) {
+                // Check if we should update snapshots
+                if (process.env.UPDATE_SNAPSHOTS === 'true') {
+                    await plugins.smartfile.fs.ensureDir(TapTools._pathHelpers.dirname(snapshotPath));
+                    await plugins.smartfile.memory.toFs(serializedValue, snapshotPath);
+                    console.log(`Snapshot updated: ${snapshotPath}`);
+                }
+                else {
+                    throw new Error(`Snapshot mismatch for ${snapshotPath}\n\nExpected:\n${existingSnapshot}\n\nReceived:\n${serializedValue}`);
+                }
+            }
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                // Snapshot doesn't exist yet, create it
+                await plugins.smartfile.fs.ensureDir(TapTools._pathHelpers.dirname(snapshotPath));
+                await plugins.smartfile.memory.toFs(serializedValue, snapshotPath);
+                console.log(`Snapshot created: ${snapshotPath}`);
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    /**
+     * Test fixtures - create test data instances
+     */
+    static { this._fixtureData = new Map(); }
+    static { this._fixtureFactories = new Map(); }
+    /**
+     * Define a fixture factory
+     */
+    static defineFixture(name, factory) {
+        this._fixtureFactories.set(name, factory);
+    }
+    /**
+     * Create a fixture instance
+     */
+    async fixture(name, data) {
+        const factory = TapTools._fixtureFactories.get(name);
+        if (!factory) {
+            throw new Error(`Fixture '${name}' not found. Define it with TapTools.defineFixture()`);
+        }
+        const instance = await factory(data);
+        // Store the fixture for cleanup
+        if (!TapTools._fixtureData.has(name)) {
+            TapTools._fixtureData.set(name, []);
+        }
+        TapTools._fixtureData.get(name).push(instance);
+        return instance;
+    }
+    /**
+     * Factory pattern for creating multiple fixtures
+     */
+    factory(name) {
+        return {
+            create: async (data) => {
+                return this.fixture(name, data);
+            },
+            createMany: async (count, dataOverrides) => {
+                const results = [];
+                for (let i = 0; i < count; i++) {
+                    const data = Array.isArray(dataOverrides)
+                        ? dataOverrides[i]
+                        : typeof dataOverrides === 'function'
+                            ? dataOverrides(i)
+                            : dataOverrides;
+                    results.push(await this.fixture(name, data));
+                }
+                return results;
+            }
+        };
+    }
+    /**
+     * Clear all fixtures (typically called in afterEach)
+     */
+    static async cleanupFixtures() {
+        TapTools._fixtureData.clear();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tapbundle.classes.taptools.js","sourceRoot":"","sources":["../../ts_tapbundle/tapbundle.classes.taptools.ts"],"names":[],"mappings":"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"}

package/dist_ts_tapbundle_node/ts_tapbundle/tapbundle.plugins.d.ts

@@ -0,0 +1,8 @@
+import * as consolecolor from '@push.rocks/consolecolor';
+import * as smartdelay from '@push.rocks/smartdelay';
+import * as smartenv from '@push.rocks/smartenv';
+import * as smartexpect from '@push.rocks/smartexpect';
+import * as smartfile from '@push.rocks/smartfile';
+import * as smartjson from '@push.rocks/smartjson';
+import * as smartpromise from '@push.rocks/smartpromise';
+export { consolecolor, smartdelay, smartenv, smartexpect, smartfile, smartjson, smartpromise };

package/dist_ts_tapbundle_node/ts_tapbundle/tapbundle.plugins.js

@@ -0,0 +1,10 @@
+// pushrocks
+import * as consolecolor from '@push.rocks/consolecolor';
+import * as smartdelay from '@push.rocks/smartdelay';
+import * as smartenv from '@push.rocks/smartenv';
+import * as smartexpect from '@push.rocks/smartexpect';
+import * as smartfile from '@push.rocks/smartfile';
+import * as smartjson from '@push.rocks/smartjson';
+import * as smartpromise from '@push.rocks/smartpromise';
+export { consolecolor, smartdelay, smartenv, smartexpect, smartfile, smartjson, smartpromise };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFwYnVuZGxlLnBsdWdpbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90c190YXBidW5kbGUvdGFwYnVuZGxlLnBsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsWUFBWTtBQUNaLE9BQU8sS0FBSyxZQUFZLE1BQU0sMEJBQTBCLENBQUM7QUFDekQsT0FBTyxLQUFLLFVBQVUsTUFBTSx3QkFBd0IsQ0FBQztBQUNyRCxPQUFPLEtBQUssUUFBUSxNQUFNLHNCQUFzQixDQUFDO0FBQ2pELE9BQU8sS0FBSyxXQUFXLE1BQU0seUJBQXlCLENBQUM7QUFDdkQsT0FBTyxLQUFLLFNBQVMsTUFBTSx1QkFBdUIsQ0FBQztBQUNuRCxPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBQ25ELE9BQU8sS0FBSyxZQUFZLE1BQU0sMEJBQTBCLENBQUM7QUFFekQsT0FBTyxFQUFFLFlBQVksRUFBRSxVQUFVLEVBQUUsUUFBUSxFQUFFLFdBQVcsRUFBRSxTQUFTLEVBQUUsU0FBUyxFQUFFLFlBQVksRUFBRSxDQUFDIn0=

package/dist_ts_tapbundle_node/ts_tapbundle/tapbundle.tapcreator.d.ts

@@ -0,0 +1,3 @@
+export declare class TapCreator {
+}
+export declare let tapCreator: TapCreator;

package/dist_ts_tapbundle_node/ts_tapbundle/tapbundle.tapcreator.js

@@ -0,0 +1,5 @@
+import * as plugins from './tapbundle.plugins.js';
+export class TapCreator {
+}
+export let tapCreator = new TapCreator();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFwYnVuZGxlLnRhcGNyZWF0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90c190YXBidW5kbGUvdGFwYnVuZGxlLnRhcGNyZWF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSx3QkFBd0IsQ0FBQztBQUVsRCxNQUFNLE9BQU8sVUFBVTtDQUV0QjtBQUVELE1BQU0sQ0FBQyxJQUFJLFVBQVUsR0FBRyxJQUFJLFVBQVUsRUFBRSxDQUFDIn0=

package/dist_ts_tapbundle_node/ts_tapbundle_node/classes.pathinject.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Initialize path helpers for the TapTools class
+ * This provides Node.js-specific path operations to the browser-compatible tapbundle
+ */
+export declare const initializePathHelpers: () => void;

package/dist_ts_tapbundle_node/ts_tapbundle_node/classes.pathinject.js

@@ -0,0 +1,13 @@
+import * as plugins from './plugins.js';
+import { TapTools } from '../ts_tapbundle/tapbundle.classes.taptools.js';
+/**
+ * Initialize path helpers for the TapTools class
+ * This provides Node.js-specific path operations to the browser-compatible tapbundle
+ */
+export const initializePathHelpers = () => {
+    TapTools.setPathHelpers({
+        join: (...args) => plugins.path.join(...args),
+        dirname: (path) => plugins.path.dirname(path)
+    });
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5wYXRoaW5qZWN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHNfdGFwYnVuZGxlX25vZGUvY2xhc3Nlcy5wYXRoaW5qZWN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sY0FBYyxDQUFDO0FBQ3hDLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSwrQ0FBK0MsQ0FBQztBQUV6RTs7O0dBR0c7QUFDSCxNQUFNLENBQUMsTUFBTSxxQkFBcUIsR0FBRyxHQUFHLEVBQUU7SUFDeEMsUUFBUSxDQUFDLGNBQWMsQ0FBQztRQUN0QixJQUFJLEVBQUUsQ0FBQyxHQUFHLElBQWMsRUFBRSxFQUFFLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsR0FBRyxJQUFJLENBQUM7UUFDdkQsT0FBTyxFQUFFLENBQUMsSUFBWSxFQUFFLEVBQUUsQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUM7S0FDdEQsQ0FBQyxDQUFDO0FBQ0wsQ0FBQyxDQUFDIn0=

package/dist_ts_tapbundle_node/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/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/ts_tapbundle_node/classes.testfileprovider.d.ts

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