3.2.12

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushrocks/tapbundle",
-  "version": "3.2.10",
+  "version": "3.2.12",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {

package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pushrocks/tapbundle",
   "private": false,
-  "version": "3.2.10",
+  "version": "3.2.12",
   "description": "tap bundled for tapbuffer",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",

test/test.ts

@@ -23,12 +23,14 @@ const test3 = tap.test(
   }
 );
 
-const test4 = tap.skip.test('my 4th test -> should fail', async (tools) => {
+const test4 = tap.test('my 4th test -> should fail', async (tools) => {
   tools.allowFailure();
   expect(false).to.be.true;
+  return 'hello';
 });
 
 const test5 = tap.test('my 5th test -> should pass in about 500ms', async (tools) => {
+  const test4Result = await test4.testResultPromise;
   tools.timeout(1000);
   await tools.delayFor(500);
 });

ts/tapbundle.classes.tap.ts

@@ -2,16 +2,16 @@ import * as plugins from './tapbundle.plugins';
 
 import { IPreTaskFunction, PreTask } from './tapbundle.classes.pretask';
 import { TapTest, ITestFunction } from './tapbundle.classes.taptest';
-export class Tap {
+export class Tap <T> {
   /**
    * skips a test
    * tests marked with tap.skip.test() are never executed
    */
   public skip = {
-    test: (descriptionArg: string, functionArg: ITestFunction) => {
+    test: (descriptionArg: string, functionArg: ITestFunction<T>) => {
       console.log(`skipped test: ${descriptionArg}`);
     },
-    testParallel: (descriptionArg: string, functionArg: ITestFunction) => {
+    testParallel: (descriptionArg: string, functionArg: ITestFunction<T>) => {
       console.log(`skipped test: ${descriptionArg}`);
     },
   };
@@ -20,14 +20,14 @@ export class Tap {
    * only executes tests marked as ONLY
    */
   public only = {
-    test: (descriptionArg: string, testFunctionArg: ITestFunction) => {
+    test: (descriptionArg: string, testFunctionArg: ITestFunction<T>) => {
       this.test(descriptionArg, testFunctionArg, 'only');
     },
   };
 
   private _tapPreTasks: PreTask[] = [];
-  private _tapTests: TapTest[] = [];
+  private _tapTests: TapTest<any>[] = [];
-  private _tapTestsOnly: TapTest[] = [];
+  private _tapTestsOnly: TapTest<any>[] = [];
 
   /**
    * Normal test function, will run one by one
@@ -36,10 +36,10 @@ export class Tap {
    */
   public test(
     testDescription: string,
-    testFunction: ITestFunction,
+    testFunction: ITestFunction<T>,
     modeArg: 'normal' | 'only' | 'skip' = 'normal'
-  ) {
+  ): TapTest<T> {
-    const localTest = new TapTest({
+    const localTest = new TapTest<T>({
       description: testDescription,
       testFunction,
       parallel: false,
@@ -61,7 +61,7 @@ export class Tap {
    * @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) {
+  public testParallel(testDescription: string, testFunction: ITestFunction<T>) {
     this._tapTests.push(
       new TapTest({
         description: testDescription,

ts/tapbundle.classes.taptest.ts

@@ -9,25 +9,25 @@ import { HrtMeasurement } from '@pushrocks/smarttime';
 // interfaces
 export type TTestStatus = 'success' | 'error' | 'pending' | 'errorAfterSuccess' | 'timeout';
 
-export type ITestFunction = (tapTools?: TapTools) => Promise<any>;
+export interface ITestFunction <T> { (tapTools?: TapTools): Promise<T> };
 
-export class TapTest {
+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;
+  public testFunction: ITestFunction<T>;
   public testKey: number; // the testKey the position in the test qeue. Set upon calling .run()
-  private testDeferred: Deferred<TapTest> = plugins.smartpromise.defer();
+  private testDeferred: Deferred<TapTest<T>> = plugins.smartpromise.defer();
-  public testPromise: Promise<TapTest> = this.testDeferred.promise;
+  public testPromise: Promise<TapTest<T>> = this.testDeferred.promise;
-  private testResultDeferred: Deferred<any> = plugins.smartpromise.defer();
+  private testResultDeferred: Deferred<T> = plugins.smartpromise.defer();
-  public testResultPromise: Promise<any> = this.testResultDeferred.promise;
+  public testResultPromise: Promise<T> = this.testResultDeferred.promise;
   /**
    * constructor
    */
-  constructor(optionsArg: { description: string; testFunction: ITestFunction; parallel: boolean }) {
+  constructor(optionsArg: { description: string; testFunction: ITestFunction<T>; parallel: boolean }) {
     this.description = optionsArg.description;
     this.hrtMeasurement = new HrtMeasurement();
     this.parallel = optionsArg.parallel;