@locustjs/test 1.5.0 → 1.6.0

package/index.esm.js

@@ -16,6 +16,7 @@ import {
   isIterable,
   isSomeArray,
   isSubClassOf,
+  isNullOrEmpty,
 } from "@locustjs/base";
 import { Exception } from "@locustjs/exception";
 import fs from "fs";
@@ -44,6 +45,19 @@ class Expect {
 
     return this;
   }
+  notToBe(value) {
+    this._expected = true;
+
+    if (this.value === value) {
+      throw new TestException({
+        message: `${value} is equal to ${this.value}`,
+        code: 1005,
+        status: "eq",
+      });
+    }
+
+    return this;
+  }
   toBeGt(value) {
     this._expected = true;
 
@@ -121,6 +135,19 @@ class Expect {
 
     return this;
   }
+  notToBeBetween(n, m) {
+    this._expected = true;
+
+    if (this.value >= n && this.value < m) {
+      throw new TestException({
+        message: `${this.value} is between ${n} and ${m}`,
+        code: 1044,
+        status: "not-between",
+      });
+    }
+
+    return this;
+  }
   toBeOfType(type) {
     this._expected = true;
 
@@ -134,6 +161,19 @@ class Expect {
 
     return this;
   }
+  notToBeOfType(type) {
+    this._expected = true;
+
+    if (typeof this.value === type) {
+      throw new TestException({
+        message: `${this.value} is of type ${type}`,
+        code: 1045,
+        status: "not-oftype",
+      });
+    }
+
+    return this;
+  }
   toBeString() {
     this._expected = true;
 
@@ -147,6 +187,19 @@ class Expect {
 
     return this;
   }
+  notToBeString() {
+    this._expected = true;
+
+    if (isString(this.value)) {
+      throw new TestException({
+        message: `${this.value} is string`,
+        code: 1046,
+        status: "not-is-string",
+      });
+    }
+
+    return this;
+  }
   toBeSomeString() {
     this._expected = true;
     if (!isSomeString(this.value)) {
@@ -159,565 +212,574 @@ class Expect {
 
     return this;
   }
-  toBeNumber() {
+  notToBeSomeString() {
     this._expected = true;
 
-    if (!isNumber(this.value)) {
+    if (isSomeString(this.value)) {
       throw new TestException({
-        message: `${this.value} is not number`,
-        code: 1028,
-        status: "is-number",
+        message: `${this.value} is some string`,
+        code: 1047,
+        status: "not-is-some-string",
       });
     }
 
     return this;
   }
-  toBeDate() {
+  toBeNumber() {
     this._expected = true;
 
-    if (!isDate(this.value)) {
+    if (!isNumber(this.value)) {
       throw new TestException({
-        message: `${this.value} is not date`,
-        code: 1029,
-        status: "is-date",
+        message: `${this.value} is not number`,
+        code: 1028,
+        status: "is-number",
       });
     }
 
     return this;
   }
-  toBeBool() {
+  notToBeNumber() {
     this._expected = true;
 
-    if (!isBool(this.value)) {
+    if (isNumber(this.value)) {
       throw new TestException({
-        message: `${this.value} is not bool`,
-        code: 1030,
-        status: "is-bool",
+        message: `${this.value} is number`,
+        code: 1048,
+        status: "not-is-number",
       });
     }
 
     return this;
   }
-  toBeBasicType() {
+  toBeDate() {
     this._expected = true;
 
-    if (!isBasic(this.value)) {
+    if (!isDate(this.value)) {
       throw new TestException({
-        message: `${this.value} is not basic type`,
-        code: 1031,
-        status: "is-basic-type",
+        message: `${this.value} is not date`,
+        code: 1029,
+        status: "is-date",
       });
     }
 
     return this;
   }
-  toBePrimitive() {
+  notToBeDate() {
     this._expected = true;
 
-    if (!isPrimitive(this.value)) {
+    if (isDate(this.value)) {
       throw new TestException({
-        message: `${this.value} is not primitive type`,
-        code: 1032,
-        status: "is-primitive",
+        message: `${this.value} is date`,
+        code: 1049,
+        status: "not-is-date",
       });
     }
 
     return this;
   }
-  toBeEmpty() {
+  toBeBool() {
     this._expected = true;
 
-    if (!isEmpty(this.value)) {
+    if (!isBool(this.value)) {
       throw new TestException({
-        message: `${this.value} is not empty`,
-        code: 1033,
-        status: "is-empty",
+        message: `${this.value} is not bool`,
+        code: 1030,
+        status: "is-bool",
       });
     }
 
     return this;
   }
-  toBeObject() {
+  notToBeBool() {
     this._expected = true;
 
-    if (!isObject(this.value)) {
+    if (isBool(this.value)) {
       throw new TestException({
-        message: `${this.value} is not object`,
-        code: 1034,
-        status: "is-object",
+        message: `${this.value} is bool`,
+        code: 1050,
+        status: "not-is-bool",
       });
     }
 
     return this;
   }
-  toBeSomeObject() {
+  toBeBasicType() {
     this._expected = true;
 
-    if (!isSomeObject(this.value)) {
+    if (!isBasic(this.value)) {
       throw new TestException({
-        message: `${this.value} is not some object`,
-        code: 1035,
-        status: "is-some-object",
+        message: `${this.value} is not basic type`,
+        code: 1031,
+        status: "is-basic-type",
       });
     }
 
     return this;
   }
-  toBeFunction() {
+  notToBeBasicType() {
     this._expected = true;
 
-    if (!isFunction(this.value)) {
+    if (isBasic(this.value)) {
       throw new TestException({
-        message: `${this.value} is not function`,
-        code: 1036,
-        status: "is-function",
+        message: `${this.value} is basic type`,
+        code: 1051,
+        status: "not-is-basic-type",
       });
     }
 
     return this;
   }
-  toBeNumeric() {
+  toBePrimitive() {
     this._expected = true;
 
-    if (!isNumeric(this.value)) {
+    if (!isPrimitive(this.value)) {
       throw new TestException({
-        message: `${this.value} is not numeric`,
-        code: 1037,
-        status: "is-numeric",
+        message: `${this.value} is not primitive type`,
+        code: 1032,
+        status: "is-primitive",
       });
     }
 
     return this;
   }
-  toBeArray() {
+  notToBePrimitive() {
     this._expected = true;
 
-    if (!isArray(this.value)) {
+    if (isPrimitive(this.value)) {
       throw new TestException({
-        message: `${this.value} is not array`,
-        code: 1038,
-        status: "is-array",
+        message: `${this.value} is primitive type`,
+        code: 1052,
+        status: "not-is-primitive",
       });
     }
 
     return this;
   }
-  toBeSomeArray() {
+  toBeEmpty() {
     this._expected = true;
 
-    if (!isSomeArray(this.value)) {
+    if (!isEmpty(this.value)) {
       throw new TestException({
-        message: `${this.value} is not some array`,
-        code: 1039,
-        status: "is-some-array",
+        message: `${this.value} is not empty`,
+        code: 1033,
+        status: "is-empty",
       });
     }
 
     return this;
   }
-  toBeIterable() {
+  notToBeEmpty() {
     this._expected = true;
 
-    if (!isIterable(this.value)) {
+    if (isEmpty(this.value)) {
       throw new TestException({
-        message: `${this.value} is not iterable`,
-        code: 1040,
-        status: "is-iterable",
+        message: `${this.value} is empty`,
+        code: 1053,
+        status: "not-is-empty",
       });
     }
 
     return this;
   }
-  toBeSubClassOf(type) {
+  toBeObject() {
     this._expected = true;
 
-    if (!isSubClassOf(this.value, type)) {
+    if (!isObject(this.value)) {
       throw new TestException({
-        message: `${this.value} is not subclass of ${type}`,
-        code: 1041,
-        status: "is-subclass-of",
+        message: `${this.value} is not object`,
+        code: 1034,
+        status: "is-object",
       });
     }
 
     return this;
   }
-  toBeInstanceOf(type) {
+  notToBeObject() {
     this._expected = true;
 
-    if (!(this.value instanceof type)) {
+    if (isObject(this.value)) {
       throw new TestException({
-        message: `${this.value} is not instance of ${type}`,
-        code: 1042,
-        status: "instanceof",
+        message: `${this.value} is object`,
+        code: 1054,
+        status: "not-is-object",
       });
     }
 
     return this;
   }
-  toMatch(pattern, flags) {
+  toBeSomeObject() {
     this._expected = true;
 
-    const r = new RegExp(pattern, flags);
-
-    if (!r.test(this.value)) {
+    if (!isSomeObject(this.value)) {
       throw new TestException({
-        message: `${this.value} does not match ${pattern}`,
-        code: 1043,
-        status: "match",
+        message: `${this.value} is not some object`,
+        code: 1035,
+        status: "is-some-object",
       });
     }
 
     return this;
   }
-  notToBe(value) {
+  notToBeSomeObject() {
     this._expected = true;
 
-    if (this.value === value) {
+    if (isSomeObject(this.value)) {
       throw new TestException({
-        message: `${value} is equal to ${this.value}`,
-        code: 1005,
-        status: "eq",
+        message: `${this.value} is some object`,
+        code: 1055,
+        status: "not-is-some-object",
       });
     }
 
     return this;
   }
-  toBeDefined() {
+  toBeFunction() {
     this._expected = true;
 
-    if (this.value === undefined) {
+    if (!isFunction(this.value)) {
       throw new TestException({
-        message: `value is undefined`,
-        code: 1006,
-        status: "undefined",
+        message: `${this.value} is not function`,
+        code: 1036,
+        status: "is-function",
       });
     }
 
     return this;
   }
-  toBeUndefined() {
+  notToBeFunction() {
     this._expected = true;
 
-    if (this.value !== undefined) {
+    if (isFunction(this.value)) {
       throw new TestException({
-        message: `value is defined`,
-        code: 1007,
-        status: "defined",
+        message: `${this.value} is function`,
+        code: 1056,
+        status: "not-is-function",
       });
     }
 
     return this;
   }
-  toBeNull() {
+  toBeNumeric() {
     this._expected = true;
 
-    if (this.value !== null) {
+    if (!isNumeric(this.value)) {
       throw new TestException({
-        message: `value is not null`,
-        code: 1008,
-        status: "not-null",
+        message: `${this.value} is not numeric`,
+        code: 1037,
+        status: "is-numeric",
       });
     }
 
     return this;
   }
-  notToBeNull() {
+  notToBeNumeric() {
     this._expected = true;
 
-    if (this.value === null) {
+    if (isNumeric(this.value)) {
       throw new TestException({
-        message: `value is null`,
-        code: 1009,
-        status: "null",
+        message: `${this.value} is numeric`,
+        code: 1057,
+        status: "not-is-numeric",
       });
     }
 
     return this;
   }
-  toBeNullOrUndefined() {
+  toBeArray() {
     this._expected = true;
 
-    if (this.value == null) {
-    } else {
+    if (!isArray(this.value)) {
       throw new TestException({
-        message: `value is not null/undefined`,
-        code: 1010,
-        status: "not-null-or-undefined",
+        message: `${this.value} is not array`,
+        code: 1038,
+        status: "is-array",
       });
     }
 
     return this;
   }
-  notToBeNullOrUndefined() {
+  notToBeArray() {
     this._expected = true;
 
-    if (this.value == null) {
+    if (isArray(this.value)) {
       throw new TestException({
-        message: `value is null/undefined`,
-        code: 1011,
-        status: "null-or-undefined",
+        message: `${this.value} is array`,
+        code: 1058,
+        status: "not-is-array",
       });
     }
 
     return this;
   }
-  notToBeBetween(n, m) {
+  toBeSomeArray() {
     this._expected = true;
 
-    if (this.value >= n && this.value < m) {
+    if (!isSomeArray(this.value)) {
       throw new TestException({
-        message: `${this.value} is between ${n} and ${m}`,
-        code: 1044,
-        status: "not-between",
+        message: `${this.value} is not some array`,
+        code: 1039,
+        status: "is-some-array",
       });
     }
 
     return this;
   }
-  notToBeOfType(type) {
+  notToBeSomeArray() {
     this._expected = true;
 
-    if (typeof this.value === type) {
+    if (isArray(this.value)) {
+      throw new TestException({
+        message: `${this.value} is array`,
+        code: 1068,
+        status: "is-array",
+      });
+    }
+    if (this.value.length) {
       throw new TestException({
-        message: `${this.value} is of type ${type}`,
-        code: 1045,
-        status: "not-oftype",
+        message: `${this.value} is array`,
+        code: 1069,
+        status: "is-some-array",
       });
     }
 
     return this;
   }
-  notToBeString() {
+  toBeIterable() {
     this._expected = true;
 
-    if (isString(this.value)) {
+    if (!isIterable(this.value)) {
       throw new TestException({
-        message: `${this.value} is string`,
-        code: 1046,
-        status: "not-is-string",
+        message: `${this.value} is not iterable`,
+        code: 1040,
+        status: "is-iterable",
       });
     }
 
     return this;
   }
-  notToBeSomeString() {
+  notToBeIterable() {
     this._expected = true;
 
-    if (isSomeString(this.value)) {
+    if (isIterable(this.value)) {
       throw new TestException({
-        message: `${this.value} is some string`,
-        code: 1047,
-        status: "not-is-some-string",
+        message: `${this.value} is iterable`,
+        code: 1060,
+        status: "not-iterable",
       });
     }
 
     return this;
   }
-  notToBeNumber() {
+  toBeSubClassOf(type) {
     this._expected = true;
 
-    if (isNumber(this.value)) {
+    if (!isSubClassOf(this.value, type)) {
       throw new TestException({
-        message: `${this.value} is number`,
-        code: 1048,
-        status: "not-is-number",
+        message: `${this.value} is not subclass of ${type}`,
+        code: 1041,
+        status: "is-subclass-of",
       });
     }
 
     return this;
   }
-  notToBeDate() {
+  notToBeSubClassOf(type) {
     this._expected = true;
 
-    if (isDate(this.value)) {
+    if (isSubClassOf(this.value, type)) {
       throw new TestException({
-        message: `${this.value} is date`,
-        code: 1049,
-        status: "not-is-date",
+        message: `${this.value} is subclass of ${type}`,
+        code: 1061,
+        status: "not-subclassof",
       });
     }
 
     return this;
   }
-  notToBeBool() {
+  toBeInstanceOf(type) {
     this._expected = true;
 
-    if (isBool(this.value)) {
+    if (!(this.value instanceof type)) {
       throw new TestException({
-        message: `${this.value} is bool`,
-        code: 1050,
-        status: "not-is-bool",
+        message: `${this.value} is not instance of ${type}`,
+        code: 1042,
+        status: "instanceof",
       });
     }
 
     return this;
   }
-  notToBeBasicType() {
+  notToBeInstanceOf(type) {
     this._expected = true;
 
-    if (isBasic(this.value)) {
+    if (this.value instanceof type) {
       throw new TestException({
-        message: `${this.value} is basic type`,
-        code: 1051,
-        status: "not-is-basic-type",
+        message: `${this.value} is instance of ${type}`,
+        code: 1062,
+        status: "not-instanceof",
       });
     }
 
     return this;
   }
-  notToBePrimitive() {
+  toMatch(pattern, flags) {
     this._expected = true;
 
-    if (isPrimitive(this.value)) {
+    const r = new RegExp(pattern, flags);
+
+    if (!r.test(this.value)) {
       throw new TestException({
-        message: `${this.value} is primitive type`,
-        code: 1052,
-        status: "not-is-primitive",
+        message: `${this.value} does not match ${pattern}`,
+        code: 1043,
+        status: "match",
       });
     }
 
     return this;
   }
-  notToBeEmpty() {
+  notToMatch(pattern, flags) {
     this._expected = true;
 
-    if (isEmpty(this.value)) {
+    const r = new RegExp(pattern, flags);
+
+    if (r.test(this.value)) {
       throw new TestException({
-        message: `${this.value} is empty`,
-        code: 1053,
-        status: "not-is-empty",
+        message: `${this.value} matches ${pattern}`,
+        code: 1070,
+        status: "match",
       });
     }
 
     return this;
   }
-  notToBeObject() {
+  doesNotMatch(pattern, flags) {
     this._expected = true;
 
-    if (isObject(this.value)) {
+    const r = new RegExp(pattern, flags);
+
+    if (r.test(this.value)) {
       throw new TestException({
-        message: `${this.value} is object`,
-        code: 1054,
-        status: "not-is-object",
+        message: `${this.value} matches ${pattern}`,
+        code: 1063,
+        status: "not-match",
       });
     }
 
     return this;
   }
-  notToBeSomeObject() {
+  toBeDefined() {
     this._expected = true;
 
-    if (isSomeObject(this.value)) {
+    if (this.value === undefined) {
       throw new TestException({
-        message: `${this.value} is some object`,
-        code: 1055,
-        status: "not-is-some-object",
+        message: `value is undefined`,
+        code: 1006,
+        status: "undefined",
       });
     }
 
     return this;
   }
-  notToBeFunction() {
+  notToBeDefined() {
     this._expected = true;
 
-    if (isFunction(this.value)) {
+    if (this.value !== undefined) {
       throw new TestException({
-        message: `${this.value} is function`,
-        code: 1056,
-        status: "not-is-function",
+        message: `value is defined`,
+        code: 1071,
+        status: "defined",
       });
     }
 
     return this;
   }
-  notToBeNumeric() {
+  toBeUndefined() {
     this._expected = true;
 
-    if (isNumeric(this.value)) {
+    if (this.value !== undefined) {
       throw new TestException({
-        message: `${this.value} is numeric`,
-        code: 1057,
-        status: "not-is-numeric",
+        message: `value is defined`,
+        code: 1007,
+        status: "defined",
       });
     }
 
     return this;
   }
-  notToBeArray() {
+  notToBeUndefined() {
     this._expected = true;
 
-    if (isArray(this.value)) {
+    if (this.value === undefined) {
       throw new TestException({
-        message: `${this.value} is array`,
-        code: 1058,
-        status: "not-is-array",
+        message: `value is undefined`,
+        code: 1072,
+        status: "undefined",
       });
     }
 
     return this;
   }
-  toBeEmptyArray() {
+  toBeNull() {
     this._expected = true;
 
-    if (isSomeArray(this.value)) {
+    if (this.value !== null) {
       throw new TestException({
-        message: `${this.value} is some array`,
-        code: 1059,
-        status: "to-be-empty-array",
+        message: `value is not null`,
+        code: 1008,
+        status: "not-null",
       });
     }
 
     return this;
   }
-  notToBeIterable() {
+  notToBeNull() {
     this._expected = true;
 
-    if (isIterable(this.value)) {
+    if (this.value === null) {
       throw new TestException({
-        message: `${this.value} is iterable`,
-        code: 1060,
-        status: "not-iterable",
+        message: `value is null`,
+        code: 1009,
+        status: "null",
       });
     }
 
     return this;
   }
-  notToBeSubClassOf(type) {
+  toBeNullOrUndefined() {
     this._expected = true;
 
-    if (isSubClassOf(this.value, type)) {
+    if (this.value == null) {
+    } else {
       throw new TestException({
-        message: `${this.value} is subclass of ${type}`,
-        code: 1061,
-        status: "not-subclassof",
+        message: `value is not null/undefined`,
+        code: 1010,
+        status: "not-null-or-undefined",
       });
     }
 
     return this;
   }
-  notToBeInstanceOf(type) {
+  notToBeNullOrUndefined() {
     this._expected = true;
 
-    if (this.value instanceof type) {
+    if (this.value == null) {
       throw new TestException({
-        message: `${this.value} is instance of ${type}`,
-        code: 1062,
-        status: "not-instanceof",
+        message: `value is null/undefined`,
+        code: 1011,
+        status: "null-or-undefined",
       });
     }
 
     return this;
   }
-  doesNotMatch(pattern, flags) {
+  toBeEmptyArray() {
     this._expected = true;
 
-    const r = new RegExp(pattern, flags);
-
-    if (r.test(this.value)) {
+    if (isSomeArray(this.value)) {
       throw new TestException({
-        message: `${this.value} matches ${pattern}`,
-        code: 1063,
-        status: "not-match",
+        message: `${this.value} is some array`,
+        code: 1059,
+        status: "to-be-empty-array",
       });
     }
 
@@ -838,7 +900,7 @@ class Expect {
 
     return this;
   }
-  async toThrowAsync(ex, shape = false, strict = false) {
+  notToThrow(ex, shape = false, strict = false) {
     this._expected = true;
 
     if (!isFunction(this.value)) {
@@ -849,16 +911,19 @@ class Expect {
       });
     }
 
-    let ok = false;
+    let ok = true;
+    let error;
 
     try {
-      await this.value();
+      this.value();
 
-      ok = true;
+      ok = false;
     } catch (e) {
+      error = e;
+
       if (ex !== undefined) {
         if (isPrimitive(ex)) {
-          if (e !== ex) {
+          if (e === ex) {
             throw new TestException({
               message: `given function threw incorrect error.`,
               code: 1018,
@@ -866,7 +931,7 @@ class Expect {
             });
           }
         } else if (isFunction(ex)) {
-          if (!(e instanceof ex)) {
+          if (e instanceof ex) {
             throw new TestException({
               message: `given function threw incorrect instance.`,
               code: 1019,
@@ -875,7 +940,7 @@ class Expect {
           }
         } else if (isObject(ex)) {
           if (shape) {
-            if (!equals(e, ex, strict)) {
+            if (equals(e, ex, strict)) {
               throw new TestException({
                 message: `given function threw incorrect object shape.`,
                 code: 1020,
@@ -883,7 +948,7 @@ class Expect {
               });
             }
           } else {
-            if (e !== ex) {
+            if (e === ex) {
               throw new TestException({
                 message: `given function threw incorrect object.`,
                 code: 1021,
@@ -892,7 +957,7 @@ class Expect {
             }
           }
         } else {
-          if (e !== ex) {
+          if (e === ex) {
             throw new TestException({
               message: `given function threw incorrect value.`,
               code: 1022,
@@ -905,15 +970,16 @@ class Expect {
 
     if (ok) {
       throw new TestException({
-        message: `given function ran without throwing any errors.`,
-        code: 1013,
-        status: "ran-to-completion",
+        message: `given function threw an error.`,
+        code: 1014,
+        status: "ran-to-error",
+        innerException: error,
       });
     }
 
     return this;
   }
-  notToThrow(ex, shape = false, strict = false) {
+  async toThrowAsync(ex, shape = false, strict = false) {
     this._expected = true;
 
     if (!isFunction(this.value)) {
@@ -924,19 +990,16 @@ class Expect {
       });
     }
 
-    let ok = true;
-    let error;
+    let ok = false;
 
     try {
-      this.value();
+      await this.value();
 
-      ok = false;
+      ok = true;
     } catch (e) {
-      error = e;
-
       if (ex !== undefined) {
         if (isPrimitive(ex)) {
-          if (e === ex) {
+          if (e !== ex) {
             throw new TestException({
               message: `given function threw incorrect error.`,
               code: 1018,
@@ -944,7 +1007,7 @@ class Expect {
             });
           }
         } else if (isFunction(ex)) {
-          if (e instanceof ex) {
+          if (!(e instanceof ex)) {
             throw new TestException({
               message: `given function threw incorrect instance.`,
               code: 1019,
@@ -953,7 +1016,7 @@ class Expect {
           }
         } else if (isObject(ex)) {
           if (shape) {
-            if (equals(e, ex, strict)) {
+            if (!equals(e, ex, strict)) {
               throw new TestException({
                 message: `given function threw incorrect object shape.`,
                 code: 1020,
@@ -961,7 +1024,7 @@ class Expect {
               });
             }
           } else {
-            if (e === ex) {
+            if (e !== ex) {
               throw new TestException({
                 message: `given function threw incorrect object.`,
                 code: 1021,
@@ -970,7 +1033,7 @@ class Expect {
             }
           }
         } else {
-          if (e === ex) {
+          if (e !== ex) {
             throw new TestException({
               message: `given function threw incorrect value.`,
               code: 1022,
@@ -983,10 +1046,9 @@ class Expect {
 
     if (ok) {
       throw new TestException({
-        message: `given function threw an error.`,
-        code: 1014,
-        status: "ran-to-error",
-        innerException: error,
+        message: `given function ran without throwing any errors.`,
+        code: 1013,
+        status: "ran-to-completion",
       });
     }
 
@@ -1257,7 +1319,7 @@ class TestRunner {
   async _runSingle(test, onProgress, i) {
     if (isFunction(onProgress)) {
       try {
-        onProgress(i, test);
+        onProgress({ source: this, test, index: i });
       } catch (ex) {
         this._errors.push({
           index: i,
@@ -1367,40 +1429,45 @@ class TestRunner {
     console.log("Finished.\n");
 
     for (let i = 0; i < this._results.length; i++) {
-      const result = this._results[i];
-      const t = `(${this._getTime(result.time)})`;
+      const testResult = this._results[i];
+      const t = `(${this._getTime(testResult.time)})`;
 
       if (detailed) {
         let message = "\n" + (i + 1) + ". ";
-
-        if (!result.expected) {
-          message += `${bright}${fgWhite}${result.test}: ${fgMagenta}expect not used${reset} ${t}`;
-        } else if (result.success) {
-          message += `${fgWhite}${result.test}: ${fgGreen}passed${reset} ${t}`;
+        let err = !isNullOrEmpty(testResult.err)
+          ? testResult.err.toString().split("\n")
+          : [];
+
+        err = err
+          .map(
+            (msg, i) =>
+              `\t${
+                i == err.length - 1
+                  ? `${fgYellow}`
+                  : `${fgGray}error ${testResult.err.code}: `
+              }${msg}${reset}`
+          )
+          .join("\n");
+
+        if (!testResult.expected) {
+          message += `${bright}${fgWhite}${testResult.test}: ${fgMagenta}expect not used${reset} ${t}`;
+
+          if (testResult.err) {
+            message += "\n";
+            message += `${fgGray}${err} ${reset}`;
+          }
+        } else if (testResult.success) {
+          message += `${fgWhite}${testResult.test}: ${fgGreen}passed${reset} ${t}`;
         } else {
-          message += `${bright}${fgWhite}${result.test}: ${fgRed}failed${reset} ${t}`;
+          message += `${bright}${fgWhite}${testResult.test}: ${fgRed}failed${reset} ${t}`;
           message += "\n";
-
-          let err = result.err.toString().split("\n");
-
-          err = err
-            .map(
-              (msg, i) =>
-                `\t${
-                  i == err.length - 1
-                    ? `${fgYellow}`
-                    : `${fgGray}error ${result.err.code}: `
-                }${msg}${reset}`
-            )
-            .join("\n");
-
           message += `${fgGray}${err} ${reset}`;
         }
 
         console.log(message);
       }
 
-      time += result.time;
+      time += testResult.time;
     }
 
     if (detailed && this._errors.length) {
@@ -1472,10 +1539,27 @@ class TestRunner {
       console.log("writing tests outcome failed.\n" + ex);
     }
   }
-  static start(tests) {
+  static async start(...tests) {
     const tr = new TestRunner();
+    const lastArg = tests[tests.length - 1];
+    const detailed = tests.length && isBool(lastArg) ? lastArg : false;
+    let _tests = [];
+
+    for (let i = 0; i < tests.length; i++) {
+      const t = tests[i];
+
+      if (i != tests.length - 1 || !isBool(t)) {
+        if (isIterable(t)) {
+          _tests = [..._tests, ...t];
+        }
+      }
+    }
+
+    const result = await tr.run(_tests);
+
+    tr.report(detailed || result.failed > 0);
 
-    tr.run(tests).then((result) => tr.report(result.failed > 0));
+    return { runner: tr, result };
   }
 }