3.2.7

.gitignore

@@ -15,8 +15,6 @@ node_modules/
 
 # builds
 dist/
-dist_web/
+dist_*/
-dist_serve/
-dist_ts_web/
 
 # custom

.gitlab-ci.yml

@@ -24,13 +24,14 @@ mirror:
     - docker
     - notpriv
 
-snyk:
+audit:
+  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
   stage: security
   script:
     - npmci npm prepare
-    - npmci command npm install -g snyk
     - npmci command npm install --ignore-scripts
-    - npmci command snyk test
+    - npmci command npm config set registry https://registry.npmjs.org
+    - npmci command npm audit --audit-level=high
   tags:
     - lossless
     - docker

.vscode/launch.json

@@ -0,0 +1,29 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "current file",
+      "type": "node",
+      "request": "launch",
+      "args": [
+        "${relativeFile}"
+      ],
+      "runtimeArgs": ["-r", "@gitzone/tsrun"],
+      "cwd": "${workspaceRoot}",
+      "protocol": "inspector",
+      "internalConsoleOptions": "openOnSessionStart"
+    },
+    {
+      "name": "test.ts",
+      "type": "node",
+      "request": "launch",
+      "args": [
+        "test/test.ts"
+      ],
+      "runtimeArgs": ["-r", "@gitzone/tsrun"],
+      "cwd": "${workspaceRoot}",
+      "protocol": "inspector",
+      "internalConsoleOptions": "openOnSessionStart"
+    }
+  ]
+}

.vscode/settings.json

@@ -0,0 +1,26 @@
+{
+  "json.schemas": [
+    {
+      "fileMatch": ["/npmextra.json"],
+      "schema": {
+        "type": "object",
+        "properties": {
+          "npmci": {
+            "type": "object",
+            "description": "settings for npmci"
+          },
+          "gitzone": {
+            "type": "object",
+            "description": "settings for gitzone",
+            "properties": {
+              "projectType": {
+                "type": "string",
+                "enum": ["website", "element", "service", "npm"]
+              }
+            }
+          }
+        }
+      }
+    }
+  ]
+}

npmextra.json

@@ -9,6 +9,7 @@
     }
   },
   "gitzone": {
+    "projectType": "npm",
     "module": {
       "githost": "gitlab.com",
       "gitscope": "pushrocks",

package.json

@@ -1,13 +1,13 @@
 {
   "name": "@pushrocks/tapbundle",
   "private": false,
-  "version": "3.0.14",
+  "version": "3.2.7",
   "description": "tap bundled for tapbuffer",
-  "main": "dist/index.js",
+  "main": "dist_ts/index.js",
-  "typings": "dist/index.d.ts",
+  "typings": "dist_ts/index.d.ts",
   "scripts": {
     "test": "(tstest test/)",
-    "build": "(tsbuild)"
+    "build": "(tsbuild --web)"
   },
   "repository": {
     "type": "git",
@@ -20,25 +20,27 @@
   },
   "homepage": "https://gitlab.com/pushrocks/tapbundle#README",
   "dependencies": {
-    "@pushrocks/early": "^3.0.3",
+    "@pushrocks/smartdelay": "^2.0.9",
-    "@pushrocks/smartdelay": "^2.0.3",
+    "@pushrocks/smartenv": "^4.0.10",
     "@pushrocks/smartpromise": "^3.0.2",
+    "@pushrocks/smarttime": "^3.0.19",
     "smartchai": "^2.0.1"
   },
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.11",
+    "@gitzone/tsbuild": "^2.1.24",
-    "@gitzone/tsrun": "^1.2.8",
+    "@gitzone/tsrun": "^1.2.12",
-    "@gitzone/tstest": "^1.0.24",
+    "@gitzone/tstest": "^1.0.36",
-    "@types/node": "^12.7.2",
+    "@types/node": "^14.0.19",
     "randomstring": "^1.1.5",
-    "tslint": "^5.19.0",
+    "tslint": "^6.1.2",
     "tslint-config-prettier": "^1.18.0"
   },
   "files": [
     "ts/**/*",
     "ts_web/**/*",
     "dist/**/*",
-    "dist_web/**/*",
+    "dist_*/**/*",
+    "dist_ts/**/*",
     "dist_ts_web/**/*",
     "assets/**/*",
     "cli.js",

test/test.browser.ts

@@ -0,0 +1,40 @@
+import { tap, expect } from '../ts/index';
+
+tap.preTask('hi there', async () => {
+  console.log('this is a pretask');
+});
+
+const test1 = tap.test('my first test -> expect true to be true', async () => {
+  return expect(true).to.be.true;
+});
+
+const test2 = tap.test('my second test', async (tools) => {
+  await tools.delayFor(50);
+});
+
+const test3 = tap.test(
+  'my third test -> test2 should take longer than test1 and endure at least 1000ms',
+  async () => {
+    expect((await test1).hrtMeasurement.milliSeconds < (await test2).hrtMeasurement.milliSeconds).to
+      .be.true;
+    expect((await test2).hrtMeasurement.milliSeconds > 10).to.be.true;
+  }
+);
+
+const test4 = tap.skip.test('my 4th test -> should fail', async (tools) => {
+  tools.allowFailure();
+  expect(false).to.be.true;
+});
+
+const test5 = tap.test('my 5th test -> should pass in about 500ms', async (tools) => {
+  tools.timeout(1000);
+  await tools.delayFor(500);
+});
+
+const test6 = tap.skip.test('my 6th test -> should fail after 1000ms', async (tools) => {
+  tools.allowFailure();
+  tools.timeout(1000);
+  await tools.delayFor(100);
+});
+
+tap.start();

test/test.iterationleak.ts

@@ -1,7 +1,7 @@
 import { tap, expect } from '../ts/index';
 import * as randomstring from 'randomstring';
 
-const test1 = tap.test('my first test -> expect true to be true', async tools => {
+const test1 = tap.test('my first test -> expect true to be true', async (tools) => {
   await tools.checkIterationLeak(async () => {
     const domain = randomstring.generate(1000);
   });
@@ -9,7 +9,7 @@ const test1 = tap.test('my first test -> expect true to be true', async tools =>
 
 const outsideArray = [];
 
-const test2 = tap.test('should throw', async tools => {
+const test2 = tap.test('should throw', async (tools) => {
   const err = await tools.returnError(async () => {
     await tools.checkIterationLeak(async () => {
       outsideArray.push(randomstring.generate(1000));

test/test.ts

@@ -1,10 +1,14 @@
 import { tap, expect } from '../ts/index';
 
+tap.preTask('hi there', async () => {
+  console.log('this is a pretask');
+});
+
 const test1 = tap.test('my first test -> expect true to be true', async () => {
   return expect(true).to.be.true;
 });
 
-const test2 = tap.test('my second test', async tools => {
+const test2 = tap.test('my second test', async (tools) => {
   await tools.delayFor(1000);
 });
 
@@ -17,17 +21,17 @@ const test3 = tap.test(
   }
 );
 
-const test4 = tap.skip.test('my 4th test -> should fail', async tools => {
+const test4 = tap.skip.test('my 4th test -> should fail', async (tools) => {
   tools.allowFailure();
   expect(false).to.be.true;
 });
 
-const test5 = tap.test('my 5th test -> should pass in about 500ms', async tools => {
+const test5 = tap.test('my 5th test -> should pass in about 500ms', async (tools) => {
   tools.timeout(1000);
   await tools.delayFor(500);
 });
 
-const test6 = tap.skip.test('my 6th test -> should fail after 1000ms', async tools => {
+const test6 = tap.skip.test('my 6th test -> should fail after 1000ms', async (tools) => {
   tools.allowFailure();
   tools.timeout(1000);
   await tools.delayFor(2000);

ts/tapbundle.classes.pretask.ts

@@ -0,0 +1,21 @@
+import * as plugins from './tapbundle.plugins';
+import { TapTools } from './tapbundle.classes.taptools';
+
+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.classes.tap.ts

@@ -1,5 +1,6 @@
 import * as plugins from './tapbundle.plugins';
 
+import { IPreTaskFunction, PreTask } from './tapbundle.classes.pretask';
 import { TapTest, ITestFunction } from './tapbundle.classes.taptest';
 import { TapWrap, ITapWrapFunction } from './tapbundle.classes.tapwrap';
 export class Tap {
@@ -7,24 +8,25 @@ export class Tap {
    * skips a test
    * tests marked with tap.skip.test() are never executed
    */
-  skip = {
+  public skip = {
     test: (descriptionArg: string, functionArg: ITestFunction) => {
       console.log(`skipped test: ${descriptionArg}`);
     },
     testParallel: (descriptionArg: string, functionArg: ITestFunction) => {
       console.log(`skipped test: ${descriptionArg}`);
-    }
+    },
   };
 
   /**
    * only executes tests marked as ONLY
    */
-  only = {
+  public only = {
     test: (descriptionArg: string, testFunctionArg: ITestFunction) => {
       this.test(descriptionArg, testFunctionArg, 'only');
-    }
+    },
   };
 
+  private _tapPreTasks: PreTask[] = [];
   private _tapTests: TapTest[] = [];
   private _tapTestsOnly: TapTest[] = [];
 
@@ -33,15 +35,15 @@ export class Tap {
    * @param testDescription - A description of what the test does
    * @param testFunction - A Function that returns a Promise and resolves or rejects
    */
-  async test(
+  public async test(
     testDescription: string,
     testFunction: ITestFunction,
     modeArg: 'normal' | 'only' | 'skip' = 'normal'
   ) {
-    let localTest = new TapTest({
+    const localTest = new TapTest({
       description: testDescription,
-      testFunction: testFunction,
+      testFunction,
-      parallel: false
+      parallel: false,
     });
     if (modeArg === 'normal') {
       this._tapTests.push(localTest);
@@ -51,10 +53,14 @@ export class Tap {
     return localTest;
   }
 
+  public preTask(descriptionArg: string, functionArg: IPreTaskFunction) {
+    this._tapPreTasks.push(new PreTask(descriptionArg, functionArg));
+  }
+
   /**
    * wraps function
    */
-  wrap(functionArg: ITapWrapFunction) {
+  public wrap(functionArg: ITapWrapFunction) {
     return new TapWrap(functionArg);
   }
 
@@ -63,12 +69,12 @@ export class Tap {
    * @param testDescription - A description of what the test does
    * @param testFunction - A Function that returns a Promise and resolves or rejects
    */
-  testParallel(testDescription: string, testFunction: ITestFunction) {
+  public testParallel(testDescription: string, testFunction: ITestFunction) {
     this._tapTests.push(
       new TapTest({
         description: testDescription,
-        testFunction: testFunction,
+        testFunction,
-        parallel: true
+        parallel: true,
       })
     );
   }
@@ -76,12 +82,20 @@ export class Tap {
   /**
    * starts the test evaluation
    */
-  async start(optionsArg?: { throwOnError: boolean }) {
+  public async start(optionsArg?: { throwOnError: boolean }) {
-    let promiseArray: Promise<any>[] = [];
+    // lets set the tapbundle promise
+    const smartenvInstance = new plugins.smartenv.Smartenv();
+    smartenvInstance.isBrowser
+      ? (globalThis.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;
     }
 
@@ -93,10 +107,15 @@ export class Tap {
       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++) {
-      let currentTest = concerningTests[testKey];
+      const currentTest = concerningTests[testKey];
-      let testPromise = currentTest.run(testKey);
+      const testPromise = currentTest.run(testKey);
       if (currentTest.parallel) {
         promiseArray.push(testPromise);
       } else {
@@ -106,10 +125,10 @@ export class Tap {
     await Promise.all(promiseArray);
 
     // when tests have been run and all promises are fullfilled
-    let failReasons: string[] = [];
+    const failReasons: string[] = [];
-    let executionNotes: string[] = [];
+    const executionNotes: string[] = [];
     // collect failed tests
-    for (let tapTest of concerningTests) {
+    for (const tapTest of concerningTests) {
       if (tapTest.status !== 'success') {
         failReasons.push(
           `Test ${tapTest.testKey + 1} failed with status ${tapTest.status}:\n` +
@@ -120,19 +139,22 @@ export class Tap {
     }
 
     // render fail Reasons
-    for (let failReason of failReasons) {
+    for (const failReason of failReasons) {
       console.log(failReason);
     }
 
     if (optionsArg && optionsArg.throwOnError && failReasons.length > 0) {
-      process.exit(1);
+      if (!smartenvInstance.isBrowser) process.exit(1);
+    }
+    if (smartenvInstance.isBrowser) {
+      globalThis.tapbundleDeferred.resolve();
     }
   }
 
   /**
    * handle errors
    */
-  threw(err) {
+  public threw(err) {
     console.log(err);
   }
 }

ts/tapbundle.classes.taptest.ts

@@ -3,27 +3,25 @@ import { tapCreator } from './tapbundle.tapcreator';
 import { TapTools } from './tapbundle.classes.taptools';
 
 // imported interfaces
-import { HrtMeasurement } from '@pushrocks/early';
 import { Deferred } from '@pushrocks/smartpromise';
+import { HrtMeasurement } from '@pushrocks/smarttime';
 
 // interfaces
 export type TTestStatus = 'success' | 'error' | 'pending' | 'errorAfterSuccess' | 'timeout';
 
-export interface ITestFunction {
+export type ITestFunction = (tapTools?: TapTools) => Promise<any>;
-  (tapTools?: TapTools): Promise<any>;
-}
 
 export class TapTest {
-  description: string;
+  public description: string;
-  failureAllowed: boolean;
+  public failureAllowed: boolean;
-  hrtMeasurement: HrtMeasurement;
+  public hrtMeasurement: HrtMeasurement;
-  parallel: boolean;
+  public parallel: boolean;
-  status: TTestStatus;
+  public status: TTestStatus;
-  tapTools: TapTools;
+  public tapTools: TapTools;
-  testFunction: ITestFunction;
+  public testFunction: ITestFunction;
-  testKey: number; // the testKey the position in the test qeue. Set upon calling .run()
+  public testKey: number; // the testKey the position in the test qeue. Set upon calling .run()
-  testDeferred: Deferred<TapTest> = plugins.smartpromise.defer();
+  public testDeferred: Deferred<TapTest> = plugins.smartpromise.defer();
-  testPromise: Promise<TapTest> = this.testDeferred.promise;
+  public testPromise: Promise<TapTest> = this.testDeferred.promise;
   /**
    * constructor
    */
@@ -39,10 +37,10 @@ export class TapTest {
   /**
    * run the test
    */
-  async run(testKeyArg: number) {
+  public async run(testKeyArg: number) {
     this.hrtMeasurement.start();
     this.testKey = testKeyArg;
-    let testNumber = testKeyArg + 1;
+    const testNumber = testKeyArg + 1;
     try {
       await this.testFunction(this.tapTools);
       if (this.status === 'timeout') {

ts/tapbundle.classes.tapwrap.ts

@@ -19,6 +19,7 @@ export class TapWrap {
    * run the wrapFunction
    */
   async run() {
+    // TODO: make sure it makes sense what we do here.
     await this.wrapFunction();
   }
 }

ts/tapbundle.plugins.ts

@@ -1,9 +1,9 @@
 // pushrocks
-import * as early from '@pushrocks/early';
 import * as smartdelay from '@pushrocks/smartdelay';
+import * as smartenv from '@pushrocks/smartenv';
 import * as smartpromise from '@pushrocks/smartpromise';
 
-export { early, smartdelay, smartpromise };
+export { smartdelay, smartenv, smartpromise };
 
 // third party
 /* import * as leakage from 'leakage';