ts-data-forge 4.1.0 → 5.0.0

package/src/functional/result.test.mts

@@ -3,20 +3,24 @@ import { Optional } from './optional/index.mjs';
 import { pipe } from './pipe.mjs';
 import { Result } from './result/index.mjs';
 
-describe('Result', () => {
+describe('Result test', () => {
   describe('ok', () => {
     test('creates Ok result', () => {
       const result = Result.ok(42);
+
       expect(Result.isOk(result)).toBe(true);
       expect(Result.isErr(result)).toBe(false);
       expect(result.value).toBe(42);
+
       expectType<typeof result, Result<number, never>>('<=');
     });
 
     test('creates Ok result with string', () => {
       const result = Result.ok('success');
+
       expect(Result.isOk(result)).toBe(true);
       expect(result.value).toBe('success');
+
       expectType<typeof result, Result<string, never>>('<=');
     });
   });
@@ -24,16 +28,20 @@ describe('Result', () => {
   describe('err', () => {
     test('creates Err result', () => {
       const result = Result.err('error message');
+
       expect(Result.isErr(result)).toBe(true);
       expect(Result.isOk(result)).toBe(false);
       expect(result.value).toBe('error message');
+
       expectType<typeof result, Result<never, string>>('<=');
     });
 
     test('creates Err result with number', () => {
       const result = Result.err(404);
+
       expect(Result.isErr(result)).toBe(true);
       expect(result.value).toBe(404);
+
       expectType<typeof result, Result<never, number>>('<=');
     });
   });
@@ -43,12 +51,14 @@ describe('Result', () => {
       const result: Result<number, string> = Result.ok(42);
       if (Result.isOk(result)) {
         expectType<typeof result, Ok<number>>('<=');
+
         expect(result.value).toBe(42);
       }
     });
 
     test('returns false for Err results', () => {
       const result: Result<number, string> = Result.err('error');
+
       expect(Result.isOk(result)).toBe(false);
     });
   });
@@ -58,12 +68,14 @@ describe('Result', () => {
       const result: Result<number, string> = Result.err('error');
       if (Result.isErr(result)) {
         expectType<typeof result, Err<string>>('<=');
+
         expect(result.value).toBe('error');
       }
     });
 
     test('returns false for Ok results', () => {
       const result: Result<number, string> = Result.ok(42);
+
       expect(Result.isErr(result)).toBe(false);
     });
   });
@@ -71,11 +83,13 @@ describe('Result', () => {
   describe('isResult', () => {
     test('recognizes Ok results', () => {
       const result = Result.ok(42);
+
       expect(Result.isResult(result)).toBe(true);
     });
 
     test('recognizes Err results', () => {
       const result = Result.err('error');
+
       expect(Result.isResult(result)).toBe(true);
     });
 
@@ -93,7 +107,9 @@ describe('Result', () => {
     test('maps Ok result', () => {
       const result = Result.ok(5);
       const mapped = Result.map(result, (x) => x * 2);
+
       expect(Result.isOk(mapped)).toBe(true);
+
       if (Result.isOk(mapped)) {
         expect(mapped.value).toBe(10);
       }
@@ -103,7 +119,9 @@ describe('Result', () => {
     test('preserves Err result', () => {
       const result: Result<number, string> = Result.err('error');
       const mapped = Result.map(result, (x) => x * 2);
+
       expect(Result.isErr(mapped)).toBe(true);
+
       if (Result.isErr(mapped)) {
         expect(mapped.value).toBe('error');
       }
@@ -117,13 +135,16 @@ describe('Result', () => {
       const mapped = doubler(okResult);
 
       expect(Result.isOk(mapped)).toBe(true);
+
       if (Result.isOk(mapped)) {
         expect(mapped.value).toBe(10);
       }
 
       const errResult: Result<number, string> = Result.err('error');
       const mappedErr = doubler(errResult);
+
       expect(Result.isErr(mappedErr)).toBe(true);
+
       if (Result.isErr(mappedErr)) {
         expect(mappedErr.value).toBe('error');
       }
@@ -136,6 +157,7 @@ describe('Result', () => {
       const result = pipe(Result.ok(5)).map(doubler).map(toStringFn).value;
 
       expect(Result.isOk(result)).toBe(true);
+
       if (Result.isOk(result)) {
         expect(result.value).toBe('10');
       }
@@ -146,7 +168,9 @@ describe('Result', () => {
     test('maps Err result', () => {
       const result: Result<number, string> = Result.err('error');
       const mapped = Result.mapErr(result, (e) => e.toUpperCase());
+
       expect(Result.isErr(mapped)).toBe(true);
+
       if (Result.isErr(mapped)) {
         expect(mapped.value).toBe('ERROR');
       }
@@ -156,7 +180,9 @@ describe('Result', () => {
     test('preserves Ok result', () => {
       const result: Result<number, string> = Result.ok(42);
       const mapped = Result.mapErr(result, (e: string) => e.toUpperCase());
+
       expect(Result.isOk(mapped)).toBe(true);
+
       if (Result.isOk(mapped)) {
         expect(mapped.value).toBe(42);
       }
@@ -168,14 +194,18 @@ describe('Result', () => {
 
       const errResult: Result<number, string> = Result.err('error');
       const mapped = errorUppercase(errResult);
+
       expect(Result.isErr(mapped)).toBe(true);
+
       if (Result.isErr(mapped)) {
         expect(mapped.value).toBe('ERROR');
       }
 
       const okResult: Result<number, string> = Result.ok(42);
       const mappedOk = errorUppercase(okResult);
+
       expect(Result.isOk(mappedOk)).toBe(true);
+
       if (Result.isOk(mappedOk)) {
         expect(mappedOk.value).toBe(42);
       }
@@ -190,6 +220,7 @@ describe('Result', () => {
         .map(errorPrefix).value;
 
       expect(Result.isErr(result)).toBe(true);
+
       if (Result.isErr(result)) {
         expect(result.value).toBe('ERROR: FAILED');
       }
@@ -200,12 +231,15 @@ describe('Result', () => {
     test('unwraps Ok result', () => {
       const result = Result.ok(42);
       const value = Result.unwrapThrow(result);
+
       expect(value).toBe(42);
+
       expectType<typeof value, number>('<=');
     });
 
     test('throws on Err result', () => {
       const result = Result.err('error message');
+
       expect(() => Result.unwrapThrow(result)).toThrow('error message');
     });
   });
@@ -214,14 +248,18 @@ describe('Result', () => {
     test('unwraps Ok result', () => {
       const result = Result.ok(42);
       const value = Result.unwrapOkOr(result, 0);
+
       expect(value).toBe(42);
+
       expectType<typeof value, number>('<=');
     });
 
     test('returns default for Err result', () => {
       const result: Result<number, string> = Result.err('error');
       const value = Result.unwrapOkOr(result, 0);
+
       expect(value).toBe(0);
+
       expectType<typeof value, number>('<=');
     });
 
@@ -230,10 +268,12 @@ describe('Result', () => {
 
       const okResult = Result.ok(100);
       const successValue = unwrapWithDefault(okResult);
+
       expect(successValue).toBe(100);
 
       const errResult: Result<number, string> = Result.err('failed');
       const defaultValue = unwrapWithDefault(errResult);
+
       expect(defaultValue).toBe(42);
     });
 
@@ -241,11 +281,13 @@ describe('Result', () => {
       const unwrapWithDefault = Result.unwrapOkOr(0);
 
       const successResult = pipe(Result.ok(200)).map(unwrapWithDefault).value;
+
       expect(successResult).toBe(200);
 
       const errorResult = pipe(Result.err('computation failed')).map(
         unwrapWithDefault,
       ).value;
+
       expect(errorResult).toBe(0);
     });
   });
@@ -254,7 +296,9 @@ describe('Result', () => {
     test('unwraps Err result', () => {
       const result: Result<number, string> = Result.err('error');
       const value = Result.unwrapErr(result);
+
       expect(value).toBe('error');
+
       expectType<typeof value, string | undefined>('<=');
     });
 
@@ -263,7 +307,9 @@ describe('Result', () => {
 
       // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
       const value = Result.unwrapErr(result);
+
       expect(value).toBeUndefined();
+
       expectType<typeof value, string | undefined>('<=');
     });
   });
@@ -276,7 +322,9 @@ describe('Result', () => {
         (x) => x * 2,
         () => 0,
       );
+
       expect(Result.isOk(folded)).toBe(true);
+
       if (Result.isOk(folded)) {
         expect(folded.value).toBe(84);
       }
@@ -290,7 +338,9 @@ describe('Result', () => {
         (x) => x * 2,
         (e) => e.length,
       );
+
       expect(Result.isErr(folded)).toBe(true);
+
       if (Result.isErr(folded)) {
         expect(folded.value).toBe(5); // length of 'error'
       }
@@ -305,14 +355,18 @@ describe('Result', () => {
 
       const okResult = Result.ok(42);
       const foldedOk = folder(okResult);
+
       expect(Result.isOk(foldedOk)).toBe(true);
+
       if (Result.isOk(foldedOk)) {
         expect(foldedOk.value).toBe(84);
       }
 
       const errResult: Result<number, string> = Result.err('error');
       const foldedErr = folder(errResult);
+
       expect(Result.isErr(foldedErr)).toBe(true);
+
       if (Result.isErr(foldedErr)) {
         expect(foldedErr.value).toBe(5);
       }
@@ -327,6 +381,7 @@ describe('Result', () => {
       const result = pipe(Result.ok(21)).map(folder).value;
 
       expect(Result.isOk(result)).toBe(true);
+
       if (Result.isOk(result)) {
         expect(result.value).toBe(42);
       }
@@ -334,6 +389,7 @@ describe('Result', () => {
       const errorResult = pipe(Result.err('error')).map(folder).value;
 
       expect(Result.isErr(errorResult)).toBe(true);
+
       if (Result.isErr(errorResult)) {
         expect(errorResult.value).toBe(0);
       }
@@ -346,6 +402,7 @@ describe('Result', () => {
         Promise.resolve().then(() => 42);
 
       const result = await Result.fromPromise(asyncFn());
+
       expect(Result.isOk(result)).toBe(true);
       expect(Result.unwrapOk(result)).toBe(42);
     });
@@ -356,6 +413,7 @@ describe('Result', () => {
         Promise.reject(error).then(() => 42);
 
       const result = await Result.fromPromise(asyncFn());
+
       expect(Result.isErr(result)).toBe(true);
       expect(Result.unwrapErr(result)).toBe(error);
     });
@@ -365,6 +423,7 @@ describe('Result', () => {
       const result = await Result.fromPromise(stringPromise);
 
       expect(Result.unwrapOk(result)).toBe('hello');
+
       expectType<typeof result, Result<string, unknown>>('=');
     });
   });
@@ -378,9 +437,11 @@ describe('Result', () => {
             Result.ok(a / b);
 
       const result = Result.flatMap(Result.ok(10), (x) => divide(x, 2));
+
       expect(Result.unwrapOk(result)).toBe(5);
 
       const error = Result.flatMap(Result.ok(10), (x) => divide(x, 0));
+
       expect(Result.unwrapErr(error)).toBe('Division by zero');
     });
 
@@ -388,6 +449,7 @@ describe('Result', () => {
       const result = Result.flatMap(Result.err('initial error'), (_: never) =>
         Result.ok(42),
       );
+
       expect(Result.unwrapErr(result)).toBe('initial error');
     });
 
@@ -405,6 +467,7 @@ describe('Result', () => {
         Result.flatMap(parseNumber('100'), (x) => divide(x, 2)),
         (x) => Result.ok(x + 10),
       );
+
       expect(Result.unwrapOk(result)).toBe(60);
     });
 
@@ -419,20 +482,26 @@ describe('Result', () => {
 
       const okResult = Result.ok(10);
       const result = divideBy2(okResult);
+
       expect(Result.isOk(result)).toBe(true);
+
       if (Result.isOk(result)) {
         expect(result.value).toBe(5);
       }
 
       const divideByZero = Result.flatMap((x: number) => divide(x, 0));
       const errorResult = divideByZero(Result.ok(10));
+
       expect(Result.isErr(errorResult)).toBe(true);
+
       if (Result.isErr(errorResult)) {
         expect(errorResult.value).toBe('Division by zero');
       }
 
       const initialError = divideBy2(Result.err('initial error'));
+
       expect(Result.isErr(initialError)).toBe(true);
+
       if (Result.isErr(initialError)) {
         expect(initialError.value).toBe('initial error');
       }
@@ -453,6 +522,7 @@ describe('Result', () => {
       const result = pipe(Result.ok('42')).map(parser).map(doubler).value;
 
       expect(Result.isOk(result)).toBe(true);
+
       if (Result.isOk(result)) {
         expect(result.value).toBe(84);
       }
@@ -463,6 +533,7 @@ describe('Result', () => {
     test('should swap Ok to Err', () => {
       const okResult = Result.ok(42);
       const swapped = Result.swap(okResult);
+
       expect(Result.isErr(swapped)).toBe(true);
       expect(Result.unwrapErr(swapped)).toBe(42);
     });
@@ -470,6 +541,7 @@ describe('Result', () => {
     test('should swap Err to Ok', () => {
       const errResult = Result.err('error');
       const swapped = Result.swap(errResult);
+
       expect(Result.isOk(swapped)).toBe(true);
       expect(Result.unwrapOk(swapped)).toBe('error');
     });
@@ -479,6 +551,7 @@ describe('Result', () => {
     test('should convert Ok to Some-like', () => {
       const okResult = Result.ok(42);
       const optional = Result.toOptional(okResult);
+
       expect(Optional.isSome(optional)).toBe(true);
       expect(Optional.unwrapThrow(optional)).toBe(42);
     });
@@ -486,6 +559,7 @@ describe('Result', () => {
     test('should convert Err to None-like', () => {
       const errResult = Result.err('error');
       const optional = Result.toOptional(errResult);
+
       expect(Optional.isNone(optional)).toBe(true);
     });
   });
@@ -493,11 +567,13 @@ describe('Result', () => {
   describe('unwrapErrThrow', () => {
     test('should return error value for Err', () => {
       const result = Result.err('error message');
+
       expect(Result.unwrapErrThrow(result)).toBe('error message');
     });
 
     test('should throw for Ok', () => {
       const result = Result.ok(42);
+
       expect(() => Result.unwrapErrThrow(result)).toThrow(
         'Expected Err but got Ok: 42',
       );
@@ -505,6 +581,7 @@ describe('Result', () => {
 
     test('should use custom toString function', () => {
       const result = Result.ok({ id: 1, name: 'test' });
+
       expect(() =>
         Result.unwrapErrThrow(result, (obj) => `Object(id=${obj.id})`),
       ).toThrow('Expected Err but got Ok: Object(id=1)');
@@ -515,12 +592,14 @@ describe('Result', () => {
     test('should return error value for Err result', () => {
       const result = Result.err('error message');
       const value = Result.unwrapErrOr(result, 'default');
+
       expect(value).toBe('error message');
     });
 
     test('should return default value for Ok result', () => {
       const result = Result.ok(42);
       const value = Result.unwrapErrOr(result, 'default');
+
       expect(value).toBe('default');
     });
 
@@ -529,10 +608,12 @@ describe('Result', () => {
 
       const errResult: Result<number, string> = Result.err('failed');
       const errorValue = unwrapErrorWithDefault(errResult);
+
       expect(errorValue).toBe('failed');
 
       const okResult: Result<number, string> = Result.ok(42);
       const defaultValue = unwrapErrorWithDefault(okResult);
+
       expect(defaultValue).toBe('unknown error');
     });
 
@@ -542,11 +623,13 @@ describe('Result', () => {
       const errorResult = pipe(Result.err('network failure')).map(
         unwrapErrorWithDefault,
       ).value;
+
       expect(errorResult).toBe('network failure');
 
       const okResult = pipe(Result.ok('success')).map(
         unwrapErrorWithDefault,
       ).value;
+
       expect(okResult).toBe('unknown error');
     });
   });
@@ -555,11 +638,13 @@ describe('Result', () => {
     test('should return value for Ok result', () => {
       const result = Result.ok(42);
       const value = Result.expectToBe(result, 'Expected valid number');
+
       expect(value).toBe(42);
     });
 
     test('should throw custom error for Err result', () => {
       const result = Result.err('failed');
+
       expect(() => Result.expectToBe(result, 'Operation must succeed')).toThrow(
         'Operation must succeed',
       );
@@ -570,9 +655,11 @@ describe('Result', () => {
 
       const okResult = Result.ok('success');
       const value = mustBeOk(okResult);
+
       expect(value).toBe('success');
 
       const errResult: Result<string, string> = Result.err('failed');
+
       expect(() => mustBeOk(errResult)).toThrow('Expected successful result');
     });
 
@@ -580,6 +667,7 @@ describe('Result', () => {
       const mustBeOk = Result.expectToBe('Validation failed');
 
       const successResult = pipe(Result.ok(100)).map(mustBeOk).value;
+
       expect(successResult).toBe(100);
 
       expect(
@@ -593,6 +681,7 @@ describe('Result', () => {
       const primary = Result.ok(42);
       const fallback = Result.ok(100);
       const result = Result.orElse(primary, fallback);
+
       expect(Result.unwrapOk(result)).toBe(42);
     });
 
@@ -600,6 +689,7 @@ describe('Result', () => {
       const primary = Result.err('error');
       const fallback = Result.ok('default');
       const result = Result.orElse(primary, fallback);
+
       expect(Result.unwrapOk(result)).toBe('default');
     });
 
@@ -607,6 +697,7 @@ describe('Result', () => {
       const primary = Result.err('error1');
       const fallback = Result.err('error2');
       const result = Result.orElse(primary, fallback);
+
       expect(Result.unwrapErr(result)).toBe('error2');
     });
 
@@ -615,14 +706,18 @@ describe('Result', () => {
 
       const okResult = Result.ok('primary');
       const result = fallbackTo(okResult);
+
       expect(Result.isOk(result)).toBe(true);
+
       if (Result.isOk(result)) {
         expect(result.value).toBe('primary');
       }
 
       const errResult: Result<string, string> = Result.err('failed');
       const fallbackResult = fallbackTo(errResult);
+
       expect(Result.isOk(fallbackResult)).toBe(true);
+
       if (Result.isOk(fallbackResult)) {
         expect(fallbackResult.value).toBe('fallback');
       }
@@ -632,13 +727,17 @@ describe('Result', () => {
       const fallbackTo = Result.orElse(Result.ok('backup'));
 
       const okResult = pipe(Result.ok('original')).map(fallbackTo).value;
+
       expect(Result.isOk(okResult)).toBe(true);
+
       if (Result.isOk(okResult)) {
         expect(okResult.value).toBe('original');
       }
 
       const errResult = pipe(Result.err('network error')).map(fallbackTo).value;
+
       expect(Result.isOk(errResult)).toBe(true);
+
       if (Result.isOk(errResult)) {
         expect(errResult.value).toBe('backup');
       }
@@ -650,13 +749,15 @@ describe('Result', () => {
       const a = Result.ok(1);
       const b = Result.ok('hello');
       const zipped = Result.zip(a, b);
-      expect(Result.unwrapOk(zipped)).toStrictEqual([1, 'hello']);
+
+      assert.deepStrictEqual(Result.unwrapOk(zipped), [1, 'hello']);
     });
 
     test('should return first Err if first is Err', () => {
       const a = Result.err('error1');
       const b = Result.ok('hello');
       const zipped = Result.zip(a, b);
+
       expect(Result.unwrapErr(zipped)).toBe('error1');
     });
 
@@ -664,6 +765,7 @@ describe('Result', () => {
       const a = Result.ok(1);
       const b = Result.err('error2');
       const zipped = Result.zip(a, b);
+
       expect(Result.unwrapErr(zipped)).toBe('error2');
     });
 
@@ -671,6 +773,7 @@ describe('Result', () => {
       const a = Result.err('error1');
       const b = Result.err('error2');
       const zipped = Result.zip(a, b);
+
       expect(Result.unwrapErr(zipped)).toBe('error1');
     });
   });
@@ -678,16 +781,20 @@ describe('Result', () => {
   describe('fromThrowable', () => {
     test('should return Ok when function succeeds', () => {
       const result = Result.fromThrowable(() => 42);
+
       expect(Result.isOk(result)).toBe(true);
       expect(Result.unwrapOk(result)).toBe(42);
+
       expectType<typeof result, Result<number, Error>>('<=');
     });
 
     test('should return Ok with object when function succeeds', () => {
       const obj = { name: 'test', value: 123 };
       const result = Result.fromThrowable(() => obj);
+
       expect(Result.isOk(result)).toBe(true);
-      expect(Result.unwrapOk(result)).toStrictEqual(obj);
+
+      assert.deepStrictEqual(Result.unwrapOk(result), obj);
     });
 
     test('should return Err when function throws Error', () => {
@@ -695,9 +802,12 @@ describe('Result', () => {
       const result = Result.fromThrowable(() => {
         throw new Error(errorMessage);
       });
+
       expect(Result.isErr(result)).toBe(true);
+
       if (Result.isErr(result)) {
         const error = result.value;
+
         expect(error).toBeInstanceOf(Error);
         expect(error.message).toBe(errorMessage);
       }
@@ -709,9 +819,12 @@ describe('Result', () => {
         // eslint-disable-next-line @typescript-eslint/only-throw-error
         throw errorMessage;
       });
+
       expect(Result.isErr(result)).toBe(true);
+
       if (Result.isErr(result)) {
         const error = result.value;
+
         expect(error).toBeInstanceOf(Error);
         expect(error.message).toBe(errorMessage);
       }
@@ -722,9 +835,12 @@ describe('Result', () => {
         // eslint-disable-next-line @typescript-eslint/only-throw-error
         throw 404;
       });
+
       expect(Result.isErr(result)).toBe(true);
+
       if (Result.isErr(result)) {
         const error = result.value;
+
         expect(error).toBeInstanceOf(Error);
         expect(error.message).toBe('404');
       }
@@ -736,14 +852,19 @@ describe('Result', () => {
 
       // eslint-disable-next-line @typescript-eslint/no-unsafe-return
       const validResult = Result.fromThrowable(() => JSON.parse(validJson));
+
       expect(Result.isOk(validResult)).toBe(true);
-      expect(Result.unwrapOk(validResult)).toStrictEqual({ key: 'value' });
+
+      assert.deepStrictEqual(Result.unwrapOk(validResult), { key: 'value' });
 
       // eslint-disable-next-line @typescript-eslint/no-unsafe-return
       const invalidResult = Result.fromThrowable(() => JSON.parse(invalidJson));
+
       expect(Result.isErr(invalidResult)).toBe(true);
+
       if (Result.isErr(invalidResult)) {
         const error = invalidResult.value;
+
         expect(error).toBeInstanceOf(Error);
       }
     });
@@ -762,8 +883,10 @@ describe('Result', () => {
       });
 
       expect(Result.isErr(result)).toBe(true);
+
       if (Result.isErr(result)) {
         const error = result.value;
+
         expect(error.message).toBe('Index out of bounds');
       }
     });