test: replace mocha with Node.js native test runner

- Replace it() with test() from node:test
- Add import {describe, test} from 'node:test' to all test files
- Tests run via: node --import tsx --test

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: 2 people

tests/Jsona.test.ts

@@ -1,5 +1,6 @@
 import * as chai from 'chai';
 import {expect} from 'chai';
+import {describe, test} from 'node:test';
 import Jsona from '../src';
 
 import {
@@ -31,95 +32,95 @@ chai.config.truncateThreshold = 0;
 describe('Jsona', () => {
     const jsona = new Jsona();
 
-    it('should instantiate with fallback property mappers', () => {
+    test('should instantiate with fallback property mappers', () => {
         let jsona = new Jsona();
     });
 
     describe('serialize', () => {
-        it('should throw Error if stuff is not passed', () => {
+        test('should throw Error if stuff is not passed', () => {
             expect(jsona.serialize.bind(jsona, null)).to.throw(Error);
             expect(jsona.serialize.bind(jsona, undefined)).to.throw(Error);
             expect(jsona.serialize.bind(jsona, {stuff: null})).to.throw(Error);
         });
 
-        it('should build json with item, without included', () => {
+        test('should build json with item, without included', () => {
             const jsonBody = jsona.serialize({stuff: town1.model});
             expect(jsonBody.data).to.be.deep.equal(town1.json);
             expect(jsonBody.included).to.be.equal(undefined);
         });
 
-        it('should build json with collection, with included', () => {
+        test('should build json with collection, with included', () => {
             const jsonBody = jsona.serialize({stuff: user2.model, includeNames: ['specialty', 'town.country']});
             expect(jsonBody.data).to.be.deep.equal(user2.json);
             expect(jsonBody.included).to.be.deep.equal([specialty1.json, specialty2.json, town2.json, country2.json]);
         });
 
-        it('should build json with collection, with included resources that do not have ids', () => {
+        test('should build json with collection, with included resources that do not have ids', () => {
             const jsonBody = jsona.serialize({stuff: userWithIdlessSpecialties.model, includeNames: ['specialtyWithoutIds']});
             expect(jsonBody.included).to.be.deep.equal([idlessSpecialty1.json, idlessSpecialty2.json]);
         });
 
-        it('should build json and save null relationships', () => {
+        test('should build json and save null relationships', () => {
             const jsonBody = jsona.serialize({stuff: withNullRelationsMock.collection});
             expect(jsonBody.data).to.be.deep.equal(withNullRelationsMock.json);
         });
     });
 
     describe('deserialize', () => {
-        it('should throw Error if body is not passed', () => {
+        test('should throw Error if body is not passed', () => {
             expect(jsona.deserialize.bind(jsona, null)).to.throw(Error);
             expect(jsona.deserialize.bind(jsona, undefined)).to.throw(Error);
         });
 
-        it('should deserialize item without included', () => {
+        test('should deserialize item without included', () => {
             const userModel = jsona.deserialize({data: user2.json});
             expect(userModel).to.be.deep.equal(user2.modelWithoutIncluded);
         });
 
-        it('should deserialize collection with included', () => {
+        test('should deserialize collection with included', () => {
             const townsCollection = jsona.deserialize({
                 data: [town1.json, town2.json],
                 included: [country1.json, country2.json]
             });
             expect(townsCollection).to.be.deep.equal([town1.model, town2.model]);
         });
 
-        it('should deserialize json with circular relationships', () => {
+        test('should deserialize json with circular relationships', () => {
             const recursiveItem = jsona.deserialize(circular.json);
             expect(recursiveItem).to.be.deep.equal(circular.model);
         });
 
-        it('should deserialize json with meta & circular relationships', () => {
+        test('should deserialize json with meta & circular relationships', () => {
             const recursiveItem = jsona.deserialize(circularWithMeta.json);
             expect(recursiveItem).to.be.deep.equal(circularWithMeta.model);
         });
 
-        it('should deserialize json with duplicate relationships', () => {
+        test('should deserialize json with duplicate relationships', () => {
             const duplicateItem = jsona.deserialize(duplicate.json, { preferNestedDataFromData: true });
             expect(duplicateItem).to.be.deep.equal(duplicate.model);
         });
 
-        it('should deserialize json with data without root ids', () => {
+        test('should deserialize json with data without root ids', () => {
             const collectionWithoutRootIds = jsona.deserialize({data: withoutRootIdsMock.json});
             expect(collectionWithoutRootIds).to.be.deep.equal(withoutRootIdsMock.collection);
         });
 
-        it('should deserialize json and save null relationships', () => {
+        test('should deserialize json and save null relationships', () => {
             const collectionWithNullRelations = jsona.deserialize({data: withNullRelationsMock.json});
             expect(collectionWithNullRelations).to.be.deep.equal(withNullRelationsMock.collection);
         });
 
-        it('should deserialize resource id object meta field into resourceIdObjMeta', () => {
+        test('should deserialize resource id object meta field into resourceIdObjMeta', () => {
             const stuff = jsona.deserialize(resourceIdObjMetaMock.json);
             expect(stuff).to.be.deep.equal(resourceIdObjMetaMock.collection);
         });
 
-        it('should deserialize with different attrs for root object and related', () => {
+        test('should deserialize with different attrs for root object and related', () => {
             const stuff = jsona.deserialize(differentAttrsInDataAndIncludedMock.json);
             expect(stuff).to.be.deep.equal(differentAttrsInDataAndIncludedMock.collection);
         });
 
-        it('should new', () => {
+        test('should new', () => {
             const stuff = jsona.deserialize(differentAttrsInDataAndIncludedMock.json);
             expect(stuff).to.be.deep.equal(differentAttrsInDataAndIncludedMock.collection);
         });
@@ -128,29 +129,29 @@ describe('Jsona', () => {
 
     describe('denormalizeReduxObject', () => {
 
-        it('should throw Error if reduxObject is not passed', () => {
+        test('should throw Error if reduxObject is not passed', () => {
             const denormalizeReduxObject = jsona.denormalizeReduxObject.bind(jsona, {
                 reduxObject: null,
             });
             expect(denormalizeReduxObject).to.throw(Error, 'reduxObject');
         });
 
-        it('should throw Error if entityType is not passed', () => {
+        test('should throw Error if entityType is not passed', () => {
             const denormalizeReduxObject = jsona.denormalizeReduxObject.bind(jsona, {
                 reduxObject: {},
             });
             expect(denormalizeReduxObject).to.throw(Error, 'entityType');
         });
 
-        it('should return null if no such entityType in reduxObject', () => {
+        test('should return null if no such entityType in reduxObject', () => {
             const model = jsona.denormalizeReduxObject({
                 reduxObject: {},
                 entityType: 'myEntity'
             });
             expect(model).to.be.equal(null);
         });
 
-        it('should return null if no such entityId in reduxObject', () => {
+        test('should return null if no such entityId in reduxObject', () => {
             const model = jsona.denormalizeReduxObject({
                 reduxObject: reduxObject1,
                 entityType: 'article',
@@ -159,7 +160,7 @@ describe('Jsona', () => {
             expect(model).to.be.equal(null);
         });
 
-        it('should return collection of models if entityIds is Array', () => {
+        test('should return collection of models if entityIds is Array', () => {
             const models = jsona.denormalizeReduxObject({
                 reduxObject: reduxObject1,
                 returnBuilderInRelations: false,
@@ -170,7 +171,7 @@ describe('Jsona', () => {
             expect(models).to.be.deep.equal([town1.model, town2.model]);
         });
 
-        it('should return collection of models if entityIds is not passed', () => {
+        test('should return collection of models if entityIds is not passed', () => {
             const models = jsona.denormalizeReduxObject({
                 reduxObject: reduxObject1,
                 returnBuilderInRelations: false,
@@ -181,7 +182,7 @@ describe('Jsona', () => {
         });
 
 
-        it('should denormalize json with circular relationships', () => {
+        test('should denormalize json with circular relationships', () => {
             const model = jsona.denormalizeReduxObject({
                 reduxObject: reduxObjectWithCircular,
                 returnBuilderInRelations: false,
@@ -191,7 +192,7 @@ describe('Jsona', () => {
             expect(model).to.be.deep.equal(circular.model);
         });
 
-        it('should denormalize model with relationships', () => {
+        test('should denormalize model with relationships', () => {
             const model1 = jsona.denormalizeReduxObject({
                 reduxObject: reduxObject1,
                 returnBuilderInRelations: false,
@@ -208,7 +209,7 @@ describe('Jsona', () => {
             expect(model2['country']).to.be.deep.equal(country1.model);
         });
 
-        it('should allow to set relationships before denormalization', () => {
+        test('should allow to set relationships before denormalization', () => {
             const model = jsona.denormalizeReduxObject({
                 reduxObject: reduxObject1,
                 returnBuilderInRelations: true,

tests/ModelsSerializer.test.ts

@@ -1,5 +1,6 @@
 import * as chai from 'chai';
 import {expect} from 'chai';
+import {describe, test} from 'node:test';
 import ModelsSerializer from "../src/builders/ModelsSerializer";
 import {ModelPropertiesMapper} from "../src/simplePropertyMappers";
 
@@ -24,47 +25,47 @@ describe('ModelsSerializer', () => {
     let builder;
     let propertiesMapper;
 
-    it('should throw Error if jsonPropertiesMapper is not passed', () => {
+    test('should throw Error if jsonPropertiesMapper is not passed', () => {
         builder = new ModelsSerializer();
         builder.setStuff(user2.model);
         expect(builder.build.bind(builder)).to.throw(Error, 'propertiesMapper');
     });
 
-    it('should instantiate without errors', () => {
+    test('should instantiate without errors', () => {
         propertiesMapper = new ModelPropertiesMapper();
         builder = new ModelsSerializer(propertiesMapper);
         expect(builder).to.be.an.instanceof(ModelsSerializer);
     });
 
-    it('should handle one model in setStuff', () => {
+    test('should handle one model in setStuff', () => {
         builder.setStuff(user2.model);
         expect(builder.stuff).to.be.deep.equal(user2.model);
     });
 
-    it('should handle collection of models in setStuff', () => {
+    test('should handle collection of models in setStuff', () => {
         builder.setStuff([user2.model, user1.model]);
         expect(builder.stuff).to.be.deep.equal([user2.model, user1.model]);
     });
 
-    it('should setIncludeNames with convertation to TJsonaNormalizedIncludeNamesTree', () => {
+    test('should setIncludeNames with convertation to TJsonaNormalizedIncludeNamesTree', () => {
         builder.setIncludeNames(includeNames1.denormalized);
         expect(builder.includeNamesTree).to.be.deep.equal(includeNames1.normalized);
     });
 
-    it('should setIncludeNames as they are', () => {
+    test('should setIncludeNames as they are', () => {
         builder.setIncludeNames(includeNames1.normalized);
         expect(builder.includeNamesTree).to.be.deep.equal(includeNames1.normalized);
     });
 
-    it('should build correct json with one data-item, without included', () => {
+    test('should build correct json with one data-item, without included', () => {
         builder = new ModelsSerializer(propertiesMapper);
 
         builder.setStuff(article1.model);
         const json = builder.build();
         expect(json).to.be.deep.equal({data: article1.json});
     });
 
-    it('should build correct json with one data-item, with included', () => {
+    test('should build correct json with one data-item, with included', () => {
         builder = new ModelsSerializer(propertiesMapper);
 
         builder.setStuff(user2.model);
@@ -73,7 +74,7 @@ describe('ModelsSerializer', () => {
         expect(json).to.be.deep.equal({data: user2.json, included: user2.included.townOnly});
     });
 
-    it('should build correct json with collection of data items, with included', () => {
+    test('should build correct json with collection of data items, with included', () => {
         builder = new ModelsSerializer(propertiesMapper);
 
         builder.setStuff([article1.model, article2.model]);
@@ -104,12 +105,12 @@ describe('ModelsSerializer', () => {
 
     });
 
-    it('should build json with null data for nulled relation', () => {
+    test('should build json with null data for nulled relation', () => {
         builder = new ModelsSerializer(propertiesMapper);
 
         builder.setStuff(articleWithoutAuthor.model);
         builder.setIncludeNames(articleWithoutAuthor.includeNames);
         const json = builder.build();
         expect(json).to.be.deep.equal({ data: articleWithoutAuthor.json });
     });
-});
+});