@locustjs/test 1.1.7 → 1.2.0

package/index.cjs.js

@@ -1,4 +1,4 @@
-import { isArray, isFunction, isObject, isPrimitive, equals } from '@locustjs/base';
+import { equals, isString, isNumber, isDate, isBool, isBasic, isPrimitive, isEmpty, isSomeString, isObject, isSomeObject, isFunction, isNumeric, isArray, isIterable, isSomeArray, isSubClassOf } from '@locustjs/base';
 import { Exception } from '@locustjs/exception';
 import fs from 'fs';
 import path from 'path';
@@ -14,42 +14,248 @@ class Expect {
         status: 'not-eq'
       });
     }
+    return this;
   }
   toBeGt(value) {
     if (this.value <= value) {
       throw new Exception({
-        message: `${this.value} is lower than or equal to ${value}`,
+        message: `${this.value} is not greater than ${value}`,
         code: 1001,
         status: 'lte'
       });
     }
+    return this;
   }
   toBeGte(value) {
     if (this.value < value) {
       throw new Exception({
-        message: `${this.value} is lower than to ${value}`,
+        message: `${this.value} is not greater than or equal to ${value}`,
         code: 1002,
         status: 'lt'
       });
     }
+    return this;
   }
   toBeLt(value) {
     if (this.value >= value) {
       throw new Exception({
-        message: `${this.value} is greater than or equal to ${value}`,
+        message: `${this.value} is not less than ${value}`,
         code: 1003,
         status: 'gte'
       });
     }
+    return this;
   }
   toBeLte(value) {
     if (this.value > value) {
       throw new Exception({
-        message: `${this.value} is greater than ${value}`,
+        message: `${this.value} is not less than or equal to ${value}`,
         code: 1004,
         status: 'gt'
       });
     }
+    return this;
+  }
+  toBeBetween(n, m) {
+    if (!(this.value >= n && this.value < m)) {
+      throw new Exception({
+        message: `${this.value} is not between ${n} and ${m}`,
+        code: 1024,
+        status: 'between'
+      });
+    }
+    return this;
+  }
+  toBeOfType(type) {
+    if (typeof this.value !== type) {
+      throw new Exception({
+        message: `${this.value} is not of type ${type}`,
+        code: 1025,
+        status: 'of-type'
+      });
+    }
+    return this;
+  }
+  toBeString() {
+    if (!isString(this.value)) {
+      throw new Exception({
+        message: `${this.value} is not string`,
+        code: 1026,
+        status: 'is-string'
+      });
+    }
+    return this;
+  }
+  toBeSomeString() {
+    if (!isSomeString(this.value)) {
+      throw new Exception({
+        message: `${this.value} is not some string`,
+        code: 1027,
+        status: 'is-some-string'
+      });
+    }
+    return this;
+  }
+  toBeNumber() {
+    if (!isNumber(this.value)) {
+      throw new Exception({
+        message: `${this.value} is not number`,
+        code: 1028,
+        status: 'is-number'
+      });
+    }
+    return this;
+  }
+  toBeDate() {
+    if (!isDate(this.value)) {
+      throw new Exception({
+        message: `${this.value} is not date`,
+        code: 1029,
+        status: 'is-date'
+      });
+    }
+    return this;
+  }
+  toBeBool() {
+    if (!isBool(this.value)) {
+      throw new Exception({
+        message: `${this.value} is not bool`,
+        code: 1030,
+        status: 'is-bool'
+      });
+    }
+    return this;
+  }
+  toBeBasicType() {
+    if (!isBasic(this.value)) {
+      throw new Exception({
+        message: `${this.value} is not basic type`,
+        code: 1031,
+        status: 'is-basic-type'
+      });
+    }
+    return this;
+  }
+  toBePrimitive() {
+    if (!isPrimitive(this.value)) {
+      throw new Exception({
+        message: `${this.value} is not primitive type`,
+        code: 1032,
+        status: 'is-primitive'
+      });
+    }
+    return this;
+  }
+  toBeEmpty() {
+    if (!isEmpty(this.value)) {
+      throw new Exception({
+        message: `${this.value} is not empty`,
+        code: 1033,
+        status: 'is-empty'
+      });
+    }
+    return this;
+  }
+  toBeObject() {
+    if (!isObject(this.value)) {
+      throw new Exception({
+        message: `${this.value} is not object`,
+        code: 1034,
+        status: 'is-object'
+      });
+    }
+    return this;
+  }
+  toBeSomeObject() {
+    if (!isSomeObject(this.value)) {
+      throw new Exception({
+        message: `${this.value} is not some object`,
+        code: 1035,
+        status: 'is-some-object'
+      });
+    }
+    return this;
+  }
+  toBeFunction() {
+    if (!isFunction(this.value)) {
+      throw new Exception({
+        message: `${this.value} is not function`,
+        code: 1036,
+        status: 'is-function'
+      });
+    }
+    return this;
+  }
+  toBeNumeric() {
+    if (!isNumeric(this.value)) {
+      throw new Exception({
+        message: `${this.value} is not numeric`,
+        code: 1037,
+        status: 'is-numeric'
+      });
+    }
+    return this;
+  }
+  toBeArray() {
+    if (!isArray(this.value)) {
+      throw new Exception({
+        message: `${this.value} is not array`,
+        code: 1038,
+        status: 'is-array'
+      });
+    }
+    return this;
+  }
+  toBeSomeArray() {
+    if (!isSomeArray(this.value)) {
+      throw new Exception({
+        message: `${this.value} is not some array`,
+        code: 1039,
+        status: 'is-some-array'
+      });
+    }
+    return this;
+  }
+  toBeIterable() {
+    if (!isIterable(this.value)) {
+      throw new Exception({
+        message: `${this.value} is not iterable`,
+        code: 1040,
+        status: 'is-iterable'
+      });
+    }
+    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'
+      });
+    }
+    return this;
+  }
+  toBeInstanceOf(type) {
+    if (!(this.value instanceof type)) {
+      throw new Exception({
+        message: `${this.value} is not instance of ${type}`,
+        code: 1042,
+        status: 'instanceof'
+      });
+    }
+    return this;
+  }
+  toMatch(pattern, flags) {
+    const r = new RegExp(pattern, flags);
+    if (!r.test(this.value)) {
+      throw new Exception({
+        message: `${this.value} does not match ${pattern}`,
+        code: 1043,
+        status: 'match'
+      });
+    }
+    return this;
   }
   notToBe(value) {
     if (this.value === value) {
@@ -59,6 +265,7 @@ class Expect {
         status: 'eq'
       });
     }
+    return this;
   }
   toBeDefined() {
     if (this.value === undefined) {
@@ -68,6 +275,7 @@ class Expect {
         status: 'undefined'
       });
     }
+    return this;
   }
   toBeUndefined() {
     if (this.value !== undefined) {
@@ -77,6 +285,7 @@ class Expect {
         status: 'defined'
       });
     }
+    return this;
   }
   toBeNull() {
     if (this.value !== null) {
@@ -86,6 +295,7 @@ class Expect {
         status: 'not-null'
       });
     }
+    return this;
   }
   notToBeNull() {
     if (this.value === null) {
@@ -95,6 +305,7 @@ class Expect {
         status: 'null'
       });
     }
+    return this;
   }
   toBeNullOrUndefined() {
     if (this.value == null) {} else {
@@ -104,6 +315,7 @@ class Expect {
         status: 'not-null-or-undefined'
       });
     }
+    return this;
   }
   notToBeNullOrUndefined() {
     if (this.value == null) {
@@ -113,6 +325,208 @@ class Expect {
         status: 'null-or-undefined'
       });
     }
+    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'
+      });
+    }
+    return this;
+  }
+  notToBeOfType(type) {
+    if (typeof this.value === type) {
+      throw new Exception({
+        message: `${this.value} is of type ${type}`,
+        code: 1045,
+        status: 'not-oftype'
+      });
+    }
+    return this;
+  }
+  notToBeString() {
+    if (isString(this.value)) {
+      throw new Exception({
+        message: `${this.value} is string`,
+        code: 1046,
+        status: 'not-is-string'
+      });
+    }
+    return this;
+  }
+  notToBeSomeString() {
+    if (isSomeString(this.value)) {
+      throw new Exception({
+        message: `${this.value} is some string`,
+        code: 1047,
+        status: 'not-is-some-string'
+      });
+    }
+    return this;
+  }
+  notToBeNumber() {
+    if (isNumber(this.value)) {
+      throw new Exception({
+        message: `${this.value} is number`,
+        code: 1048,
+        status: 'not-is-number'
+      });
+    }
+    return this;
+  }
+  notToBeDate() {
+    if (isDate(this.value)) {
+      throw new Exception({
+        message: `${this.value} is date`,
+        code: 1049,
+        status: 'not-is-date'
+      });
+    }
+    return this;
+  }
+  notToBeBool() {
+    if (isBool(this.value)) {
+      throw new Exception({
+        message: `${this.value} is bool`,
+        code: 1050,
+        status: 'not-is-bool'
+      });
+    }
+    return this;
+  }
+  notToBeBasicType() {
+    if (isBasic(this.value)) {
+      throw new Exception({
+        message: `${this.value} is basic type`,
+        code: 1051,
+        status: 'not-is-basic-type'
+      });
+    }
+    return this;
+  }
+  notToBePrimitive() {
+    if (isPrimitive(this.value)) {
+      throw new Exception({
+        message: `${this.value} is primitive type`,
+        code: 1052,
+        status: 'not-is-primitive'
+      });
+    }
+    return this;
+  }
+  notToBeEmpty() {
+    if (isEmpty(this.value)) {
+      throw new Exception({
+        message: `${this.value} is empty`,
+        code: 1053,
+        status: 'not-is-empty'
+      });
+    }
+    return this;
+  }
+  notToBeObject() {
+    if (isObject(this.value)) {
+      throw new Exception({
+        message: `${this.value} is object`,
+        code: 1054,
+        status: 'not-is-object'
+      });
+    }
+    return this;
+  }
+  notToBeSomeObject() {
+    if (isSomeObject(this.value)) {
+      throw new Exception({
+        message: `${this.value} is some object`,
+        code: 1055,
+        status: 'not-is-some-object'
+      });
+    }
+    return this;
+  }
+  notToBeFunction() {
+    if (isFunction(this.value)) {
+      throw new Exception({
+        message: `${this.value} is function`,
+        code: 1056,
+        status: 'not-is-function'
+      });
+    }
+    return this;
+  }
+  notToBeNumeric() {
+    if (isNumeric(this.value)) {
+      throw new Exception({
+        message: `${this.value} is numeric`,
+        code: 1057,
+        status: 'not-is-numeric'
+      });
+    }
+    return this;
+  }
+  notToBeArray() {
+    if (isArray(this.value)) {
+      throw new Exception({
+        message: `${this.value} is array`,
+        code: 1058,
+        status: 'not-is-array'
+      });
+    }
+    return this;
+  }
+  toBeEmptyArray() {
+    if (isSomeArray(this.value)) {
+      throw new Exception({
+        message: `${this.value} is some array`,
+        code: 1059,
+        status: 'to-be-empty-array'
+      });
+    }
+    return this;
+  }
+  notToBeIterable() {
+    if (isIterable(this.value)) {
+      throw new Exception({
+        message: `${this.value} is iterable`,
+        code: 1060,
+        status: 'not-iterable'
+      });
+    }
+    return this;
+  }
+  notToBeSubClassOf(type) {
+    if (isSubClassOf(this.value, type)) {
+      throw new Exception({
+        message: `${this.value} is subclass of ${type}`,
+        code: 1061,
+        status: 'not-subclassof'
+      });
+    }
+    return this;
+  }
+  notToBeInstanceOf(type) {
+    if (this.value instanceof type) {
+      throw new Exception({
+        message: `${this.value} is instance of ${type}`,
+        code: 1062,
+        status: 'not-instanceof'
+      });
+    }
+    return this;
+  }
+  doesNotMatch(pattern, flags) {
+    const r = new RegExp(pattern, flags);
+    if (r.test(this.value)) {
+      throw new Exception({
+        message: `${this.value} matches ${pattern}`,
+        code: 1063,
+        status: 'not-match'
+      });
+    }
+    return this;
   }
   toThrow(ex, shape = false, strict = false) {
     if (!isFunction(this.value)) {
@@ -180,6 +594,7 @@ class Expect {
         status: 'ran-to-completion'
       });
     }
+    return this;
   }
   async toThrowAsync(ex, shape = false, strict = false) {
     if (!isFunction(this.value)) {
@@ -247,6 +662,7 @@ class Expect {
         status: 'ran-to-completion'
       });
     }
+    return this;
   }
   notToThrow(ex, shape = false, strict = false) {
     if (!isFunction(this.value)) {
@@ -317,6 +733,7 @@ class Expect {
         innerException: error
       });
     }
+    return this;
   }
   async notToThrowAsync(ex, shape = false, strict = false) {
     if (!isFunction(this.value)) {
@@ -387,6 +804,7 @@ class Expect {
         innerException: error
       });
     }
+    return this;
   }
   toBeTruthy() {
     if (this.value) {} else {
@@ -396,6 +814,7 @@ class Expect {
         status: 'not-truthy'
       });
     }
+    return this;
   }
   toBeFalsy() {
     if (!this.value) {} else {
@@ -405,6 +824,7 @@ class Expect {
         status: 'not-falsy'
       });
     }
+    return this;
   }
   toBeNaN() {
     if (isNaN(this.value)) {} else {
@@ -414,6 +834,7 @@ class Expect {
         status: 'not-nan'
       });
     }
+    return this;
   }
   notToBeNaN() {
     if (!isNaN(this.value)) {} else {
@@ -423,6 +844,7 @@ class Expect {
         status: 'is-nan'
       });
     }
+    return this;
   }
 }
 const expect = x => new Expect(x);

package/index.esm.js

@@ -1,4 +1,22 @@
-import { isArray, isFunction, isObject, isPrimitive, equals } from '@locustjs/base';
+import {
+	equals,
+	isString,
+	isNumber,
+	isDate,
+	isBool,
+	isBasic,
+	isPrimitive,
+	isEmpty,
+	isSomeString,
+	isObject,
+	isSomeObject,
+	isFunction,
+	isNumeric,
+	isArray,
+	isIterable,
+	isSomeArray,
+	isSubClassOf
+} from '@locustjs/base';
 import { Exception } from '@locustjs/exception';
 import fs from 'fs';
 import path from 'path';
@@ -12,62 +30,370 @@ class Expect {
 		} else {
 			throw new Exception({ message: `${this.value} is not equal to ${value}`, code: 1000, status: 'not-eq' })
 		}
+
+		return this;
 	}
 	toBeGt(value) {
 		if (this.value <= value) {
-			throw new Exception({ message: `${this.value} is lower than or equal to ${value}`, code: 1001, status: 'lte' })
+			throw new Exception({ message: `${this.value} is not greater than ${value}`, code: 1001, status: 'lte' })
 		}
+
+		return this;
 	}
 	toBeGte(value) {
 		if (this.value < value) {
-			throw new Exception({ message: `${this.value} is lower than to ${value}`, code: 1002, status: 'lt' })
+			throw new Exception({ message: `${this.value} is not greater than or equal to ${value}`, code: 1002, status: 'lt' })
 		}
+
+		return this;
 	}
 	toBeLt(value) {
 		if (this.value >= value) {
-			throw new Exception({ message: `${this.value} is greater than or equal to ${value}`, code: 1003, status: 'gte' })
+			throw new Exception({ message: `${this.value} is not less than ${value}`, code: 1003, status: 'gte' })
 		}
+
+		return this;
 	}
 	toBeLte(value) {
 		if (this.value > value) {
-			throw new Exception({ message: `${this.value} is greater than ${value}`, code: 1004, status: 'gt' })
+			throw new Exception({ message: `${this.value} is not less than or equal to ${value}`, code: 1004, status: 'gt' })
+		}
+
+		return this;
+	}
+	toBeBetween(n, m) {
+		if (!(this.value >= n && this.value < m)) {
+			throw new Exception({ message: `${this.value} is not between ${n} and ${m}`, code: 1024, status: 'between' })
+		}
+
+		return this;
+	}
+	toBeOfType(type) {
+		if (typeof this.value !== type) {
+			throw new Exception({ message: `${this.value} is not of type ${type}`, code: 1025, status: 'of-type' })
+		}
+
+		return this;
+	}
+	toBeString() {
+		if (!isString(this.value)) {
+			throw new Exception({ message: `${this.value} is not string`, code: 1026, status: 'is-string' })
+		}
+
+		return this;
+	}
+	toBeSomeString() {
+		if (!isSomeString(this.value)) {
+			throw new Exception({ message: `${this.value} is not some string`, code: 1027, status: 'is-some-string' })
+		}
+
+		return this;
+	}
+	toBeNumber() {
+		if (!isNumber(this.value)) {
+			throw new Exception({ message: `${this.value} is not number`, code: 1028, status: 'is-number' })
+		}
+
+		return this;
+	}
+	toBeDate() {
+		if (!isDate(this.value)) {
+			throw new Exception({ message: `${this.value} is not date`, code: 1029, status: 'is-date' })
+		}
+
+		return this;
+	}
+	toBeBool() {
+		if (!isBool(this.value)) {
+			throw new Exception({ message: `${this.value} is not bool`, code: 1030, status: 'is-bool' })
+		}
+
+		return this;
+	}
+	toBeBasicType() {
+		if (!isBasic(this.value)) {
+			throw new Exception({ message: `${this.value} is not basic type`, code: 1031, status: 'is-basic-type' })
+		}
+
+		return this;
+	}
+	toBePrimitive() {
+		if (!isPrimitive(this.value)) {
+			throw new Exception({ message: `${this.value} is not primitive type`, code: 1032, status: 'is-primitive' })
 		}
+
+		return this;
+	}
+	toBeEmpty() {
+		if (!isEmpty(this.value)) {
+			throw new Exception({ message: `${this.value} is not empty`, code: 1033, status: 'is-empty' })
+		}
+
+		return this;
+	}
+	toBeObject() {
+		if (!isObject(this.value)) {
+			throw new Exception({ message: `${this.value} is not object`, code: 1034, status: 'is-object' })
+		}
+
+		return this;
+	}
+	toBeSomeObject() {
+		if (!isSomeObject(this.value)) {
+			throw new Exception({ message: `${this.value} is not some object`, code: 1035, status: 'is-some-object' })
+		}
+
+		return this;
+	}
+	toBeFunction() {
+		if (!isFunction(this.value)) {
+			throw new Exception({ message: `${this.value} is not function`, code: 1036, status: 'is-function' })
+		}
+
+		return this;
+	}
+	toBeNumeric() {
+		if (!isNumeric(this.value)) {
+			throw new Exception({ message: `${this.value} is not numeric`, code: 1037, status: 'is-numeric' })
+		}
+
+		return this;
+	}
+	toBeArray() {
+		if (!isArray(this.value)) {
+			throw new Exception({ message: `${this.value} is not array`, code: 1038, status: 'is-array' })
+		}
+
+		return this;
+	}
+	toBeSomeArray() {
+		if (!isSomeArray(this.value)) {
+			throw new Exception({ message: `${this.value} is not some array`, code: 1039, status: 'is-some-array' })
+		}
+
+		return this;
+	}
+	toBeIterable() {
+		if (!isIterable(this.value)) {
+			throw new Exception({ message: `${this.value} is not iterable`, code: 1040, status: 'is-iterable' })
+		}
+
+		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' })
+		}
+
+		return this;
+	}
+	toBeInstanceOf(type) {
+		if (!(this.value instanceof type)) {
+			throw new Exception({ message: `${this.value} is not instance of ${type}`, code: 1042, status: 'instanceof' })
+		}
+
+		return this;
+	}
+	toMatch(pattern, flags) {
+		const r = new RegExp(pattern, flags)
+
+		if (!r.test(this.value)) {
+			throw new Exception({ message: `${this.value} does not match ${pattern}`, code: 1043, status: 'match' })
+		}
+
+		return this;
 	}
 	notToBe(value) {
 		if (this.value === value) {
 			throw new Exception({ message: `${value} is equal to ${this.value}`, code: 1005, status: 'eq' })
 		}
+
+		return this;
 	}
 	toBeDefined() {
 		if (this.value === undefined) {
 			throw new Exception({ message: `value is undefined`, code: 1006, status: 'undefined' })
 		}
+
+		return this;
 	}
 	toBeUndefined() {
 		if (this.value !== undefined) {
 			throw new Exception({ message: `value is defined`, code: 1007, status: 'defined' })
 		}
+
+		return this;
 	}
 	toBeNull() {
 		if (this.value !== null) {
 			throw new Exception({ message: `value is not null`, code: 1008, status: 'not-null' })
 		}
+
+		return this;
 	}
 	notToBeNull() {
 		if (this.value === null) {
 			throw new Exception({ message: `value is null`, code: 1009, status: 'null' })
 		}
+
+		return this;
 	}
 	toBeNullOrUndefined() {
 		if (this.value == null) {
 		} else {
 			throw new Exception({ message: `value is not null/undefined`, code: 1010, status: 'not-null-or-undefined' })
 		}
+
+		return this;
 	}
 	notToBeNullOrUndefined() {
 		if (this.value == null) {
 			throw new Exception({ message: `value is null/undefined`, code: 1011, status: 'null-or-undefined' })
 		}
+
+		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' })
+		}
+		
+		return this;
+	}
+	notToBeOfType(type) {
+		if (typeof this.value === type) {
+			throw new Exception({ message: `${this.value} is of type ${type}`, code: 1045, status: 'not-oftype' })
+		}
+		
+		return this;
+	}
+	notToBeString() {
+		if (isString(this.value)) {
+			throw new Exception({ message: `${this.value} is string`, code: 1046, status: 'not-is-string' })
+		}
+		
+		return this;
+	}
+	notToBeSomeString() {
+		if (isSomeString(this.value)) {
+			throw new Exception({ message: `${this.value} is some string`, code: 1047, status: 'not-is-some-string' })
+		}
+		
+		return this;
+	}
+	notToBeNumber() {
+		if (isNumber(this.value)) {
+			throw new Exception({ message: `${this.value} is number`, code: 1048, status: 'not-is-number' })
+		}
+		
+		return this;
+	}
+	notToBeDate() {
+		if (isDate(this.value)) {
+			throw new Exception({ message: `${this.value} is date`, code: 1049, status: 'not-is-date' })
+		}
+		
+		return this;
+	}
+	notToBeBool() {
+		if (isBool(this.value)) {
+			throw new Exception({ message: `${this.value} is bool`, code: 1050, status: 'not-is-bool' })
+		}
+		
+		return this;
+	}
+	notToBeBasicType() {
+		if (isBasic(this.value)) {
+			throw new Exception({ message: `${this.value} is basic type`, code: 1051, status: 'not-is-basic-type' })
+		}
+		
+		return this;
+	}
+	notToBePrimitive() {
+		if (isPrimitive(this.value)) {
+			throw new Exception({ message: `${this.value} is primitive type`, code: 1052, status: 'not-is-primitive' })
+		}
+		
+		return this;
+	}
+	notToBeEmpty() {
+		if (isEmpty(this.value)) {
+			throw new Exception({ message: `${this.value} is empty`, code: 1053, status: 'not-is-empty' })
+		}
+		
+		return this;
+	}
+	notToBeObject() {
+		if (isObject(this.value)) {
+			throw new Exception({ message: `${this.value} is object`, code: 1054, status: 'not-is-object' })
+		}
+		
+		return this;
+	}
+	notToBeSomeObject() {
+		if (isSomeObject(this.value)) {
+			throw new Exception({ message: `${this.value} is some object`, code: 1055, status: 'not-is-some-object' })
+		}
+		
+		return this;
+	}
+	notToBeFunction() {
+		if (isFunction(this.value)) {
+			throw new Exception({ message: `${this.value} is function`, code: 1056, status: 'not-is-function' })
+		}
+		
+		return this;
+	}
+	notToBeNumeric() {
+		if (isNumeric(this.value)) {
+			throw new Exception({ message: `${this.value} is numeric`, code: 1057, status: 'not-is-numeric' })
+		}
+		
+		return this;
+	}
+	notToBeArray() {
+		if (isArray(this.value)) {
+			throw new Exception({ message: `${this.value} is array`, code: 1058, status: 'not-is-array' })
+		}
+		
+		return this;
+	}
+	toBeEmptyArray() {
+		if (isSomeArray(this.value)) {
+			throw new Exception({ message: `${this.value} is some array`, code: 1059, status: 'to-be-empty-array' })
+		}
+		
+		return this;
+	}
+	notToBeIterable() {
+		if (isIterable(this.value)) {
+			throw new Exception({ message: `${this.value} is iterable`, code: 1060, status: 'not-iterable' })
+		}
+		
+		return this;
+	}
+	notToBeSubClassOf(type) {
+		if (isSubClassOf(this.value, type)) {
+			throw new Exception({ message: `${this.value} is subclass of ${type}`, code: 1061, status: 'not-subclassof' })
+		}
+		
+		return this;
+	}
+	notToBeInstanceOf(type) {
+		if (this.value instanceof type) {
+			throw new Exception({ message: `${this.value} is instance of ${type}`, code: 1062, status: 'not-instanceof' })
+		}
+		
+		return this;
+	}
+	doesNotMatch(pattern, flags) {
+		const r = new RegExp(pattern, flags)
+
+		if (r.test(this.value)) {
+			throw new Exception({ message: `${this.value} matches ${pattern}`, code: 1063, status: 'not-match' })
+		}
+		
+		return this;
 	}
 	toThrow(ex, shape = false, strict = false) {
 		if (!isFunction(this.value)) {
@@ -111,6 +437,8 @@ class Expect {
 		if (ok) {
 			throw new Exception({ message: `given function ran without throwing any errors.`, code: 1013, status: 'ran-to-completion' })
 		}
+
+		return this;
 	}
 	async toThrowAsync(ex, shape = false, strict = false) {
 		if (!isFunction(this.value)) {
@@ -154,6 +482,8 @@ class Expect {
 		if (ok) {
 			throw new Exception({ message: `given function ran without throwing any errors.`, code: 1013, status: 'ran-to-completion' })
 		}
+
+		return this;
 	}
 	notToThrow(ex, shape = false, strict = false) {
 		if (!isFunction(this.value)) {
@@ -200,6 +530,8 @@ class Expect {
 		if (ok) {
 			throw new Exception({ message: `given function threw an error.`, code: 1014, status: 'ran-to-error', innerException: error })
 		}
+
+		return this;
 	}
 	async notToThrowAsync(ex, shape = false, strict = false) {
 		if (!isFunction(this.value)) {
@@ -246,30 +578,40 @@ class Expect {
 		if (ok) {
 			throw new Exception({ message: `given function threw an error.`, code: 1014, status: 'ran-to-error', innerException: error })
 		}
+
+		return this;
 	}
 	toBeTruthy() {
 		if (this.value) {
 		} else {
 			throw new Exception({ message: `${this.value} is not truthy`, code: 1015, status: 'not-truthy' })
 		}
+
+		return this;
 	}
 	toBeFalsy() {
 		if (!this.value) {
 		} else {
 			throw new Exception({ message: `${this.value} is not falsy`, code: 1016, status: 'not-falsy' })
 		}
+
+		return this;
 	}
 	toBeNaN() {
 		if (isNaN(this.value)) {
 		} else {
 			throw new Exception({ message: `${this.value} is not NaN`, code: 1017, status: 'not-nan' })
 		}
+
+		return this;
 	}
 	notToBeNaN() {
 		if (!isNaN(this.value)) {
 		} else {
 			throw new Exception({ message: `${this.value} is NaN`, code: 1023, status: 'is-nan' })
 		}
+
+		return this;
 	}
 }
 

package/package.json

@@ -1,12 +1,9 @@
 {
   "name": "@locustjs/test",
-  "version": "1.1.7",
+  "version": "1.2.0",
   "description": "This library provides a simple test runner.",
   "main": "index.cjs.js",
   "module": "index.esm.js",
-  "scripts": {
-    "build": "babel index.esm.js -o index.cjs.js"
-  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ironcodev/locustjs-test.git"
@@ -27,6 +24,11 @@
   },
   "devDependencies": {
     "@babel/cli": "^7.22.6",
-    "@babel/core": "^7.22.8"
+    "@babel/core": "^7.22.8",
+    "esm": "^3.2.25"
+  },
+  "scripts": {
+    "build": "babel index.esm.js -o index.cjs.js",
+    "test": "node -r esm ./tests/index.js"
   }
-}
+}

package/tests/index.js

@@ -0,0 +1,112 @@
+import TestRunner from "../index.esm.js";
+
+class Foo {}
+class Bar extends Foo {}
+class Buz {}
+
+const tests = [
+  [
+    "Test 1: number",
+    function (expect) {
+      const n = 10;
+
+      expect(n)
+        .toBeDefined()
+        .toBeBasicType()
+        .toBePrimitive()
+        .toBeNumber()
+        .toBeNumeric()
+        .toBeGt(8)
+        .toBeGte(10)
+        .toBeLt(12)
+        .toBeLte(10)
+        .toBeBetween(5, 15)
+        .notToBeBetween(12, 20)
+        .toBeOfType("number");
+    },
+  ],
+  [
+    "Test 2: string",
+    function (expect) {
+      const n = "10";
+
+      expect(n)
+        .toBeDefined()
+        .notToBeNumber()
+        .toBeNumeric()
+        .toBeOfType("string")
+        .toBeString()
+        .toBeSomeString();
+    },
+  ],
+  [
+    "Test 3: empty array",
+    function (expect) {
+      const n = [];
+
+      expect(n)
+        .toBeDefined()
+        .toBeArray()
+        .toBeEmptyArray();
+    },
+  ],
+  [
+    "Test 4: array",
+    function (expect) {
+      const n = [10];
+
+      expect(n)
+        .toBeDefined()
+        .toBeArray()
+        .toBeSomeArray();
+    },
+  ],
+  [
+    "Test 3: empty object",
+    function (expect) {
+      const n = {};
+
+      expect(n)
+        .toBeDefined()
+        .notToBeBasicType()
+        .notToBePrimitive()
+        .notToBeNull()
+        .toBeObject()
+        .notToBeSomeObject();
+    },
+  ],
+  [
+    "Test 4: object",
+    function (expect) {
+      const n = {a:10};
+
+      expect(n)
+        .toBeDefined()
+        .notToBeBasicType()
+        .notToBePrimitive()
+        .notToBeNull()
+        .toBeObject()
+        .toBeSomeObject();
+    },
+  ],
+  [
+    "Test 4: class",
+    function (expect) {
+      const x = new Bar();
+
+      expect(x)
+        .toBeDefined()
+        .toBeObject()
+        .notToBeSomeObject()
+        .toBeInstanceOf(Bar)
+        .toBeInstanceOf(Foo)
+        .notToBeInstanceOf(Buz);
+    },
+  ]
+];
+
+const runner = new TestRunner();
+
+runner.run(tests).then((result) => {
+  runner.report(result.failed > 0);
+});