ts-data-forge 5.0.1 → 5.1.1

package/src/guard/is-type.test.mts

@@ -20,19 +20,24 @@ import {
 
 describe(isUndefined, () => {
   test('should return true for undefined', () => {
-    expect(isUndefined(undefined)).toBe(true);
+    assert.isTrue(isUndefined(undefined));
   });
 
   test('should return false for non-undefined values', () => {
-    expect(isUndefined(null)).toBe(false);
-    expect(isUndefined(0)).toBe(false);
-    expect(isUndefined('')).toBe(false);
-    expect(isUndefined(false)).toBe(false);
-    expect(isUndefined({})).toBe(false);
+    assert.isFalse(isUndefined(null));
+
+    assert.isFalse(isUndefined(0));
+
+    assert.isFalse(isUndefined(''));
+
+    assert.isFalse(isUndefined(false));
+
+    assert.isFalse(isUndefined({}));
   });
 
   test('should act as a type guard', () => {
     const value: string | undefined = undefined;
+
     if (isUndefined(value)) {
       expectType<typeof value, undefined>('=');
     }
@@ -41,18 +46,22 @@ describe(isUndefined, () => {
 
 describe(isNotUndefined, () => {
   test('should return false for undefined', () => {
-    expect(isNotUndefined(undefined)).toBe(false);
+    assert.isFalse(isNotUndefined(undefined));
   });
 
   test('should return true for non-undefined values', () => {
-    expect(isNotUndefined(null)).toBe(true);
-    expect(isNotUndefined(0)).toBe(true);
-    expect(isNotUndefined('')).toBe(true);
-    expect(isNotUndefined(false)).toBe(true);
+    assert.isTrue(isNotUndefined(null));
+
+    assert.isTrue(isNotUndefined(0));
+
+    assert.isTrue(isNotUndefined(''));
+
+    assert.isTrue(isNotUndefined(false));
   });
 
   test('should narrow types correctly', () => {
     const value: string | undefined = 'test';
+
     if (isNotUndefined(value)) {
       expectType<typeof value, string>('=');
     }
@@ -61,19 +70,24 @@ describe(isNotUndefined, () => {
 
 describe(isNull, () => {
   test('should return true for null', () => {
-    expect(isNull(null)).toBe(true);
+    assert.isTrue(isNull(null));
   });
 
   test('should return false for non-null values', () => {
-    expect(isNull(undefined)).toBe(false);
-    expect(isNull(0)).toBe(false);
-    expect(isNull('')).toBe(false);
-    expect(isNull(false)).toBe(false);
-    expect(isNull({})).toBe(false);
+    assert.isFalse(isNull(undefined));
+
+    assert.isFalse(isNull(0));
+
+    assert.isFalse(isNull(''));
+
+    assert.isFalse(isNull(false));
+
+    assert.isFalse(isNull({}));
   });
 
   test('should act as a type guard', () => {
     const value: string | null = null;
+
     if (isNull(value)) {
       expectType<typeof value, null>('=');
     }
@@ -82,17 +96,20 @@ describe(isNull, () => {
 
 describe(isNotNull, () => {
   test('should return false for null', () => {
-    expect(isNotNull(null)).toBe(false);
+    assert.isFalse(isNotNull(null));
   });
 
   test('should return true for non-null values', () => {
-    expect(isNotNull(undefined)).toBe(true);
-    expect(isNotNull(0)).toBe(true);
-    expect(isNotNull('')).toBe(true);
+    assert.isTrue(isNotNull(undefined));
+
+    assert.isTrue(isNotNull(0));
+
+    assert.isTrue(isNotNull(''));
   });
 
   test('should narrow types correctly', () => {
     const value: string | null = 'test';
+
     if (isNotNull(value)) {
       expectType<typeof value, string>('=');
     }
@@ -101,23 +118,31 @@ describe(isNotNull, () => {
 
 describe(isString, () => {
   test('should return true for strings', () => {
-    expect(isString('')).toBe(true);
-    expect(isString('hello')).toBe(true);
-    expect(isString('123')).toBe(true);
-    expect(isString(`template`)).toBe(true);
+    assert.isTrue(isString(''));
+
+    assert.isTrue(isString('hello'));
+
+    assert.isTrue(isString('123'));
+
+    assert.isTrue(isString(`template`));
   });
 
   test('should return false for non-strings', () => {
-    expect(isString(123)).toBe(false);
-    expect(isString(true)).toBe(false);
-    expect(isString(null)).toBe(false);
-    expect(isString(undefined)).toBe(false);
+    assert.isFalse(isString(123));
+
+    assert.isFalse(isString(true));
+
+    assert.isFalse(isString(null));
+
+    assert.isFalse(isString(undefined));
+
     // eslint-disable-next-line unicorn/new-for-builtins
-    expect(isString(new String('hello'))).toBe(false);
+    assert.isFalse(isString(new String('hello')));
   });
 
   test('should act as a type guard', () => {
     const value: unknown = 'test';
+
     if (isString(value)) {
       expectType<typeof value, string>('=');
 
@@ -128,25 +153,35 @@ describe(isString, () => {
 
 describe(isNumber, () => {
   test('should return true for numbers', () => {
-    expect(isNumber(0)).toBe(true);
-    expect(isNumber(42)).toBe(true);
-    expect(isNumber(-3.14)).toBe(true);
-    expect(isNumber(Number.NaN)).toBe(true);
-    expect(isNumber(Number.POSITIVE_INFINITY)).toBe(true);
-    expect(isNumber(Number.NEGATIVE_INFINITY)).toBe(true);
+    assert.isTrue(isNumber(0));
+
+    assert.isTrue(isNumber(42));
+
+    assert.isTrue(isNumber(-3.14));
+
+    assert.isTrue(isNumber(Number.NaN));
+
+    assert.isTrue(isNumber(Number.POSITIVE_INFINITY));
+
+    assert.isTrue(isNumber(Number.NEGATIVE_INFINITY));
   });
 
   test('should return false for non-numbers', () => {
-    expect(isNumber('123')).toBe(false);
-    expect(isNumber(true)).toBe(false);
-    expect(isNumber(null)).toBe(false);
-    expect(isNumber(123n)).toBe(false);
+    assert.isFalse(isNumber('123'));
+
+    assert.isFalse(isNumber(true));
+
+    assert.isFalse(isNumber(null));
+
+    assert.isFalse(isNumber(123n));
+
     // eslint-disable-next-line unicorn/new-for-builtins
-    expect(isNumber(new Number(42))).toBe(false);
+    assert.isFalse(isNumber(new Number(42)));
   });
 
   test('should act as a type guard', () => {
     const value: unknown = 42;
+
     if (isNumber(value)) {
       expectType<typeof value, number>('=');
 
@@ -157,20 +192,26 @@ describe(isNumber, () => {
 
 describe(isBigint, () => {
   test('should return true for bigints', () => {
-    expect(isBigint(0n)).toBe(true);
-    expect(isBigint(123n)).toBe(true);
-    expect(isBigint(-456n)).toBe(true);
+    assert.isTrue(isBigint(0n));
+
+    assert.isTrue(isBigint(123n));
+
+    assert.isTrue(isBigint(-456n));
   });
 
   test('should return false for non-bigints', () => {
-    expect(isBigint(123)).toBe(false);
-    expect(isBigint('123')).toBe(false);
-    expect(isBigint(true)).toBe(false);
-    expect(isBigint(null)).toBe(false);
+    assert.isFalse(isBigint(123));
+
+    assert.isFalse(isBigint('123'));
+
+    assert.isFalse(isBigint(true));
+
+    assert.isFalse(isBigint(null));
   });
 
   test('should act as a type guard', () => {
     const value: unknown = 123n;
+
     if (isBigint(value)) {
       expectType<typeof value, bigint>('=');
 
@@ -181,44 +222,55 @@ describe(isBigint, () => {
 
 describe(isBoolean, () => {
   test('should return true for booleans', () => {
-    expect(isBoolean(true)).toBe(true);
-    expect(isBoolean(false)).toBe(true);
+    assert.isTrue(isBoolean(true));
+
+    assert.isTrue(isBoolean(false));
   });
 
   test('should return false for non-booleans', () => {
-    expect(isBoolean(1)).toBe(false);
-    expect(isBoolean(0)).toBe(false);
-    expect(isBoolean('true')).toBe(false);
-    expect(isBoolean(null)).toBe(false);
+    assert.isFalse(isBoolean(1));
+
+    assert.isFalse(isBoolean(0));
+
+    assert.isFalse(isBoolean('true'));
+
+    assert.isFalse(isBoolean(null));
+
     // eslint-disable-next-line unicorn/new-for-builtins
-    expect(isBoolean(new Boolean(true))).toBe(false);
+    assert.isFalse(isBoolean(new Boolean(true)));
   });
 
   test('should act as a type guard', () => {
     const value: unknown = true;
+
     if (isBoolean(value)) {
       expectType<typeof value, boolean>('=');
 
-      expect(!value).toBe(false);
+      assert.isTrue(value);
     }
   });
 });
 
 describe(isSymbol, () => {
   test('should return true for symbols', () => {
-    expect(isSymbol(Symbol())).toBe(true);
-    expect(isSymbol(Symbol('test'))).toBe(true);
-    expect(isSymbol(Symbol.iterator)).toBe(true);
+    assert.isTrue(isSymbol(Symbol()));
+
+    assert.isTrue(isSymbol(Symbol('test')));
+
+    assert.isTrue(isSymbol(Symbol.iterator));
   });
 
   test('should return false for non-symbols', () => {
-    expect(isSymbol('symbol')).toBe(false);
-    expect(isSymbol(123)).toBe(false);
-    expect(isSymbol(null)).toBe(false);
+    assert.isFalse(isSymbol('symbol'));
+
+    assert.isFalse(isSymbol(123));
+
+    assert.isFalse(isSymbol(null));
   });
 
   test('should act as a type guard', () => {
     const value: unknown = Symbol('test');
+
     if (isSymbol(value)) {
       expectType<typeof value, symbol>('=');
 
@@ -229,86 +281,117 @@ describe(isSymbol, () => {
 
 describe(isNotBoolean, () => {
   test('should return false for boolean values', () => {
-    expect(isNotBoolean(true)).toBe(false);
-    expect(isNotBoolean(false)).toBe(false);
+    assert.isFalse(isNotBoolean(true));
+
+    assert.isFalse(isNotBoolean(false));
   });
 
   test('should return true for non-boolean values', () => {
-    expect(isNotBoolean(0)).toBe(true);
-    expect(isNotBoolean(1)).toBe(true);
-    expect(isNotBoolean('true')).toBe(true);
-    expect(isNotBoolean('false')).toBe(true);
-    expect(isNotBoolean(null)).toBe(true);
-    expect(isNotBoolean(undefined)).toBe(true);
-    expect(isNotBoolean({})).toBe(true);
-    expect(isNotBoolean([])).toBe(true);
+    assert.isTrue(isNotBoolean(0));
+
+    assert.isTrue(isNotBoolean(1));
+
+    assert.isTrue(isNotBoolean('true'));
+
+    assert.isTrue(isNotBoolean('false'));
+
+    assert.isTrue(isNotBoolean(null));
+
+    assert.isTrue(isNotBoolean(undefined));
+
+    assert.isTrue(isNotBoolean({}));
+
+    assert.isTrue(isNotBoolean([]));
   });
 
   test('should act as a type guard', () => {
     const value: string | number | boolean = 'test';
+
     if (isNotBoolean(value)) {
       expectType<typeof value, string | number>('<=');
 
       // Should not have boolean methods
-      expect(typeof value === 'string' || typeof value === 'number').toBe(true);
+      assert.isTrue(typeof value === 'string' || typeof value === 'number');
     }
   });
 });
 
 describe(isNotNumber, () => {
   test('should return false for number values', () => {
-    expect(isNotNumber(0)).toBe(false);
-    expect(isNotNumber(42)).toBe(false);
-    expect(isNotNumber(-3.14)).toBe(false);
-    expect(isNotNumber(Number.NaN)).toBe(false);
-    expect(isNotNumber(Number.POSITIVE_INFINITY)).toBe(false);
-    expect(isNotNumber(Number.NEGATIVE_INFINITY)).toBe(false);
+    assert.isFalse(isNotNumber(0));
+
+    assert.isFalse(isNotNumber(42));
+
+    assert.isFalse(isNotNumber(-3.14));
+
+    assert.isFalse(isNotNumber(Number.NaN));
+
+    assert.isFalse(isNotNumber(Number.POSITIVE_INFINITY));
+
+    assert.isFalse(isNotNumber(Number.NEGATIVE_INFINITY));
   });
 
   test('should return true for non-number values', () => {
-    expect(isNotNumber('123')).toBe(true);
-    expect(isNotNumber(true)).toBe(true);
-    expect(isNotNumber(false)).toBe(true);
-    expect(isNotNumber(null)).toBe(true);
-    expect(isNotNumber(undefined)).toBe(true);
-    expect(isNotNumber(123n)).toBe(true);
-    expect(isNotNumber({})).toBe(true);
-    expect(isNotNumber([])).toBe(true);
-    expect(isNotNumber(Symbol('test'))).toBe(true);
+    assert.isTrue(isNotNumber('123'));
+
+    assert.isTrue(isNotNumber(true));
+
+    assert.isTrue(isNotNumber(false));
+
+    assert.isTrue(isNotNumber(null));
+
+    assert.isTrue(isNotNumber(undefined));
+
+    assert.isTrue(isNotNumber(123n));
+
+    assert.isTrue(isNotNumber({}));
+
+    assert.isTrue(isNotNumber([]));
+
+    assert.isTrue(isNotNumber(Symbol('test')));
   });
 
   test('should act as a type guard', () => {
     const value: string | number | boolean = 'test';
+
     if (isNotNumber(value)) {
       expectType<typeof value, string | boolean>('<=');
 
-      expect(typeof value === 'string' || typeof value === 'boolean').toBe(
-        true,
-      );
+      assert.isTrue(typeof value === 'string' || typeof value === 'boolean');
     }
   });
 });
 
 describe(isNotBigint, () => {
   test('should return false for bigint values', () => {
-    expect(isNotBigint(0n)).toBe(false);
-    expect(isNotBigint(123n)).toBe(false);
-    expect(isNotBigint(-456n)).toBe(false);
+    assert.isFalse(isNotBigint(0n));
+
+    assert.isFalse(isNotBigint(123n));
+
+    assert.isFalse(isNotBigint(-456n));
   });
 
   test('should return true for non-bigint values', () => {
-    expect(isNotBigint(123)).toBe(true);
-    expect(isNotBigint('123')).toBe(true);
-    expect(isNotBigint(true)).toBe(true);
-    expect(isNotBigint(false)).toBe(true);
-    expect(isNotBigint(null)).toBe(true);
-    expect(isNotBigint(undefined)).toBe(true);
-    expect(isNotBigint({})).toBe(true);
-    expect(isNotBigint(Symbol('test'))).toBe(true);
+    assert.isTrue(isNotBigint(123));
+
+    assert.isTrue(isNotBigint('123'));
+
+    assert.isTrue(isNotBigint(true));
+
+    assert.isTrue(isNotBigint(false));
+
+    assert.isTrue(isNotBigint(null));
+
+    assert.isTrue(isNotBigint(undefined));
+
+    assert.isTrue(isNotBigint({}));
+
+    assert.isTrue(isNotBigint(Symbol('test')));
   });
 
   test('should act as a type guard', () => {
     const value: number | bigint = 123;
+
     if (isNotBigint(value)) {
       expectType<typeof value, number>('<=');
 
@@ -319,84 +402,114 @@ describe(isNotBigint, () => {
 
 describe(isNotString, () => {
   test('should return false for string values', () => {
-    expect(isNotString('')).toBe(false);
-    expect(isNotString('hello')).toBe(false);
-    expect(isNotString('123')).toBe(false);
-    expect(isNotString(`template`)).toBe(false);
+    assert.isFalse(isNotString(''));
+
+    assert.isFalse(isNotString('hello'));
+
+    assert.isFalse(isNotString('123'));
+
+    assert.isFalse(isNotString(`template`));
   });
 
   test('should return true for non-string values', () => {
-    expect(isNotString(123)).toBe(true);
-    expect(isNotString(true)).toBe(true);
-    expect(isNotString(false)).toBe(true);
-    expect(isNotString(null)).toBe(true);
-    expect(isNotString(undefined)).toBe(true);
-    expect(isNotString({})).toBe(true);
-    expect(isNotString([])).toBe(true);
-    expect(isNotString(Symbol('test'))).toBe(true);
-    expect(isNotString(123n)).toBe(true);
+    assert.isTrue(isNotString(123));
+
+    assert.isTrue(isNotString(true));
+
+    assert.isTrue(isNotString(false));
+
+    assert.isTrue(isNotString(null));
+
+    assert.isTrue(isNotString(undefined));
+
+    assert.isTrue(isNotString({}));
+
+    assert.isTrue(isNotString([]));
+
+    assert.isTrue(isNotString(Symbol('test')));
+
+    assert.isTrue(isNotString(123n));
   });
 
   test('should act as a type guard', () => {
     const value: string | number | boolean = 42;
+
     if (isNotString(value)) {
       expectType<typeof value, number | boolean>('<=');
 
-      expect(typeof value === 'number' || typeof value === 'boolean').toBe(
-        true,
-      );
+      assert.isTrue(typeof value === 'number' || typeof value === 'boolean');
     }
   });
 });
 
 describe(isNotSymbol, () => {
   test('should return false for symbol values', () => {
-    expect(isNotSymbol(Symbol())).toBe(false);
-    expect(isNotSymbol(Symbol('test'))).toBe(false);
-    expect(isNotSymbol(Symbol.iterator)).toBe(false);
+    assert.isFalse(isNotSymbol(Symbol()));
+
+    assert.isFalse(isNotSymbol(Symbol('test')));
+
+    assert.isFalse(isNotSymbol(Symbol.iterator));
   });
 
   test('should return true for non-symbol values', () => {
-    expect(isNotSymbol('symbol')).toBe(true);
-    expect(isNotSymbol(123)).toBe(true);
-    expect(isNotSymbol(true)).toBe(true);
-    expect(isNotSymbol(false)).toBe(true);
-    expect(isNotSymbol(null)).toBe(true);
-    expect(isNotSymbol(undefined)).toBe(true);
-    expect(isNotSymbol({})).toBe(true);
-    expect(isNotSymbol([])).toBe(true);
-    expect(isNotSymbol(123n)).toBe(true);
+    assert.isTrue(isNotSymbol('symbol'));
+
+    assert.isTrue(isNotSymbol(123));
+
+    assert.isTrue(isNotSymbol(true));
+
+    assert.isTrue(isNotSymbol(false));
+
+    assert.isTrue(isNotSymbol(null));
+
+    assert.isTrue(isNotSymbol(undefined));
+
+    assert.isTrue(isNotSymbol({}));
+
+    assert.isTrue(isNotSymbol([]));
+
+    assert.isTrue(isNotSymbol(123n));
   });
 
   test('should act as a type guard', () => {
     const value: string | number | symbol = 'test';
+
     if (isNotSymbol(value)) {
       expectType<typeof value, string | number>('<=');
 
-      expect(typeof value === 'string' || typeof value === 'number').toBe(true);
+      assert.isTrue(typeof value === 'string' || typeof value === 'number');
     }
   });
 });
 
 describe(isNullish, () => {
   test('should return true for null and undefined', () => {
-    expect(isNullish(null)).toBe(true);
-    expect(isNullish(undefined)).toBe(true);
+    assert.isTrue(isNullish(null));
+
+    assert.isTrue(isNullish(undefined));
   });
 
   test('should return false for non-nullish values', () => {
-    expect(isNullish(0)).toBe(false);
-    expect(isNullish(false)).toBe(false);
-    expect(isNullish('')).toBe(false);
-    expect(isNullish('null')).toBe(false);
-    expect(isNullish('undefined')).toBe(false);
-    expect(isNullish({})).toBe(false);
-    expect(isNullish([])).toBe(false);
-    expect(isNullish(Number.NaN)).toBe(false);
+    assert.isFalse(isNullish(0));
+
+    assert.isFalse(isNullish(false));
+
+    assert.isFalse(isNullish(''));
+
+    assert.isFalse(isNullish('null'));
+
+    assert.isFalse(isNullish('undefined'));
+
+    assert.isFalse(isNullish({}));
+
+    assert.isFalse(isNullish([]));
+
+    assert.isFalse(isNullish(Number.NaN));
   });
 
   test('should act as a type guard', () => {
     const value: string | null | undefined = null;
+
     if (isNullish(value)) {
       expectType<typeof value, null | undefined>('<=');
 
@@ -407,32 +520,44 @@ describe(isNullish, () => {
 
   test('should handle edge cases', () => {
     // Test that it uses loose equality (==)
-    expect(isNullish(null)).toBe(true);
-    expect(isNullish(undefined)).toBe(true);
+    assert.isTrue(isNullish(null));
+
+    assert.isTrue(isNullish(undefined));
   });
 });
 
 describe(isNonNullish, () => {
   test('should return false for null and undefined', () => {
-    expect(isNonNullish(null)).toBe(false);
-    expect(isNonNullish(undefined)).toBe(false);
+    assert.isFalse(isNonNullish(null));
+
+    assert.isFalse(isNonNullish(undefined));
   });
 
   test('should return true for non-nullish values', () => {
-    expect(isNonNullish(0)).toBe(true);
-    expect(isNonNullish(false)).toBe(true);
-    expect(isNonNullish('')).toBe(true);
-    expect(isNonNullish('null')).toBe(true);
-    expect(isNonNullish('undefined')).toBe(true);
-    expect(isNonNullish({})).toBe(true);
-    expect(isNonNullish([])).toBe(true);
-    expect(isNonNullish(Number.NaN)).toBe(true);
-    expect(isNonNullish(Symbol('test'))).toBe(true);
-    expect(isNonNullish(123n)).toBe(true);
+    assert.isTrue(isNonNullish(0));
+
+    assert.isTrue(isNonNullish(false));
+
+    assert.isTrue(isNonNullish(''));
+
+    assert.isTrue(isNonNullish('null'));
+
+    assert.isTrue(isNonNullish('undefined'));
+
+    assert.isTrue(isNonNullish({}));
+
+    assert.isTrue(isNonNullish([]));
+
+    assert.isTrue(isNonNullish(Number.NaN));
+
+    assert.isTrue(isNonNullish(Symbol('test')));
+
+    assert.isTrue(isNonNullish(123n));
   });
 
   test('should act as a type guard', () => {
     const value: string | null | undefined = 'test';
+
     if (isNonNullish(value)) {
       expectType<typeof value, string>('<=');
 
@@ -450,6 +575,7 @@ describe(isNonNullish, () => {
     ];
 
     const definedItems = items.filter(isNonNullish);
+
     expectType<typeof definedItems, string[]>('<=');
 
     expect(definedItems).toHaveLength(3);
@@ -459,6 +585,7 @@ describe(isNonNullish, () => {
 
   test('should handle complex union types', () => {
     type ComplexType = string | number | boolean | null | undefined;
+
     const value: ComplexType = 42;
 
     if (isNonNullish(value)) {
@@ -494,12 +621,15 @@ describe('type guard behavior in complex scenarios', () => {
     ];
 
     const nonNullish = mixed.filter(isNonNullish);
+
     expectType<typeof nonNullish, (string | number | boolean)[]>('<=');
 
     const nonBooleans = nonNullish.filter(isNotBoolean);
+
     expectType<typeof nonBooleans, (string | number)[]>('<=');
 
     const strings = nonBooleans.filter(isNotNumber);
+
     expectType<typeof strings, string[]>('<=');
 
     assert.deepStrictEqual(strings, ['hello', 'world']);