feat(cli): Improve test runner configuration: update test scripts, reorganize test directories, update dependencies and add local settings for command permissions.

ts_tapbundle/00_commitinfo_data.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@push.rocks/tapbundle',
+  version: '6.0.3',
+  description: 'A comprehensive testing automation library that provides a wide range of utilities and tools for TAP (Test Anything Protocol) based testing, especially suitable for projects using tapbuffer.'
+}

ts_tapbundle/index.ts

@@ -0,0 +1,7 @@
+export { tap } from './tapbundle.classes.tap.js';
+export { TapWrap } from './tapbundle.classes.tapwrap.js';
+export { webhelpers } from './webhelpers.js';
+
+import { expect } from '@push.rocks/smartexpect';
+
+export { expect };

ts_tapbundle/tapbundle.classes.pretask.ts

@@ -0,0 +1,21 @@
+import * as plugins from './tapbundle.plugins.js';
+import { TapTools } from './tapbundle.classes.taptools.js';
+
+export interface IPreTaskFunction {
+  (tapTools?: TapTools): Promise<any>;
+}
+
+export class PreTask {
+  public description: string;
+  public preTaskFunction: IPreTaskFunction;
+
+  constructor(descriptionArg: string, preTaskFunctionArg: IPreTaskFunction) {
+    this.description = descriptionArg;
+    this.preTaskFunction = preTaskFunctionArg;
+  }
+
+  public async run() {
+    console.log(`::__PRETASK: ${this.description}`);
+    await this.preTaskFunction(new TapTools(null));
+  }
+}

ts_tapbundle/tapbundle.classes.tap.ts

@@ -0,0 +1,173 @@
+import * as plugins from './tapbundle.plugins.js';
+
+import { type IPreTaskFunction, PreTask } from './tapbundle.classes.pretask.js';
+import { TapTest, type ITestFunction } from './tapbundle.classes.taptest.js';
+export class Tap<T> {
+  /**
+   * skips a test
+   * tests marked with tap.skip.test() are never executed
+   */
+  public skip = {
+    test: (descriptionArg: string, functionArg: ITestFunction<T>) => {
+      console.log(`skipped test: ${descriptionArg}`);
+    },
+    testParallel: (descriptionArg: string, functionArg: ITestFunction<T>) => {
+      console.log(`skipped test: ${descriptionArg}`);
+    },
+  };
+
+  /**
+   * only executes tests marked as ONLY
+   */
+  public only = {
+    test: (descriptionArg: string, testFunctionArg: ITestFunction<T>) => {
+      this.test(descriptionArg, testFunctionArg, 'only');
+    },
+  };
+
+  private _tapPreTasks: PreTask[] = [];
+  private _tapTests: TapTest<any>[] = [];
+  private _tapTestsOnly: TapTest<any>[] = [];
+
+  /**
+   * Normal test function, will run one by one
+   * @param testDescription - A description of what the test does
+   * @param testFunction - A Function that returns a Promise and resolves or rejects
+   */
+  public test(
+    testDescription: string,
+    testFunction: ITestFunction<T>,
+    modeArg: 'normal' | 'only' | 'skip' = 'normal',
+  ): TapTest<T> {
+    const localTest = new TapTest<T>({
+      description: testDescription,
+      testFunction,
+      parallel: false,
+    });
+    if (modeArg === 'normal') {
+      this._tapTests.push(localTest);
+    } else if (modeArg === 'only') {
+      this._tapTestsOnly.push(localTest);
+    }
+    return localTest;
+  }
+
+  public preTask(descriptionArg: string, functionArg: IPreTaskFunction) {
+    this._tapPreTasks.push(new PreTask(descriptionArg, functionArg));
+  }
+
+  /**
+   * A parallel test that will not be waited for before the next starts.
+   * @param testDescription - A description of what the test does
+   * @param testFunction - A Function that returns a Promise and resolves or rejects
+   */
+  public testParallel(testDescription: string, testFunction: ITestFunction<T>) {
+    this._tapTests.push(
+      new TapTest({
+        description: testDescription,
+        testFunction,
+        parallel: true,
+      }),
+    );
+  }
+
+  /**
+   * starts the test evaluation
+   */
+  public async start(optionsArg?: { throwOnError: boolean }) {
+    // lets set the tapbundle promise
+    const smartenvInstance = new plugins.smartenv.Smartenv();
+    smartenvInstance.isBrowser
+      ? ((globalThis as any).tapbundleDeferred = plugins.smartpromise.defer())
+      : null;
+
+    // lets continue with running the tests
+    const promiseArray: Array<Promise<any>> = [];
+
+    // safeguard against empty test array
+    if (this._tapTests.length === 0) {
+      console.log('no tests specified. Ending here!');
+      // TODO: throw proper error
+      return;
+    }
+
+    // determine which tests to run
+    let concerningTests: TapTest[];
+    if (this._tapTestsOnly.length > 0) {
+      concerningTests = this._tapTestsOnly;
+    } else {
+      concerningTests = this._tapTests;
+    }
+
+    // lets run the pretasks
+    for (const preTask of this._tapPreTasks) {
+      await preTask.run();
+    }
+
+    console.log(`1..${concerningTests.length}`);
+    for (let testKey = 0; testKey < concerningTests.length; testKey++) {
+      const currentTest = concerningTests[testKey];
+      const testPromise = currentTest.run(testKey);
+      if (currentTest.parallel) {
+        promiseArray.push(testPromise);
+      } else {
+        await testPromise;
+      }
+    }
+    await Promise.all(promiseArray);
+
+    // when tests have been run and all promises are fullfilled
+    const failReasons: string[] = [];
+    const executionNotes: string[] = [];
+    // collect failed tests
+    for (const tapTest of concerningTests) {
+      if (tapTest.status !== 'success') {
+        failReasons.push(
+          `Test ${tapTest.testKey + 1} failed with status ${tapTest.status}:\n` +
+            `|| ${tapTest.description}\n` +
+            `|| for more information please take a look the logs above`,
+        );
+      }
+    }
+
+    // render fail Reasons
+    for (const failReason of failReasons) {
+      console.log(failReason);
+    }
+
+    if (optionsArg && optionsArg.throwOnError && failReasons.length > 0) {
+      if (!smartenvInstance.isBrowser) process.exit(1);
+    }
+    if (smartenvInstance.isBrowser) {
+      (globalThis as any).tapbundleDeferred.resolve();
+    }
+  }
+
+  public async stopForcefully(codeArg = 0, directArg = false) {
+    console.log(`tap stopping forcefully! Code: ${codeArg} / Direct: ${directArg}`);
+    if (directArg) {
+      process.exit(codeArg);
+    } else {
+      setTimeout(() => {
+        process.exit(codeArg);
+      }, 10);
+    }
+  }
+
+  /**
+   * handle errors
+   */
+  public threw(err: Error) {
+    console.log(err);
+  }
+
+  /**
+   * Explicitly fail the current test with a custom message
+   * @param message - The failure message to display
+   */
+  public fail(message: string = 'Test failed'): never {
+    throw new Error(message);
+  }
+}
+
+export let tap = new Tap();

ts_tapbundle/tapbundle.classes.taptest.ts

@@ -0,0 +1,87 @@
+import * as plugins from './tapbundle.plugins.js';
+import { tapCreator } from './tapbundle.tapcreator.js';
+import { TapTools } from './tapbundle.classes.taptools.js';
+
+// imported interfaces
+import { Deferred } from '@push.rocks/smartpromise';
+import { HrtMeasurement } from '@push.rocks/smarttime';
+
+// interfaces
+export type TTestStatus = 'success' | 'error' | 'pending' | 'errorAfterSuccess' | 'timeout';
+
+export interface ITestFunction<T> {
+  (tapTools?: TapTools): Promise<T>;
+}
+
+export class TapTest<T = unknown> {
+  public description: string;
+  public failureAllowed: boolean;
+  public hrtMeasurement: HrtMeasurement;
+  public parallel: boolean;
+  public status: TTestStatus;
+  public tapTools: TapTools;
+  public testFunction: ITestFunction<T>;
+  public testKey: number; // the testKey the position in the test qeue. Set upon calling .run()
+  private testDeferred: Deferred<TapTest<T>> = plugins.smartpromise.defer();
+  public testPromise: Promise<TapTest<T>> = this.testDeferred.promise;
+  private testResultDeferred: Deferred<T> = plugins.smartpromise.defer();
+  public testResultPromise: Promise<T> = this.testResultDeferred.promise;
+  /**
+   * constructor
+   */
+  constructor(optionsArg: {
+    description: string;
+    testFunction: ITestFunction<T>;
+    parallel: boolean;
+  }) {
+    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
+   */
+  public async run(testKeyArg: number) {
+    this.hrtMeasurement.start();
+    this.testKey = testKeyArg;
+    const testNumber = testKeyArg + 1;
+    try {
+      const testReturnValue = await this.testFunction(this.tapTools);
+      if (this.status === 'timeout') {
+        throw new Error('Test succeeded, but timed out...');
+      }
+      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);
+    } catch (err: any) {
+      this.hrtMeasurement.stop();
+      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);
+    }
+  }
+}

ts_tapbundle/tapbundle.classes.taptools.ts

@@ -0,0 +1,68 @@
+import * as plugins from './tapbundle.plugins.js';
+import { TapTest } from './tapbundle.classes.taptest.js';
+
+export interface IPromiseFunc {
+  (): Promise<any>;
+}
+
+export class TapTools {
+  /**
+   * the referenced TapTest
+   */
+  private _tapTest: TapTest;
+
+  constructor(TapTestArg: TapTest<any>) {
+    this._tapTest = TapTestArg;
+  }
+
+  /**
+   * allow failure
+   */
+  public allowFailure() {
+    this._tapTest.failureAllowed = true;
+  }
+
+  /**
+   * async/await delay method
+   */
+  public async delayFor(timeMilliArg: number) {
+    await plugins.smartdelay.delayFor(timeMilliArg);
+  }
+
+  public async delayForRandom(timeMilliMinArg: number, timeMilliMaxArg: number) {
+    await plugins.smartdelay.delayForRandom(timeMilliMinArg, timeMilliMaxArg);
+  }
+
+  public async coloredString(...args: Parameters<typeof plugins.consolecolor.coloredString>) {
+    return plugins.consolecolor.coloredString(...args);
+  }
+
+  public async timeout(timeMilliArg: number) {
+    const timeout = new plugins.smartdelay.Timeout(timeMilliArg);
+    timeout.makeUnrefed();
+    await timeout.promise;
+    if (this._tapTest.status === 'pending') {
+      this._tapTest.status = 'timeout';
+    }
+  }
+
+  public async returnError(throwingFuncArg: IPromiseFunc) {
+    let funcErr: Error;
+    try {
+      await throwingFuncArg();
+    } catch (err: any) {
+      funcErr = err;
+    }
+    return funcErr;
+  }
+
+  public defer() {
+    return plugins.smartpromise.defer();
+  }
+
+  public cumulativeDefer() {
+    return plugins.smartpromise.cumulativeDefer();
+  }
+
+  public smartjson = plugins.smartjson;
+}

ts_tapbundle/tapbundle.classes.tapwrap.ts

@@ -0,0 +1,13 @@
+import * as plugins from './tapbundle.plugins.js';
+
+export interface ITapWrapOptions {
+  before: () => Promise<any>;
+  after: () => {};
+}
+
+export class TapWrap {
+  public options: ITapWrapOptions;
+  constructor(optionsArg: ITapWrapOptions) {
+    this.options = optionsArg;
+  }
+}

ts_tapbundle/tapbundle.plugins.ts

@@ -0,0 +1,9 @@
+// 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 smartjson from '@push.rocks/smartjson';
+import * as smartpromise from '@push.rocks/smartpromise';
+
+export { consolecolor, smartdelay, smartenv, smartexpect, smartjson, smartpromise };

ts_tapbundle/tapbundle.tapcreator.ts

@@ -0,0 +1,7 @@
+import * as plugins from './tapbundle.plugins.js';
+
+export class TapCreator {
+  // TODO:
+}
+
+export let tapCreator = new TapCreator();

ts_tapbundle/tspublish.json

@@ -0,0 +1,3 @@
+{
+  "order": 1
+}

ts_tapbundle/webhelpers.ts

@@ -0,0 +1,40 @@
+import * as plugins from './tapbundle.plugins.js';
+import { tap } from './tapbundle.classes.tap.js';
+
+class WebHelpers {
+  html: any;
+  fixture: any;
+
+  constructor() {
+    const smartenv = new plugins.smartenv.Smartenv();
+    
+    // Initialize HTML template tag function
+    this.html = (strings: TemplateStringsArray, ...values: any[]) => {
+      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: string): Promise<HTMLElement> => {
+        const container = document.createElement('div');
+        container.innerHTML = htmlString.trim();
+        const element = container.firstChild as HTMLElement;
+        return element;
+      };
+    } else {
+      // Node.js environment - provide a stub or alternative implementation
+      this.fixture = async (htmlString: string): Promise<any> => {
+        throw new Error('WebHelpers.fixture is only available in browser environment');
+      };
+    }
+  }
+}
+
+export const webhelpers = new WebHelpers();