ts-data-forge 5.0.1 → 5.1.1

package/src/json/json.test.mts

@@ -6,18 +6,24 @@ import { Json } from './json.mjs';
 describe('parse', () => {
   test('should parse primitive values', () => {
     assert.deepStrictEqual(Json.parse('"hello"'), Result.ok('hello'));
+
     assert.deepStrictEqual(Json.parse('42'), Result.ok(42));
+
     assert.deepStrictEqual(Json.parse('true'), Result.ok(true));
+
     assert.deepStrictEqual(Json.parse('false'), Result.ok(false));
+
     assert.deepStrictEqual(Json.parse('null'), Result.ok(null));
   });
 
   test('should parse arrays', () => {
     assert.deepStrictEqual(Json.parse('[1,2,3]'), Result.ok([1, 2, 3]));
+
     assert.deepStrictEqual(
       Json.parse('["a","b","c"]'),
       Result.ok(['a', 'b', 'c']),
     );
+
     assert.deepStrictEqual(
       Json.parse('[1,"two",true,null]'),
       Result.ok([1, 'two', true, null]),
@@ -29,6 +35,7 @@ describe('parse', () => {
       Json.parse('{"a":1,"b":2}'),
       Result.ok({ a: 1, b: 2 }),
     );
+
     assert.deepStrictEqual(
       Json.parse('{"name":"test","value":42}'),
       Result.ok({
@@ -40,6 +47,7 @@ describe('parse', () => {
 
   test('should parse nested structures', () => {
     const json = '{"level1":{"level2":{"array":[1,2,{"level3":"deep"}]}}}';
+
     const expected = {
       level1: {
         level2: {
@@ -56,6 +64,7 @@ describe('parse', () => {
       Json.parse('  {  "a" : 1 ,  "b" : 2  }  '),
       Result.ok({ a: 1, b: 2 }),
     );
+
     assert.deepStrictEqual(
       Json.parse('\n[\n  1,\n  2,\n  3\n]\n'),
       Result.ok([1, 2, 3]),
@@ -63,38 +72,54 @@ describe('parse', () => {
   });
 
   test('should return error for invalid JSON', () => {
-    expect(Result.isErr(Json.parse('invalid'))).toBe(true);
-    expect(Result.isErr(Json.parse('{missing quotes: true}'))).toBe(true);
-    expect(Result.isErr(Json.parse('[1,2,]'))).toBe(true); // Trailing comma
-    expect(Result.isErr(Json.parse('undefined'))).toBe(true);
+    assert.isTrue(Result.isErr(Json.parse('invalid')));
+
+    assert.isTrue(Result.isErr(Json.parse('{missing quotes: true}')));
+
+    assert.isTrue(Result.isErr(Json.parse('[1,2,]'))); // Trailing comma
+
+    assert.isTrue(Result.isErr(Json.parse('undefined')));
   });
 
   test('should return parsed value for valid JSON', () => {
     assert.deepStrictEqual(Json.parse('{"a":1}'), Result.ok({ a: 1 }));
+
     assert.deepStrictEqual(Json.parse('[1,2,3]'), Result.ok([1, 2, 3]));
+
     assert.deepStrictEqual(Json.parse('"string"'), Result.ok('string'));
+
     assert.deepStrictEqual(Json.parse('42'), Result.ok(42));
+
     assert.deepStrictEqual(Json.parse('true'), Result.ok(true));
+
     assert.deepStrictEqual(Json.parse('null'), Result.ok(null));
   });
 
   test('should return error for invalid JSON cases', () => {
-    expect(Result.isErr(Json.parse('invalid'))).toBe(true);
-    expect(Result.isErr(Json.parse('{bad json}'))).toBe(true);
-    expect(Result.isErr(Json.parse('[1,2,]'))).toBe(true);
-    expect(Result.isErr(Json.parse('undefined'))).toBe(true);
-    expect(Result.isErr(Json.parse(''))).toBe(true);
+    assert.isTrue(Result.isErr(Json.parse('invalid')));
+
+    assert.isTrue(Result.isErr(Json.parse('{bad json}')));
+
+    assert.isTrue(Result.isErr(Json.parse('[1,2,]')));
+
+    assert.isTrue(Result.isErr(Json.parse('undefined')));
+
+    assert.isTrue(Result.isErr(Json.parse('')));
   });
 
   test('should handle edge cases', () => {
     assert.deepStrictEqual(Json.parse('0'), Result.ok(0));
+
     assert.deepStrictEqual(Json.parse('""'), Result.ok(''));
+
     assert.deepStrictEqual(Json.parse('[]'), Result.ok([]));
+
     assert.deepStrictEqual(Json.parse('{}'), Result.ok({}));
   });
 
   test('should not throw errors', () => {
     expect(() => Json.parse('{{{')).not.toThrow();
+
     expect(() => Json.parse('null null')).not.toThrow();
 
     expect(() => Json.parse(String(undefined))).not.toThrow();
@@ -105,21 +130,23 @@ describe('parse', () => {
       if (typeof value === 'string' && /^\d{4}-\d{2}-\d{2}T/u.test(value)) {
         return new Date(value);
       }
+
       return value;
     };
 
     const jsonString = '{"name":"test","created":"2023-12-01T10:00:00.000Z"}';
+
     const result = Json.parse(jsonString, dateReviver);
 
-    expect(Result.isOk(result)).toBe(true);
+    assert.isTrue(Result.isOk(result));
 
     if (
-      Result.isOk(result) &&
       isRecord(result.value) &&
       hasKey(result.value, 'name') &&
       hasKey(result.value, 'created')
     ) {
       expect(result.value.name).toBe('test');
+
       expect(result.value.created).toBeInstanceOf(Date);
     }
   });
@@ -129,6 +156,7 @@ describe('parse', () => {
       if (key === 'number' && typeof value === 'string') {
         return Number.parseInt(value, 10);
       }
+
       return value;
     };
 
@@ -137,20 +165,20 @@ describe('parse', () => {
       transformReviver,
     );
 
-    expect(Result.isOk(result)).toBe(true);
+    assert.isTrue(Result.isOk(result));
 
-    if (Result.isOk(result)) {
-      expect(result.value).toHaveProperty('number');
-      expect(result.value).toHaveProperty('text');
+    expect(result.value).toHaveProperty('number');
 
-      if (
-        isRecord(result.value) &&
-        hasKey(result.value, 'number') &&
-        hasKey(result.value, 'text')
-      ) {
-        expect(result.value.number).toBe(42);
-        expect(result.value.text).toBe('hello');
-      }
+    expect(result.value).toHaveProperty('text');
+
+    if (
+      isRecord(result.value) &&
+      hasKey(result.value, 'number') &&
+      hasKey(result.value, 'text')
+    ) {
+      expect(result.value.number).toBe(42);
+
+      expect(result.value.text).toBe('hello');
     }
   });
 });
@@ -158,17 +186,22 @@ describe('parse', () => {
 describe('stringify', () => {
   test('should stringify primitive values', () => {
     assert.deepStrictEqual(Json.stringify('hello'), Result.ok('"hello"'));
+
     assert.deepStrictEqual(Json.stringify(42), Result.ok('42'));
+
     assert.deepStrictEqual(Json.stringify(true), Result.ok('true'));
+
     assert.deepStrictEqual(Json.stringify(null), Result.ok('null'));
   });
 
   test('should stringify arrays', () => {
     assert.deepStrictEqual(Json.stringify([1, 2, 3]), Result.ok('[1,2,3]'));
+
     assert.deepStrictEqual(
       Json.stringify(['a', 'b', 'c']),
       Result.ok('["a","b","c"]'),
     );
+
     assert.deepStrictEqual(
       Json.stringify([1, 'two', true, null]),
       Result.ok('[1,"two",true,null]'),
@@ -180,6 +213,7 @@ describe('stringify', () => {
       Json.stringify({ a: 1, b: 2 }),
       Result.ok('{"a":1,"b":2}'),
     );
+
     assert.deepStrictEqual(
       Json.stringify({ name: 'test', value: 42 }),
       Result.ok('{"name":"test","value":42}'),
@@ -203,6 +237,7 @@ describe('stringify', () => {
 
   test('should handle empty structures', () => {
     assert.deepStrictEqual(Json.stringify({}), Result.ok('{}'));
+
     assert.deepStrictEqual(Json.stringify([]), Result.ok('[]'));
   });
 
@@ -211,10 +246,12 @@ describe('stringify', () => {
       Json.stringify('with "quotes"'),
       Result.ok(String.raw`"with \"quotes\""`),
     );
+
     assert.deepStrictEqual(
       Json.stringify('with\nnewline'),
       Result.ok(String.raw`"with\nnewline"`),
     );
+
     assert.deepStrictEqual(
       Json.stringify('with\ttab'),
       Result.ok(String.raw`"with\ttab"`),
@@ -223,34 +260,42 @@ describe('stringify', () => {
 
   test('should return stringified value for valid JSON values', () => {
     assert.deepStrictEqual(Json.stringify({ a: 1 }), Result.ok('{"a":1}'));
+
     assert.deepStrictEqual(Json.stringify([1, 2, 3]), Result.ok('[1,2,3]'));
+
     assert.deepStrictEqual(Json.stringify('string'), Result.ok('"string"'));
+
     assert.deepStrictEqual(Json.stringify(42), Result.ok('42'));
+
     assert.deepStrictEqual(Json.stringify(true), Result.ok('true'));
+
     assert.deepStrictEqual(Json.stringify(null), Result.ok('null'));
   });
 
   test('should handle non-serializable values', () => {
     assert.deepStrictEqual(Json.stringify(undefined), Result.ok(undefined));
+
     assert.deepStrictEqual(
       Json.stringify(Symbol('test')),
       Result.ok(undefined),
     );
+
     assert.deepStrictEqual(
       Json.stringify(() => {}),
       Result.ok(undefined),
     );
 
     // BigInt should cause an error
-    expect(Result.isErr(Json.stringify(123n))).toBe(true);
+    assert.isTrue(Result.isErr(Json.stringify(123n)));
   });
 
   test('should handle circular references', () => {
     const mut_obj: any = { a: 1 };
+
     // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
     mut_obj.circular = mut_obj;
 
-    expect(Result.isErr(Json.stringify(mut_obj))).toBe(true);
+    assert.isTrue(Result.isErr(Json.stringify(mut_obj)));
   });
 
   test('should handle objects with toJSON method', () => {
@@ -275,9 +320,11 @@ describe('stringify', () => {
 
   test('should not throw errors', () => {
     const mut_circularArray: any[] = [];
+
     mut_circularArray.push(mut_circularArray);
 
     expect(() => Json.stringify(mut_circularArray)).not.toThrow();
+
     expect(() => Json.stringify({ fn: () => {} })).not.toThrow();
   });
 
@@ -290,41 +337,41 @@ describe('stringify', () => {
 
     const secureReplacer = (key: string, value: unknown): unknown => {
       if (key === 'password') return '[REDACTED]';
+
       return value;
     };
 
     const result = Json.stringify(data, secureReplacer);
 
-    expect(Result.isOk(result)).toBe(true);
+    assert.isTrue(Result.isOk(result));
 
-    if (Result.isOk(result)) {
-      expect(result.value).toContain('[REDACTED]');
-      expect(result.value).not.toContain('secret123');
-    }
+    expect(result.value).toContain('[REDACTED]');
+
+    expect(result.value).not.toContain('secret123');
   });
 
   test('should format output with space parameter (number)', () => {
     const data = { a: 1, b: 2 };
+
     const result = Json.stringify(data, undefined, 2);
 
-    expect(Result.isOk(result)).toBe(true);
+    assert.isTrue(Result.isOk(result));
 
-    if (Result.isOk(result)) {
-      expect(result.value).toContain('\n');
-      expect(result.value).toContain('  '); // 2 spaces indentation
-    }
+    expect(result.value).toContain('\n');
+
+    expect(result.value).toContain('  '); // 2 spaces indentation
   });
 
   test('should format output with space parameter (string)', () => {
     const data = { a: 1, b: 2 };
+
     const result = Json.stringify(data, undefined, '\t');
 
-    expect(Result.isOk(result)).toBe(true);
+    assert.isTrue(Result.isOk(result));
 
-    if (Result.isOk(result)) {
-      expect(result.value).toContain('\n');
-      expect(result.value).toContain('\t'); // tab indentation
-    }
+    expect(result.value).toContain('\n');
+
+    expect(result.value).toContain('\t'); // tab indentation
   });
 });
 
@@ -340,22 +387,21 @@ describe('stringifySelected', () => {
 
     const result = Json.stringifySelected(user, ['id', 'name', 'email']);
 
-    expect(Result.isOk(result)).toBe(true);
+    assert.isTrue(Result.isOk(result));
 
-    if (Result.isOk(result)) {
-      assert(isString(result.value));
+    assert.isTrue(isString(result.value));
 
-      const parsed: unknown = JSON.parse(result.value);
+    const parsed: unknown = JSON.parse(result.value);
 
-      assert.deepStrictEqual(parsed, {
-        id: 1,
-        name: 'Alice',
-        email: 'alice@example.com',
-      });
+    assert.deepStrictEqual(parsed, {
+      id: 1,
+      name: 'Alice',
+      email: 'alice@example.com',
+    });
 
-      expect(parsed).not.toHaveProperty('password');
-      expect(parsed).not.toHaveProperty('lastLogin');
-    }
+    expect(parsed).not.toHaveProperty('password');
+
+    expect(parsed).not.toHaveProperty('lastLogin');
   });
 
   test('should work with nested objects', () => {
@@ -375,26 +421,29 @@ describe('stringifySelected', () => {
       'total',
     ]);
 
-    expect(Result.isOk(result)).toBe(true);
+    assert.isTrue(Result.isOk(result));
 
-    if (Result.isOk(result)) {
-      assert(isString(result.value));
-      const parsed: unknown = JSON.parse(result.value);
-      if (isRecord(parsed) && hasKey(parsed, 'users')) {
-        expect(isRecord(parsed.users)).toBe(false);
-        expect(parsed.users).toHaveLength(2);
+    assert.isTrue(isString(result.value));
 
-        if (Arr.isArray(parsed.users)) {
-          assert.deepStrictEqual(parsed.users[0], { id: 1, name: 'Alice' });
+    const parsed: unknown = JSON.parse(result.value);
 
-          expect(parsed.users[0]).not.toHaveProperty('secret');
-        }
-        if (isRecord(parsed) && hasKey(parsed, 'metadata')) {
-          assert.deepStrictEqual(parsed.metadata, { total: 2 });
+    if (isRecord(parsed) && hasKey(parsed, 'users')) {
+      assert.isTrue(Arr.isArray(parsed.users));
 
-          expect(parsed.metadata).not.toHaveProperty('page');
-          expect(parsed.metadata).not.toHaveProperty('internal');
-        }
+      expect(parsed.users).toHaveLength(2);
+
+      if (Arr.isArray(parsed.users)) {
+        assert.deepStrictEqual(parsed.users[0], { id: 1, name: 'Alice' });
+
+        expect(parsed.users[0]).not.toHaveProperty('secret');
+      }
+
+      if (isRecord(parsed) && hasKey(parsed, 'metadata')) {
+        assert.deepStrictEqual(parsed.metadata, { total: 2 });
+
+        expect(parsed.metadata).not.toHaveProperty('page');
+
+        expect(parsed.metadata).not.toHaveProperty('internal');
       }
     }
   });
@@ -408,65 +457,66 @@ describe('stringifySelected', () => {
 
     const result = Json.stringifySelected(matrix, [0, 1]);
 
-    expect(Result.isOk(result)).toBe(true);
+    assert.isTrue(Result.isOk(result));
 
-    if (Result.isOk(result)) {
-      assert(isString(result.value));
-      const parsed: unknown = JSON.parse(result.value);
+    assert.isTrue(isString(result.value));
 
-      // Note: stringifySelected works with JSON.stringify's replacer parameter
-      // which may not work as expected with arrays
-      expect(Array.isArray(parsed)).toBe(true);
-      expect(parsed).toHaveLength(3);
-    }
+    const parsed: unknown = JSON.parse(result.value);
+
+    // Note: stringifySelected works with JSON.stringify's replacer parameter
+    // which may not work as expected with arrays
+    assert.isTrue(Array.isArray(parsed));
+
+    expect(parsed).toHaveLength(3);
   });
 
   test('should handle formatting with space parameter', () => {
     const data = { a: 1, b: { c: 2 } };
+
     const result = Json.stringifySelected(data, ['a', 'b', 'c'], 2);
 
-    expect(Result.isOk(result)).toBe(true);
+    assert.isTrue(Result.isOk(result));
 
-    if (Result.isOk(result)) {
-      expect(result.value).toContain('\n');
-      expect(result.value).toContain('  ');
-    }
+    expect(result.value).toContain('\n');
+
+    expect(result.value).toContain('  ');
   });
 
   test('should handle empty selection array', () => {
     const data = { a: 1, b: 2, c: 3 };
+
     const result = Json.stringifySelected(data, []);
 
-    expect(Result.isOk(result)).toBe(true);
+    assert.isTrue(Result.isOk(result));
 
-    if (Result.isOk(result)) {
-      expect(result.value).toBe('{}');
-    }
+    expect(result.value).toBe('{}');
   });
 
   test('should handle undefined properties parameter', () => {
     const data = { a: 1, b: 2 };
+
     const result = Json.stringifySelected(data, undefined);
 
-    expect(Result.isOk(result)).toBe(true);
+    assert.isTrue(Result.isOk(result));
 
-    if (Result.isOk(result)) {
-      assert(isString(result.value));
-      const parsed: unknown = JSON.parse(result.value);
+    assert.isTrue(isString(result.value));
 
-      assert.deepStrictEqual(parsed, { a: 1, b: 2 });
-    }
+    const parsed: unknown = JSON.parse(result.value);
+
+    assert.deepStrictEqual(parsed, { a: 1, b: 2 });
   });
 
   test('should handle circular references with error', () => {
     type CircularType = { name: string; self?: CircularType };
+
     const mut_circular: CircularType = { name: 'test' };
+
     mut_circular.self = mut_circular;
 
     const result = Json.stringifySelected(mut_circular, ['name', 'self']);
 
     // Note: JSON.stringify may handle circular references differently depending on the replacer
-    expect(Result.isOk(result) || Result.isErr(result)).toBe(true);
+    assert.isTrue(Result.isOk(result) || Result.isErr(result));
 
     if (Result.isErr(result)) {
       expectTypeOf(result.value).toBeString();
@@ -485,13 +535,11 @@ describe('stringifySortedKey', () => {
 
     const result = Json.stringifySortedKey(unsortedObj);
 
-    expect(Result.isOk(result)).toBe(true);
+    assert.isTrue(Result.isOk(result));
 
-    if (Result.isOk(result)) {
-      expect(result.value).toBe(
-        '{"aardvark":"animal","apple":"fruit","banana":"fruit","zebra":"animal"}',
-      );
-    }
+    expect(result.value).toBe(
+      '{"aardvark":"animal","apple":"fruit","banana":"fruit","zebra":"animal"}',
+    );
   });
 
   test('should sort nested object keys', () => {
@@ -513,26 +561,26 @@ describe('stringifySortedKey', () => {
 
     const result = Json.stringifySortedKey(nestedObj);
 
-    expect(Result.isOk(result)).toBe(true);
+    assert.isTrue(Result.isOk(result));
 
-    if (Result.isOk(result)) {
-      assert(isString(result.value));
-      const parsed: unknown = JSON.parse(result.value);
-      if (isRecord(parsed)) {
-        const keys = Object.keys(parsed);
+    assert.isTrue(isString(result.value));
 
-        assert.deepStrictEqual(keys, ['settings', 'user']); // sorted top-level keys
+    const parsed: unknown = JSON.parse(result.value);
 
-        if (hasKey(parsed, 'user') && isRecord(parsed.user)) {
-          const userKeys = Object.keys(parsed.user);
+    if (isRecord(parsed)) {
+      const keys = Object.keys(parsed);
 
-          assert.deepStrictEqual(userKeys, ['address', 'age', 'name']); // sorted nested keys
+      assert.deepStrictEqual(keys, ['settings', 'user']); // sorted top-level keys
 
-          if (hasKey(parsed.user, 'address') && isRecord(parsed.user.address)) {
-            const addressKeys = Object.keys(parsed.user.address);
+      if (hasKey(parsed, 'user') && isRecord(parsed.user)) {
+        const userKeys = Object.keys(parsed.user);
 
-            assert.deepStrictEqual(addressKeys, ['city', 'country', 'zip']); // sorted deeper nested keys
-          }
+        assert.deepStrictEqual(userKeys, ['address', 'age', 'name']); // sorted nested keys
+
+        if (hasKey(parsed.user, 'address') && isRecord(parsed.user.address)) {
+          const addressKeys = Object.keys(parsed.user.address);
+
+          assert.deepStrictEqual(addressKeys, ['city', 'country', 'zip']); // sorted deeper nested keys
         }
       }
     }
@@ -553,41 +601,37 @@ describe('stringifySortedKey', () => {
 
     const result = Json.stringifySortedKey(dataWithArrays);
 
-    expect(Result.isOk(result)).toBe(true);
+    assert.isTrue(Result.isOk(result));
 
-    if (Result.isOk(result)) {
-      assert(isString(result.value));
-      const parsed: unknown = JSON.parse(result.value);
+    assert.isTrue(isString(result.value));
 
-      if (isRecord(parsed)) {
-        // Check top-level keys are sorted
-        const topKeys = Object.keys(parsed);
+    const parsed: unknown = JSON.parse(result.value);
 
-        assert.deepStrictEqual(topKeys, ['metadata', 'users']);
+    if (isRecord(parsed)) {
+      // Check top-level keys are sorted
+      const topKeys = Object.keys(parsed);
 
-        // Check metadata keys are sorted
-        if (hasKey(parsed, 'metadata') && isRecord(parsed.metadata)) {
-          const metadataKeys = Object.keys(parsed.metadata);
+      assert.deepStrictEqual(topKeys, ['metadata', 'users']);
 
-          assert.deepStrictEqual(metadataKeys, [
-            'author',
-            'created',
-            'version',
-          ]);
-        }
+      // Check metadata keys are sorted
+      if (hasKey(parsed, 'metadata') && isRecord(parsed.metadata)) {
+        const metadataKeys = Object.keys(parsed.metadata);
 
-        // Check user object keys are sorted
-        if (
-          hasKey(parsed, 'users') &&
-          Arr.isArray(parsed.users) &&
-          Arr.isNonEmpty(parsed.users)
-        ) {
-          const firstUser = parsed.users[0];
-          if (isRecord(firstUser)) {
-            const userKeys = Object.keys(firstUser);
+        assert.deepStrictEqual(metadataKeys, ['author', 'created', 'version']);
+      }
 
-            assert.deepStrictEqual(userKeys, ['active', 'id', 'name']);
-          }
+      // Check user object keys are sorted
+      if (
+        hasKey(parsed, 'users') &&
+        Arr.isArray(parsed.users) &&
+        Arr.isNonEmpty(parsed.users)
+      ) {
+        const firstUser = parsed.users[0];
+
+        if (isRecord(firstUser)) {
+          const userKeys = Object.keys(firstUser);
+
+          assert.deepStrictEqual(userKeys, ['active', 'id', 'name']);
         }
       }
     }
@@ -595,30 +639,32 @@ describe('stringifySortedKey', () => {
 
   test('should handle formatting with space parameter', () => {
     const obj = { b: 2, a: 1 };
+
     const result = Json.stringifySortedKey(obj, 2);
 
-    expect(Result.isOk(result)).toBe(true);
+    assert.isTrue(Result.isOk(result));
 
-    if (Result.isOk(result)) {
-      expect(result.value).toContain('\n');
-      expect(result.value).toContain('  ');
-      expect(result.value).toMatch(/\{\s+"a": 1,\s+"b": 2\s+\}/u);
-    }
+    expect(result.value).toContain('\n');
+
+    expect(result.value).toContain('  ');
+
+    expect(result.value).toMatch(/\{\s+"a": 1,\s+"b": 2\s+\}/u);
   });
 
   test('should produce deterministic output', () => {
     const obj1 = { c: 3, a: 1, b: 2 };
+
     const obj2 = { b: 2, a: 1, c: 3 };
 
     const result1 = Json.stringifySortedKey(obj1);
+
     const result2 = Json.stringifySortedKey(obj2);
 
-    expect(Result.isOk(result1)).toBe(true);
-    expect(Result.isOk(result2)).toBe(true);
+    assert.isTrue(Result.isOk(result1));
 
-    if (Result.isOk(result1) && Result.isOk(result2)) {
-      expect(result1.value).toBe(result2.value);
-    }
+    assert.isTrue(Result.isOk(result2));
+
+    expect(result1.value).toBe(result2.value);
   });
 
   test('should handle problematic objects', () => {
@@ -627,16 +673,18 @@ describe('stringifySortedKey', () => {
         normal: string;
         circular: { self?: CircularObj };
       };
+
       const mut_problematicObj: CircularObj = {
         normal: 'value',
         circular: {},
       };
+
       mut_problematicObj.circular.self = mut_problematicObj;
 
       const result = Json.stringifySortedKey(mut_problematicObj);
 
       // This may throw due to circular reference during key extraction
-      expect(Result.isErr(result)).toBe(true);
+      assert.isTrue(Result.isErr(result));
 
       if (Result.isErr(result)) {
         expectTypeOf(result.value).toBeString();
@@ -650,11 +698,9 @@ describe('stringifySortedKey', () => {
   test('should handle empty object', () => {
     const result = Json.stringifySortedKey({});
 
-    expect(Result.isOk(result)).toBe(true);
+    assert.isTrue(Result.isOk(result));
 
-    if (Result.isOk(result)) {
-      expect(result.value).toBe('{}');
-    }
+    expect(result.value).toBe('{}');
   });
 
   test('should handle deeply nested structures', () => {
@@ -672,25 +718,27 @@ describe('stringifySortedKey', () => {
 
     const result = Json.stringifySortedKey(deep);
 
-    expect(Result.isOk(result)).toBe(true);
-
-    if (Result.isOk(result)) {
-      assert(isString(result.value));
-      const parsed: unknown = JSON.parse(result.value);
-      if (isRecord(parsed) && hasKey(parsed, 'level1')) {
-        const level1 = parsed.level1;
-        if (isRecord(level1)) {
-          assert.deepStrictEqual(Object.keys(level1), ['a', 'z']);
-
-          if (
-            hasKey(level1, 'a') &&
-            isRecord(level1.a) &&
-            hasKey(level1.a, 'nested')
-          ) {
-            const nested = level1.a.nested;
-            if (isRecord(nested)) {
-              assert.deepStrictEqual(Object.keys(nested), ['x', 'y']);
-            }
+    assert.isTrue(Result.isOk(result));
+
+    assert.isTrue(isString(result.value));
+
+    const parsed: unknown = JSON.parse(result.value);
+
+    if (isRecord(parsed) && hasKey(parsed, 'level1')) {
+      const level1 = parsed.level1;
+
+      if (isRecord(level1)) {
+        assert.deepStrictEqual(Object.keys(level1), ['a', 'z']);
+
+        if (
+          hasKey(level1, 'a') &&
+          isRecord(level1.a) &&
+          hasKey(level1.a, 'nested')
+        ) {
+          const nested = level1.a.nested;
+
+          if (isRecord(nested)) {
+            assert.deepStrictEqual(Object.keys(nested), ['x', 'y']);
           }
         }
       }