@locustjs/test 1.4.0 → 1.6.0

package/index.esm.js

@@ -16,19 +16,27 @@ import {
   isIterable,
   isSomeArray,
   isSubClassOf,
+  isNullOrEmpty,
 } from "@locustjs/base";
 import { Exception } from "@locustjs/exception";
 import fs from "fs";
 import path from "path";
 
+class TestException extends Exception {}
 class Expect {
   constructor(value) {
     this.value = value;
+    this._expected = false;
+  }
+  get expected() {
+    return this._expected;
   }
   toBe(value) {
+    this._expected = true;
+
     if (this.value === value) {
     } else {
-      throw new Exception({
+      throw new TestException({
         message: `${this.value} is not equal to ${value}`,
         code: 1000,
         status: "not-eq",
@@ -37,9 +45,24 @@ 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;
+
     if (this.value <= value) {
-      throw new Exception({
+      throw new TestException({
         message: `${this.value} is not greater than ${value}`,
         code: 1001,
         status: "lte",
@@ -52,8 +75,10 @@ class Expect {
     return this.toBeGt(value);
   }
   toBeGte(value) {
+    this._expected = true;
+
     if (this.value < value) {
-      throw new Exception({
+      throw new TestException({
         message: `${this.value} is not greater than or equal to ${value}`,
         code: 1002,
         status: "lt",
@@ -66,8 +91,10 @@ class Expect {
     return this.toBeGte(value);
   }
   toBeLt(value) {
+    this._expected = true;
+
     if (this.value >= value) {
-      throw new Exception({
+      throw new TestException({
         message: `${this.value} is not less than ${value}`,
         code: 1003,
         status: "gte",
@@ -80,8 +107,10 @@ class Expect {
     return this.toBeLt(value);
   }
   toBeLte(value) {
+    this._expected = true;
+
     if (this.value > value) {
-      throw new Exception({
+      throw new TestException({
         message: `${this.value} is not less than or equal to ${value}`,
         code: 1004,
         status: "gt",
@@ -94,8 +123,10 @@ class Expect {
     return this.toBeLte(value);
   }
   toBeBetween(n, m) {
+    this._expected = true;
+
     if (!(this.value >= n && this.value < m)) {
-      throw new Exception({
+      throw new TestException({
         message: `${this.value} is not between ${n} and ${m}`,
         code: 1024,
         status: "between",
@@ -104,9 +135,24 @@ 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;
+
     if (typeof this.value !== type) {
-      throw new Exception({
+      throw new TestException({
         message: `${this.value} is not of type ${type}`,
         code: 1025,
         status: "of-type",
@@ -115,9 +161,24 @@ 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;
+
     if (!isString(this.value)) {
-      throw new Exception({
+      throw new TestException({
         message: `${this.value} is not string`,
         code: 1026,
         status: "is-string",
@@ -126,9 +187,23 @@ 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)) {
-      throw new Exception({
+      throw new TestException({
         message: `${this.value} is not some string`,
         code: 1027,
         status: "is-some-string",
@@ -137,9 +212,24 @@ class Expect {
 
     return this;
   }
+  notToBeSomeString() {
+    this._expected = true;
+
+    if (isSomeString(this.value)) {
+      throw new TestException({
+        message: `${this.value} is some string`,
+        code: 1047,
+        status: "not-is-some-string",
+      });
+    }
+
+    return this;
+  }
   toBeNumber() {
+    this._expected = true;
+
     if (!isNumber(this.value)) {
-      throw new Exception({
+      throw new TestException({
         message: `${this.value} is not number`,
         code: 1028,
         status: "is-number",
@@ -148,9 +238,24 @@ class Expect {
 
     return this;
   }
+  notToBeNumber() {
+    this._expected = true;
+
+    if (isNumber(this.value)) {
+      throw new TestException({
+        message: `${this.value} is number`,
+        code: 1048,
+        status: "not-is-number",
+      });
+    }
+
+    return this;
+  }
   toBeDate() {
+    this._expected = true;
+
     if (!isDate(this.value)) {
-      throw new Exception({
+      throw new TestException({
         message: `${this.value} is not date`,
         code: 1029,
         status: "is-date",
@@ -159,9 +264,24 @@ class Expect {
 
     return this;
   }
+  notToBeDate() {
+    this._expected = true;
+
+    if (isDate(this.value)) {
+      throw new TestException({
+        message: `${this.value} is date`,
+        code: 1049,
+        status: "not-is-date",
+      });
+    }
+
+    return this;
+  }
   toBeBool() {
+    this._expected = true;
+
     if (!isBool(this.value)) {
-      throw new Exception({
+      throw new TestException({
         message: `${this.value} is not bool`,
         code: 1030,
         status: "is-bool",
@@ -170,9 +290,24 @@ class Expect {
 
     return this;
   }
+  notToBeBool() {
+    this._expected = true;
+
+    if (isBool(this.value)) {
+      throw new TestException({
+        message: `${this.value} is bool`,
+        code: 1050,
+        status: "not-is-bool",
+      });
+    }
+
+    return this;
+  }
   toBeBasicType() {
+    this._expected = true;
+
     if (!isBasic(this.value)) {
-      throw new Exception({
+      throw new TestException({
         message: `${this.value} is not basic type`,
         code: 1031,
         status: "is-basic-type",
@@ -181,9 +316,24 @@ class Expect {
 
     return this;
   }
+  notToBeBasicType() {
+    this._expected = true;
+
+    if (isBasic(this.value)) {
+      throw new TestException({
+        message: `${this.value} is basic type`,
+        code: 1051,
+        status: "not-is-basic-type",
+      });
+    }
+
+    return this;
+  }
   toBePrimitive() {
+    this._expected = true;
+
     if (!isPrimitive(this.value)) {
-      throw new Exception({
+      throw new TestException({
         message: `${this.value} is not primitive type`,
         code: 1032,
         status: "is-primitive",
@@ -192,9 +342,24 @@ class Expect {
 
     return this;
   }
+  notToBePrimitive() {
+    this._expected = true;
+
+    if (isPrimitive(this.value)) {
+      throw new TestException({
+        message: `${this.value} is primitive type`,
+        code: 1052,
+        status: "not-is-primitive",
+      });
+    }
+
+    return this;
+  }
   toBeEmpty() {
+    this._expected = true;
+
     if (!isEmpty(this.value)) {
-      throw new Exception({
+      throw new TestException({
         message: `${this.value} is not empty`,
         code: 1033,
         status: "is-empty",
@@ -203,9 +368,24 @@ class Expect {
 
     return this;
   }
+  notToBeEmpty() {
+    this._expected = true;
+
+    if (isEmpty(this.value)) {
+      throw new TestException({
+        message: `${this.value} is empty`,
+        code: 1053,
+        status: "not-is-empty",
+      });
+    }
+
+    return this;
+  }
   toBeObject() {
+    this._expected = true;
+
     if (!isObject(this.value)) {
-      throw new Exception({
+      throw new TestException({
         message: `${this.value} is not object`,
         code: 1034,
         status: "is-object",
@@ -214,9 +394,24 @@ class Expect {
 
     return this;
   }
+  notToBeObject() {
+    this._expected = true;
+
+    if (isObject(this.value)) {
+      throw new TestException({
+        message: `${this.value} is object`,
+        code: 1054,
+        status: "not-is-object",
+      });
+    }
+
+    return this;
+  }
   toBeSomeObject() {
+    this._expected = true;
+
     if (!isSomeObject(this.value)) {
-      throw new Exception({
+      throw new TestException({
         message: `${this.value} is not some object`,
         code: 1035,
         status: "is-some-object",
@@ -225,9 +420,24 @@ class Expect {
 
     return this;
   }
+  notToBeSomeObject() {
+    this._expected = true;
+
+    if (isSomeObject(this.value)) {
+      throw new TestException({
+        message: `${this.value} is some object`,
+        code: 1055,
+        status: "not-is-some-object",
+      });
+    }
+
+    return this;
+  }
   toBeFunction() {
+    this._expected = true;
+
     if (!isFunction(this.value)) {
-      throw new Exception({
+      throw new TestException({
         message: `${this.value} is not function`,
         code: 1036,
         status: "is-function",
@@ -236,395 +446,357 @@ class Expect {
 
     return this;
   }
-  toBeNumeric() {
-    if (!isNumeric(this.value)) {
-      throw new Exception({
-        message: `${this.value} is not numeric`,
-        code: 1037,
-        status: "is-numeric",
-      });
-    }
+  notToBeFunction() {
+    this._expected = true;
 
-    return this;
-  }
-  toBeArray() {
-    if (!isArray(this.value)) {
-      throw new Exception({
-        message: `${this.value} is not array`,
-        code: 1038,
-        status: "is-array",
+    if (isFunction(this.value)) {
+      throw new TestException({
+        message: `${this.value} is function`,
+        code: 1056,
+        status: "not-is-function",
       });
     }
 
     return this;
   }
-  toBeSomeArray() {
-    if (!isSomeArray(this.value)) {
-      throw new Exception({
-        message: `${this.value} is not some array`,
-        code: 1039,
-        status: "is-some-array",
-      });
-    }
+  toBeNumeric() {
+    this._expected = true;
 
-    return this;
-  }
-  toBeIterable() {
-    if (!isIterable(this.value)) {
-      throw new Exception({
-        message: `${this.value} is not iterable`,
-        code: 1040,
-        status: "is-iterable",
+    if (!isNumeric(this.value)) {
+      throw new TestException({
+        message: `${this.value} is not numeric`,
+        code: 1037,
+        status: "is-numeric",
       });
     }
 
     return this;
   }
-  toBeSubClassOf(type) {
-    if (!isSubClassOf(this.value, type)) {
-      throw new Exception({
-        message: `${this.value} is not subclass of ${type}`,
-        code: 1041,
-        status: "is-subclass-of",
-      });
-    }
+  notToBeNumeric() {
+    this._expected = true;
 
-    return this;
-  }
-  toBeInstanceOf(type) {
-    if (!(this.value instanceof type)) {
-      throw new Exception({
-        message: `${this.value} is not instance of ${type}`,
-        code: 1042,
-        status: "instanceof",
+    if (isNumeric(this.value)) {
+      throw new TestException({
+        message: `${this.value} is numeric`,
+        code: 1057,
+        status: "not-is-numeric",
       });
     }
 
     return this;
   }
-  toMatch(pattern, flags) {
-    const r = new RegExp(pattern, flags);
+  toBeArray() {
+    this._expected = true;
 
-    if (!r.test(this.value)) {
-      throw new Exception({
-        message: `${this.value} does not match ${pattern}`,
-        code: 1043,
-        status: "match",
+    if (!isArray(this.value)) {
+      throw new TestException({
+        message: `${this.value} is not array`,
+        code: 1038,
+        status: "is-array",
       });
     }
 
     return this;
   }
-  notToBe(value) {
-    if (this.value === value) {
-      throw new Exception({
-        message: `${value} is equal to ${this.value}`,
-        code: 1005,
-        status: "eq",
-      });
-    }
+  notToBeArray() {
+    this._expected = true;
 
-    return this;
-  }
-  toBeDefined() {
-    if (this.value === undefined) {
-      throw new Exception({
-        message: `value is undefined`,
-        code: 1006,
-        status: "undefined",
+    if (isArray(this.value)) {
+      throw new TestException({
+        message: `${this.value} is array`,
+        code: 1058,
+        status: "not-is-array",
       });
     }
 
     return this;
   }
-  toBeUndefined() {
-    if (this.value !== undefined) {
-      throw new Exception({
-        message: `value is defined`,
-        code: 1007,
-        status: "defined",
-      });
-    }
+  toBeSomeArray() {
+    this._expected = true;
 
-    return this;
-  }
-  toBeNull() {
-    if (this.value !== null) {
-      throw new Exception({
-        message: `value is not null`,
-        code: 1008,
-        status: "not-null",
+    if (!isSomeArray(this.value)) {
+      throw new TestException({
+        message: `${this.value} is not some array`,
+        code: 1039,
+        status: "is-some-array",
       });
     }
 
     return this;
   }
-  notToBeNull() {
-    if (this.value === null) {
-      throw new Exception({
-        message: `value is null`,
-        code: 1009,
-        status: "null",
-      });
-    }
+  notToBeSomeArray() {
+    this._expected = true;
 
-    return this;
-  }
-  toBeNullOrUndefined() {
-    if (this.value == null) {
-    } else {
-      throw new Exception({
-        message: `value is not null/undefined`,
-        code: 1010,
-        status: "not-null-or-undefined",
+    if (isArray(this.value)) {
+      throw new TestException({
+        message: `${this.value} is array`,
+        code: 1068,
+        status: "is-array",
       });
     }
-
-    return this;
-  }
-  notToBeNullOrUndefined() {
-    if (this.value == null) {
-      throw new Exception({
-        message: `value is null/undefined`,
-        code: 1011,
-        status: "null-or-undefined",
+    if (this.value.length) {
+      throw new TestException({
+        message: `${this.value} is array`,
+        code: 1069,
+        status: "is-some-array",
       });
     }
 
     return this;
   }
-  notToBeBetween(n, m) {
-    if (this.value >= n && this.value < m) {
-      throw new Exception({
-        message: `${this.value} is between ${n} and ${m}`,
-        code: 1044,
-        status: "not-between",
-      });
-    }
+  toBeIterable() {
+    this._expected = true;
 
-    return this;
-  }
-  notToBeOfType(type) {
-    if (typeof this.value === type) {
-      throw new Exception({
-        message: `${this.value} is of type ${type}`,
-        code: 1045,
-        status: "not-oftype",
+    if (!isIterable(this.value)) {
+      throw new TestException({
+        message: `${this.value} is not iterable`,
+        code: 1040,
+        status: "is-iterable",
       });
     }
 
     return this;
   }
-  notToBeString() {
-    if (isString(this.value)) {
-      throw new Exception({
-        message: `${this.value} is string`,
-        code: 1046,
-        status: "not-is-string",
+  notToBeIterable() {
+    this._expected = true;
+
+    if (isIterable(this.value)) {
+      throw new TestException({
+        message: `${this.value} is iterable`,
+        code: 1060,
+        status: "not-iterable",
       });
     }
 
     return this;
   }
-  notToBeSomeString() {
-    if (isSomeString(this.value)) {
-      throw new Exception({
-        message: `${this.value} is some string`,
-        code: 1047,
-        status: "not-is-some-string",
+  toBeSubClassOf(type) {
+    this._expected = true;
+
+    if (!isSubClassOf(this.value, type)) {
+      throw new TestException({
+        message: `${this.value} is not subclass of ${type}`,
+        code: 1041,
+        status: "is-subclass-of",
       });
     }
 
     return this;
   }
-  notToBeNumber() {
-    if (isNumber(this.value)) {
-      throw new Exception({
-        message: `${this.value} is number`,
-        code: 1048,
-        status: "not-is-number",
-      });
-    }
+  notToBeSubClassOf(type) {
+    this._expected = true;
 
-    return this;
-  }
-  notToBeDate() {
-    if (isDate(this.value)) {
-      throw new Exception({
-        message: `${this.value} is date`,
-        code: 1049,
-        status: "not-is-date",
+    if (isSubClassOf(this.value, type)) {
+      throw new TestException({
+        message: `${this.value} is subclass of ${type}`,
+        code: 1061,
+        status: "not-subclassof",
       });
     }
 
     return this;
   }
-  notToBeBool() {
-    if (isBool(this.value)) {
-      throw new Exception({
-        message: `${this.value} is bool`,
-        code: 1050,
-        status: "not-is-bool",
+  toBeInstanceOf(type) {
+    this._expected = true;
+
+    if (!(this.value instanceof type)) {
+      throw new TestException({
+        message: `${this.value} is not instance of ${type}`,
+        code: 1042,
+        status: "instanceof",
       });
     }
 
     return this;
   }
-  notToBeBasicType() {
-    if (isBasic(this.value)) {
-      throw new Exception({
-        message: `${this.value} is basic type`,
-        code: 1051,
-        status: "not-is-basic-type",
+  notToBeInstanceOf(type) {
+    this._expected = true;
+
+    if (this.value instanceof type) {
+      throw new TestException({
+        message: `${this.value} is instance of ${type}`,
+        code: 1062,
+        status: "not-instanceof",
       });
     }
 
     return this;
   }
-  notToBePrimitive() {
-    if (isPrimitive(this.value)) {
-      throw new Exception({
-        message: `${this.value} is primitive type`,
-        code: 1052,
-        status: "not-is-primitive",
+  toMatch(pattern, flags) {
+    this._expected = true;
+
+    const r = new RegExp(pattern, flags);
+
+    if (!r.test(this.value)) {
+      throw new TestException({
+        message: `${this.value} does not match ${pattern}`,
+        code: 1043,
+        status: "match",
       });
     }
 
     return this;
   }
-  notToBeEmpty() {
-    if (isEmpty(this.value)) {
-      throw new Exception({
-        message: `${this.value} is empty`,
-        code: 1053,
-        status: "not-is-empty",
+  notToMatch(pattern, flags) {
+    this._expected = true;
+
+    const r = new RegExp(pattern, flags);
+
+    if (r.test(this.value)) {
+      throw new TestException({
+        message: `${this.value} matches ${pattern}`,
+        code: 1070,
+        status: "match",
       });
     }
 
     return this;
   }
-  notToBeObject() {
-    if (isObject(this.value)) {
-      throw new Exception({
-        message: `${this.value} is object`,
-        code: 1054,
-        status: "not-is-object",
+  doesNotMatch(pattern, flags) {
+    this._expected = true;
+
+    const r = new RegExp(pattern, flags);
+
+    if (r.test(this.value)) {
+      throw new TestException({
+        message: `${this.value} matches ${pattern}`,
+        code: 1063,
+        status: "not-match",
       });
     }
 
     return this;
   }
-  notToBeSomeObject() {
-    if (isSomeObject(this.value)) {
-      throw new Exception({
-        message: `${this.value} is some object`,
-        code: 1055,
-        status: "not-is-some-object",
+  toBeDefined() {
+    this._expected = true;
+
+    if (this.value === undefined) {
+      throw new TestException({
+        message: `value is undefined`,
+        code: 1006,
+        status: "undefined",
       });
     }
 
     return this;
   }
-  notToBeFunction() {
-    if (isFunction(this.value)) {
-      throw new Exception({
-        message: `${this.value} is function`,
-        code: 1056,
-        status: "not-is-function",
+  notToBeDefined() {
+    this._expected = true;
+
+    if (this.value !== undefined) {
+      throw new TestException({
+        message: `value is defined`,
+        code: 1071,
+        status: "defined",
       });
     }
 
     return this;
   }
-  notToBeNumeric() {
-    if (isNumeric(this.value)) {
-      throw new Exception({
-        message: `${this.value} is numeric`,
-        code: 1057,
-        status: "not-is-numeric",
+  toBeUndefined() {
+    this._expected = true;
+
+    if (this.value !== undefined) {
+      throw new TestException({
+        message: `value is defined`,
+        code: 1007,
+        status: "defined",
       });
     }
 
     return this;
   }
-  notToBeArray() {
-    if (isArray(this.value)) {
-      throw new Exception({
-        message: `${this.value} is array`,
-        code: 1058,
-        status: "not-is-array",
+  notToBeUndefined() {
+    this._expected = true;
+
+    if (this.value === undefined) {
+      throw new TestException({
+        message: `value is undefined`,
+        code: 1072,
+        status: "undefined",
       });
     }
 
     return this;
   }
-  toBeEmptyArray() {
-    if (isSomeArray(this.value)) {
-      throw new Exception({
-        message: `${this.value} is some array`,
-        code: 1059,
-        status: "to-be-empty-array",
+  toBeNull() {
+    this._expected = true;
+
+    if (this.value !== null) {
+      throw new TestException({
+        message: `value is not null`,
+        code: 1008,
+        status: "not-null",
       });
     }
 
     return this;
   }
-  notToBeIterable() {
-    if (isIterable(this.value)) {
-      throw new Exception({
-        message: `${this.value} is iterable`,
-        code: 1060,
-        status: "not-iterable",
+  notToBeNull() {
+    this._expected = true;
+
+    if (this.value === null) {
+      throw new TestException({
+        message: `value is null`,
+        code: 1009,
+        status: "null",
       });
     }
 
     return this;
   }
-  notToBeSubClassOf(type) {
-    if (isSubClassOf(this.value, type)) {
-      throw new Exception({
-        message: `${this.value} is subclass of ${type}`,
-        code: 1061,
-        status: "not-subclassof",
+  toBeNullOrUndefined() {
+    this._expected = true;
+
+    if (this.value == null) {
+    } else {
+      throw new TestException({
+        message: `value is not null/undefined`,
+        code: 1010,
+        status: "not-null-or-undefined",
       });
     }
 
     return this;
   }
-  notToBeInstanceOf(type) {
-    if (this.value instanceof type) {
-      throw new Exception({
-        message: `${this.value} is instance of ${type}`,
-        code: 1062,
-        status: "not-instanceof",
+  notToBeNullOrUndefined() {
+    this._expected = true;
+
+    if (this.value == null) {
+      throw new TestException({
+        message: `value is null/undefined`,
+        code: 1011,
+        status: "null-or-undefined",
       });
     }
 
     return this;
   }
-  doesNotMatch(pattern, flags) {
-    const r = new RegExp(pattern, flags);
+  toBeEmptyArray() {
+    this._expected = true;
 
-    if (r.test(this.value)) {
-      throw new Exception({
-        message: `${this.value} matches ${pattern}`,
-        code: 1063,
-        status: "not-match",
+    if (isSomeArray(this.value)) {
+      throw new TestException({
+        message: `${this.value} is some array`,
+        code: 1059,
+        status: "to-be-empty-array",
       });
     }
 
     return this;
   }
   toBeValid(fnValidation) {
+    this._expected = true;
+
     if (!isFunction(fnValidation)) {
-      throw new Exception({
+      throw new TestException({
         message: `fnValidation is not function`,
         code: 1064,
         status: "to-be-valid",
       });
     }
     if (!fnValidation(this.value)) {
-      throw new Exception({
+      throw new TestException({
         message: `${this.value} is not valid`,
         code: 1065,
         status: "to-be-valid",
@@ -634,15 +806,17 @@ class Expect {
     return this;
   }
   notToBeValid(fnValidation) {
+    this._expected = true;
+
     if (!isFunction(fnValidation)) {
-      throw new Exception({
+      throw new TestException({
         message: `fnValidation is not function`,
         code: 1066,
         status: "not-to-be-valid",
       });
     }
     if (fnValidation(this.value)) {
-      throw new Exception({
+      throw new TestException({
         message: `${this.value} is valid`,
         code: 1067,
         status: "not-to-be-valid",
@@ -652,8 +826,10 @@ class Expect {
     return this;
   }
   toThrow(ex, shape = false, strict = false) {
+    this._expected = true;
+
     if (!isFunction(this.value)) {
-      throw new Exception({
+      throw new TestException({
         message: `given argument is not a function.`,
         code: 1012,
         status: "not-func",
@@ -670,7 +846,7 @@ class Expect {
       if (ex !== undefined) {
         if (isPrimitive(ex)) {
           if (e !== ex) {
-            throw new Exception({
+            throw new TestException({
               message: `given function threw incorrect error.`,
               code: 1018,
               status: "incorrect-throw-error",
@@ -678,7 +854,7 @@ class Expect {
           }
         } else if (isFunction(ex)) {
           if (!(e instanceof ex)) {
-            throw new Exception({
+            throw new TestException({
               message: `given function threw incorrect instance.`,
               code: 1019,
               status: "incorrect-throw-instance",
@@ -687,7 +863,7 @@ class Expect {
         } else if (isObject(ex)) {
           if (shape) {
             if (!equals(e, ex, strict)) {
-              throw new Exception({
+              throw new TestException({
                 message: `given function threw incorrect object shape.`,
                 code: 1020,
                 status: "incorrect-throw-shape",
@@ -695,7 +871,7 @@ class Expect {
             }
           } else {
             if (e !== ex) {
-              throw new Exception({
+              throw new TestException({
                 message: `given function threw incorrect object.`,
                 code: 1021,
                 status: "incorrect-throw-object",
@@ -704,7 +880,7 @@ class Expect {
           }
         } else {
           if (e !== ex) {
-            throw new Exception({
+            throw new TestException({
               message: `given function threw incorrect value.`,
               code: 1022,
               status: "incorrect-throw-value",
@@ -715,7 +891,7 @@ class Expect {
     }
 
     if (ok) {
-      throw new Exception({
+      throw new TestException({
         message: `given function ran without throwing any errors.`,
         code: 1013,
         status: "ran-to-completion",
@@ -724,34 +900,39 @@ class Expect {
 
     return this;
   }
-  async toThrowAsync(ex, shape = false, strict = false) {
+  notToThrow(ex, shape = false, strict = false) {
+    this._expected = true;
+
     if (!isFunction(this.value)) {
-      throw new Exception({
+      throw new TestException({
         message: `given argument is not a function.`,
         code: 1012,
         status: "not-func",
       });
     }
 
-    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) {
-            throw new Exception({
+          if (e === ex) {
+            throw new TestException({
               message: `given function threw incorrect error.`,
               code: 1018,
               status: "incorrect-throw-error",
             });
           }
         } else if (isFunction(ex)) {
-          if (!(e instanceof ex)) {
-            throw new Exception({
+          if (e instanceof ex) {
+            throw new TestException({
               message: `given function threw incorrect instance.`,
               code: 1019,
               status: "incorrect-throw-instance",
@@ -759,16 +940,16 @@ class Expect {
           }
         } else if (isObject(ex)) {
           if (shape) {
-            if (!equals(e, ex, strict)) {
-              throw new Exception({
+            if (equals(e, ex, strict)) {
+              throw new TestException({
                 message: `given function threw incorrect object shape.`,
                 code: 1020,
                 status: "incorrect-throw-shape",
               });
             }
           } else {
-            if (e !== ex) {
-              throw new Exception({
+            if (e === ex) {
+              throw new TestException({
                 message: `given function threw incorrect object.`,
                 code: 1021,
                 status: "incorrect-throw-object",
@@ -776,8 +957,8 @@ class Expect {
             }
           }
         } else {
-          if (e !== ex) {
-            throw new Exception({
+          if (e === ex) {
+            throw new TestException({
               message: `given function threw incorrect value.`,
               code: 1022,
               status: "incorrect-throw-value",
@@ -788,46 +969,46 @@ class Expect {
     }
 
     if (ok) {
-      throw new Exception({
-        message: `given function ran without throwing any errors.`,
-        code: 1013,
-        status: "ran-to-completion",
+      throw new TestException({
+        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)) {
-      throw new Exception({
+      throw new TestException({
         message: `given argument is not a function.`,
         code: 1012,
         status: "not-func",
       });
     }
 
-    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) {
-            throw new Exception({
+          if (e !== ex) {
+            throw new TestException({
               message: `given function threw incorrect error.`,
               code: 1018,
               status: "incorrect-throw-error",
             });
           }
         } else if (isFunction(ex)) {
-          if (e instanceof ex) {
-            throw new Exception({
+          if (!(e instanceof ex)) {
+            throw new TestException({
               message: `given function threw incorrect instance.`,
               code: 1019,
               status: "incorrect-throw-instance",
@@ -835,16 +1016,16 @@ class Expect {
           }
         } else if (isObject(ex)) {
           if (shape) {
-            if (equals(e, ex, strict)) {
-              throw new Exception({
+            if (!equals(e, ex, strict)) {
+              throw new TestException({
                 message: `given function threw incorrect object shape.`,
                 code: 1020,
                 status: "incorrect-throw-shape",
               });
             }
           } else {
-            if (e === ex) {
-              throw new Exception({
+            if (e !== ex) {
+              throw new TestException({
                 message: `given function threw incorrect object.`,
                 code: 1021,
                 status: "incorrect-throw-object",
@@ -852,8 +1033,8 @@ class Expect {
             }
           }
         } else {
-          if (e === ex) {
-            throw new Exception({
+          if (e !== ex) {
+            throw new TestException({
               message: `given function threw incorrect value.`,
               code: 1022,
               status: "incorrect-throw-value",
@@ -864,19 +1045,20 @@ class Expect {
     }
 
     if (ok) {
-      throw new Exception({
-        message: `given function threw an error.`,
-        code: 1014,
-        status: "ran-to-error",
-        innerException: error,
+      throw new TestException({
+        message: `given function ran without throwing any errors.`,
+        code: 1013,
+        status: "ran-to-completion",
       });
     }
 
     return this;
   }
   async notToThrowAsync(ex, shape = false, strict = false) {
+    this._expected = true;
+
     if (!isFunction(this.value)) {
-      throw new Exception({
+      throw new TestException({
         message: `given argument is not a function.`,
         code: 1012,
         status: "not-func",
@@ -896,7 +1078,7 @@ class Expect {
       if (ex !== undefined) {
         if (isPrimitive(ex)) {
           if (e === ex) {
-            throw new Exception({
+            throw new TestException({
               message: `given function threw incorrect error.`,
               code: 1018,
               status: "incorrect-throw-error",
@@ -904,7 +1086,7 @@ class Expect {
           }
         } else if (isFunction(ex)) {
           if (e instanceof ex) {
-            throw new Exception({
+            throw new TestException({
               message: `given function threw incorrect instance.`,
               code: 1019,
               status: "incorrect-throw-instance",
@@ -913,7 +1095,7 @@ class Expect {
         } else if (isObject(ex)) {
           if (shape) {
             if (equals(e, ex, strict)) {
-              throw new Exception({
+              throw new TestException({
                 message: `given function threw incorrect object shape.`,
                 code: 1020,
                 status: "incorrect-throw-shape",
@@ -921,7 +1103,7 @@ class Expect {
             }
           } else {
             if (e === ex) {
-              throw new Exception({
+              throw new TestException({
                 message: `given function threw incorrect object.`,
                 code: 1021,
                 status: "incorrect-throw-object",
@@ -930,7 +1112,7 @@ class Expect {
           }
         } else {
           if (e === ex) {
-            throw new Exception({
+            throw new TestException({
               message: `given function threw incorrect value.`,
               code: 1022,
               status: "incorrect-throw-value",
@@ -941,7 +1123,7 @@ class Expect {
     }
 
     if (ok) {
-      throw new Exception({
+      throw new TestException({
         message: `given function threw an error.`,
         code: 1014,
         status: "ran-to-error",
@@ -952,9 +1134,11 @@ class Expect {
     return this;
   }
   toBeTruthy() {
+    this._expected = true;
+
     if (this.value) {
     } else {
-      throw new Exception({
+      throw new TestException({
         message: `${this.value} is not truthy`,
         code: 1015,
         status: "not-truthy",
@@ -967,9 +1151,11 @@ class Expect {
     return this.toBeTruthy();
   }
   toBeFalsy() {
+    this._expected = true;
+
     if (!this.value) {
     } else {
-      throw new Exception({
+      throw new TestException({
         message: `${this.value} is not falsy`,
         code: 1016,
         status: "not-falsy",
@@ -982,9 +1168,11 @@ class Expect {
     return this.toBeFalsy();
   }
   toBeNaN() {
+    this._expected = true;
+
     if (isNaN(this.value)) {
     } else {
-      throw new Exception({
+      throw new TestException({
         message: `${this.value} is not NaN`,
         code: 1017,
         status: "not-nan",
@@ -994,9 +1182,11 @@ class Expect {
     return this;
   }
   notToBeNaN() {
+    this._expected = true;
+
     if (!isNaN(this.value)) {
     } else {
-      throw new Exception({
+      throw new TestException({
         message: `${this.value} is NaN`,
         code: 1023,
         status: "is-nan",
@@ -1007,8 +1197,6 @@ class Expect {
   }
 }
 
-const expect = (x) => new Expect(x);
-
 class Test {
   constructor(name, fn) {
     this.name = name;
@@ -1019,8 +1207,14 @@ class Test {
       const start = new Date();
 
       if (isFunction(this.fn)) {
+        const _expect = new Expect();
+
         try {
-          const _result = this.fn(expect);
+          const _result = this.fn((x) => {
+            _expect.value = x;
+
+            return _expect;
+          });
 
           if (_result && isFunction(_result.then)) {
             _result
@@ -1030,6 +1224,7 @@ class Test {
                   test: this.name,
                   result,
                   time: new Date() - start,
+                  expected: _expect.expected,
                 });
               })
               .catch((ex) => {
@@ -1037,7 +1232,8 @@ class Test {
                   success: false,
                   test: this.name,
                   time: new Date() - start,
-                  err: new Exception({
+                  expected: _expect.expected,
+                  err: new TestException({
                     message: `test '${this.name}' failed.`,
                     code: 501,
                     status: "failed",
@@ -1051,6 +1247,7 @@ class Test {
               test: this.name,
               time: new Date() - start,
               result: _result,
+              expected: _expect.expected,
             });
           }
         } catch (ex) {
@@ -1058,7 +1255,8 @@ class Test {
             success: false,
             test: this.name,
             time: new Date() - start,
-            err: new Exception({
+            expected: _expect.expected,
+            err: new TestException({
               message: `test '${this.name}' failed.`,
               code: 501,
               status: "failed",
@@ -1071,7 +1269,7 @@ class Test {
           success: false,
           test: this.name,
           time: new Date() - start,
-          err: new Exception({
+          err: new TestException({
             message: `test '${this.name}' does not have a function to be called.`,
             code: 500,
             status: "no-func",
@@ -1082,50 +1280,51 @@ class Test {
   }
 }
 
-const reset = "\x1b[0m"
-const bright = "\x1b[1m"
-const dim = "\x1b[2m"
-const underscore = "\x1b[4m"
-const blink = "\x1b[5m"
-const reverse = "\x1b[7m"
-const hidden = "\x1b[8m"
-
-const fgBlack = "\x1b[30m"
-const fgRed = "\x1b[31m"
-const fgGreen = "\x1b[32m"
-const fgYellow = "\x1b[33m"
-const fgBlue = "\x1b[34m"
-const fgMagenta = "\x1b[35m"
-const fgCyan = "\x1b[36m"
-const fgWhite = "\x1b[37m"
-const fgGray = "\x1b[90m"
-
-const bgBlack = "\x1b[40m"
-const bgRed = "\x1b[41m"
-const bgGreen = "\x1b[42m"
-const bgYellow = "\x1b[43m"
-const bgBlue = "\x1b[44m"
-const bgMagenta = "\x1b[45m"
-const bgCyan = "\x1b[46m"
-const bgWhite = "\x1b[47m"
-const bgGray = "\x1b[100m"
+const reset = "\x1b[0m";
+const bright = "\x1b[1m";
+const dim = "\x1b[2m";
+const underscore = "\x1b[4m";
+const blink = "\x1b[5m";
+const reverse = "\x1b[7m";
+const hidden = "\x1b[8m";
+
+const fgBlack = "\x1b[30m";
+const fgRed = "\x1b[31m";
+const fgGreen = "\x1b[32m";
+const fgYellow = "\x1b[33m";
+const fgBlue = "\x1b[34m";
+const fgMagenta = "\x1b[35m";
+const fgCyan = "\x1b[36m";
+const fgWhite = "\x1b[37m";
+const fgGray = "\x1b[90m";
+
+const bgBlack = "\x1b[40m";
+const bgRed = "\x1b[41m";
+const bgGreen = "\x1b[42m";
+const bgYellow = "\x1b[43m";
+const bgBlue = "\x1b[44m";
+const bgMagenta = "\x1b[45m";
+const bgCyan = "\x1b[46m";
+const bgWhite = "\x1b[47m";
+const bgGray = "\x1b[100m";
 
 class TestRunner {
   constructor() {
     this._passed = 0;
     this._failed = 0;
+    this._unknown = 0;
     this._results = [];
     this._errors = [];
   }
   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,
           test: test.name,
-          err: new Exception({
+          err: new TestException({
             message: `onProgress failed for test '${test.name} at index ${i}'.`,
             code: 1500,
             status: "progress-failed",
@@ -1139,7 +1338,9 @@ class TestRunner {
 
     this._results.push(tr);
 
-    if (tr.success) {
+    if (!tr.expected) {
+      this._unknown++;
+    } else if (tr.success) {
       this._passed++;
     } else {
       this._failed++;
@@ -1185,7 +1386,7 @@ class TestRunner {
             .then((_) => res(this.result))
             .catch((ex) => {
               this._errors.push({
-                err: new Exception({
+                err: new TestException({
                   message: `not all tests succeeded. check errors.`,
                   code: 1503,
                   status: "partial-finished",
@@ -1197,7 +1398,7 @@ class TestRunner {
             });
         } else {
           this._errors.push({
-            err: new Exception({
+            err: new TestException({
               message: `invalid tests. expected array or a single test.`,
               code: 1502,
               status: "invalid-tests",
@@ -1208,7 +1409,7 @@ class TestRunner {
         }
       } else {
         this._errors.push({
-          err: new Exception({
+          err: new TestException({
             message: `no tests given to be ran.`,
             code: 1501,
             status: "no-tests",
@@ -1228,38 +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.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) {
@@ -1291,6 +1499,9 @@ class TestRunner {
       (this._failed > 0
         ? `${fgRed} ${this._failed} test(s) failed${reset}`
         : `0 tests failed${reset}`) +
+      (this._unknown > 0
+        ? `, ${fgMagenta} ${this._unknown} test(s) are unknown${reset}`
+        : ``) +
       "\n";
 
     console.log(text);
@@ -1328,12 +1539,29 @@ 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 };
   }
 }
 
 export default TestRunner;
-export { Test, Expect, expect };
+export { Test, Expect, TestException };