@nymphjs/nymph 1.0.0-beta.55 → 1.0.0-beta.57

package/dist/driver/testArtifacts.js

@@ -16,11 +16,14 @@ function QueriesTest(nymph, it) {
     let testGuid;
     let refGuid;
     let createdMultiple = false;
+    // The entities created by this function are required by many of the tests.
     async function createTestEntities() {
         if (testGuid != null) {
             return;
         }
+        // Creating entity...
         testEntity = await TestModel.factory();
+        // Saving entity...
         testEntity.name = 'Entity Test ' + new Date().toLocaleString();
         testEntity.null = null;
         testEntity.string = 'test';
@@ -49,20 +52,25 @@ These hats are absolutely fantastic.`;
         expect(await testEntity.$save()).toEqual(true);
         entityReferenceTest.test = 'good';
         expect(await entityReferenceTest.$save()).toEqual(true);
+        // Test asynchronous getEntity.
         testEntity = (await nymph.getEntity({ class: TestModel }, testGuid));
         expect(testEntity).toBeInstanceOf(TestModel);
         expect(testEntity.guid).toEqual(testGuid);
     }
+    // The entities created by this function are required by many of the tests.
     async function createMultipleTestEntities() {
         if (!createdMultiple) {
             createdMultiple = true;
+            // Creating 100 entities...
             for (let i = 0; i < 100; i++) {
                 const testEntity = await TestModel.factory();
                 testEntity.name = `Multi Test ${i}`;
+                // Reverse the number for sort testing.
                 testEntity.number = 100 - i;
                 testEntity.$removeTag('test');
                 testEntity.$addTag('multiTest');
                 expect(await testEntity.$save()).toEqual(true);
+                // Pause for a few milliseconds so the cdate and mdate can be sorted.
                 await new Promise((res) => setTimeout(() => res(1), 5));
             }
         }
@@ -96,15 +104,19 @@ These hats are absolutely fantastic.`;
     });
     it('by guid', async () => {
         await createTestEntities();
+        // Retrieving entity by GUID...
         let resultEntity = await nymph.getEntity({ class: TestModel }, testGuid);
         expect(testEntity.$is(resultEntity)).toEqual(true);
+        // Using class constructor...
         resultEntity = await TestModel.factory(testGuid);
         expect(testEntity.$is(resultEntity)).toEqual(true);
+        // Testing wrong GUID...
         resultEntity = await nymph.getEntity({ class: TestModel }, (0, guid_1.guid)());
         expect(testEntity.$is(resultEntity)).toEqual(false);
     });
     it('transactions', async () => {
         await createTestEntities();
+        // Verify not in a transaction.
         expect(await nymph.inTransaction()).toEqual(false);
         let transaction = await nymph.startTransaction('test');
         testEntity.$nymph = transaction;
@@ -113,37 +125,56 @@ These hats are absolutely fantastic.`;
             await transaction.rollback('test');
             return;
         }
+        // Change a value in the test entity.
         testEntity.string = 'bad value';
         expect(await testEntity.$save()).toEqual(true);
+        // Rollback the transaction.
         await transaction.rollback('test');
+        // Verify not in a transaction.
         expect(await transaction.inTransaction()).toEqual(false);
+        // Verify the value is correct.
         await testEntity.$refresh();
         expect(testEntity.string).toEqual('test');
+        // Start a new transaction.
         transaction = await nymph.startTransaction('test');
         testEntity.$nymph = transaction;
+        // Verify in a transaction.
         expect(await transaction.inTransaction()).toEqual(true);
+        // Delete the entity.
         expect(await testEntity.$delete()).toEqual(true);
         const resultEntity = await transaction.getEntity({ class: TestModel }, testGuid);
         expect(resultEntity).toBeNull();
+        // Rollback the transaction.
         await transaction.rollback('test');
+        // Verify not in a transaction.
         expect(await transaction.inTransaction()).toEqual(false);
+        // Verify it's back.
         testEntity = (await transaction.getEntity({ class: TestModel }, testGuid));
         expect(testEntity.guid).toEqual(testGuid);
+        // Start a new transaction with a dot in the name.
         transaction = await nymph.startTransaction('test.1');
         testEntity.$nymph = transaction;
+        // Verify in a transaction.
         expect(await transaction.inTransaction()).toEqual(true);
+        // Make a change.
         testEntity.string = 'fish';
         expect(await testEntity.$save()).toEqual(true);
+        // Commit the transaction.
         await transaction.commit('test.1');
         testEntity.$nymph = nymph;
+        // Verify not in a transaction.
         expect(await transaction.inTransaction()).toEqual(false);
+        // Verify the value is correct.
         await testEntity.$refresh();
         expect(testEntity.string).toEqual('fish');
+        // Finally, change it back.
         testEntity.string = 'test';
         expect(await testEntity.$save()).toEqual(true);
+        // TODO: nested transactions
     });
     it('options', async () => {
         await createTestEntities();
+        // Testing entity order, offset, limit...
         const resultEntities = await nymph.getEntities({
             class: TestModel,
             reverse: true,
@@ -156,86 +187,103 @@ These hats are absolutely fantastic.`;
     });
     it('guid and tags', async () => {
         await createTestEntities();
+        // Retrieving entity by GUID and tags...
         const resultEntity = await nymph.getEntity({ class: TestModel }, { type: '&', guid: testGuid, tag: 'test' });
         expect(testEntity.$is(resultEntity)).toEqual(true);
     });
     it('or selector', async () => {
         await createTestEntities();
+        // Retrieving entity by GUID and tags...
         const resultEntity = await nymph.getEntity({ class: TestModel }, { type: '|', guid: [testGuid, (0, guid_1.guid)()] });
         expect(testEntity.$is(resultEntity)).toEqual(true);
     });
     it('wrong or selector', async () => {
         await createTestEntities();
+        // Retrieving entity by GUID and tags...
         const resultEntity = await nymph.getEntity({ class: TestModel }, { type: '|', guid: [(0, guid_1.guid)(), (0, guid_1.guid)()] });
         expect(testEntity.$is(resultEntity)).toEqual(false);
     });
     it('not guid', async () => {
         await createTestEntities();
+        // Retrieving entity by !GUID...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', '!guid': (0, guid_1.guid)(), tag: 'test' });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('not tags', async () => {
         await createTestEntities();
+        // Retrieving entity by !tags...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', guid: testGuid, '!tag': ['barbecue', 'pickles'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('guid and wrong tags', async () => {
         await createTestEntities();
+        // Testing GUID and wrong tags...
         const resultEntity = await nymph.getEntity({ class: TestModel }, { type: '&', guid: testGuid, tag: ['pickles'] });
         expect(resultEntity).toBeNull();
     });
     it('tags', async () => {
         await createTestEntities();
+        // Retrieving entity by tags...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test' });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('wrong tags', async () => {
         await createTestEntities();
+        // Testing wrong tags...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'pickles' });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('inclusive tags', async () => {
         await createTestEntities();
+        // Retrieving entity by tags inclusively...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '|', tag: ['pickles', 'test', 'barbecue'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('wrong inclusive tags', async () => {
         await createTestEntities();
+        // Testing wrong inclusive tags...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '|', tag: ['pickles', 'barbecue'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('mixed tags', async () => {
         await createTestEntities();
+        // Retrieving entity by mixed tags...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test' }, { type: '|', tag: ['pickles', 'test', 'barbecue'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('wrong inclusive mixed tags', async () => {
         await createTestEntities();
+        // Testing wrong inclusive mixed tags...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test' }, { type: '|', tag: ['pickles', 'barbecue'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('wrong exclusive mixed tags', async () => {
         await createTestEntities();
+        // Testing wrong exclusive mixed tags...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'pickles' }, { type: '|', tag: ['test', 'barbecue'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('defined', async () => {
         await createTestEntities();
+        // Retrieving entity by defined...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', defined: 'string' });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('not defined', async () => {
         await createTestEntities();
+        // Retrieving entity by !defined...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test', '!defined': 'pickles' });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('defined in a not and clause', async () => {
         await createTestEntities();
+        // Retrieving entity by defined in not and clause...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '!&', defined: 'pickles' }, { type: '&', tag: 'test' });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('equal', async () => {
         await createTestEntities();
+        // Retrieving entity by equal...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', equal: ['string', 'test'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
@@ -243,12 +291,14 @@ These hats are absolutely fantastic.`;
         await createTestEntities();
         const referenceEntity = await TestModel.factory(refGuid);
         expect(referenceEntity.guid).toEqual(refGuid);
+        // Retrieving entity by !equal...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test', '!equal': ['string', 'wrong'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
         expect(referenceEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('like', async () => {
         await createTestEntities();
+        // Retrieving entity by like...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', like: ['string', 't_s%'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
@@ -256,12 +306,14 @@ These hats are absolutely fantastic.`;
         await createTestEntities();
         const referenceEntity = await TestModel.factory(refGuid);
         expect(referenceEntity.guid).toEqual(refGuid);
+        // Retrieving entity by !like...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test', '!like': ['string', 'wr_n%'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
         expect(referenceEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('ilike', async () => {
         await createTestEntities();
+        // Retrieving entity by ilike...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', ilike: ['string', 'T_s%'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
@@ -269,56 +321,68 @@ These hats are absolutely fantastic.`;
         await createTestEntities();
         const referenceEntity = await TestModel.factory(refGuid);
         expect(referenceEntity.guid).toEqual(refGuid);
+        // Retrieving entity by !ilike...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test', '!ilike': ['string', 'wr_n%'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
         expect(referenceEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('like with wrong case', async () => {
         await createTestEntities();
+        // Retrieving entity by like...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', like: ['string', 'T_s%'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('tags and equal', async () => {
         await createTestEntities();
+        // Retrieving entity by tags and equal...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test', equal: ['string', 'test'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('wrong tags right equal', async () => {
         await createTestEntities();
+        // Testing wrong tags and right equal...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'pickles', equal: ['string', 'test'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('right tags wrong equal', async () => {
         await createTestEntities();
+        // Testing right tags and wrong equal...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test', equal: ['string', 'pickles'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('wrong tags wrong equal', async () => {
         await createTestEntities();
+        // Testing wrong tags and wrong equal...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'pickles', equal: ['string', 'pickles'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('contain', async () => {
         await createTestEntities();
+        // Retrieving entity by contain...
         let resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', contain: ['array', 'values'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
+        // Retrieving entity by contain with full match...
         resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', contain: ['string', 'test'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('not contain', async () => {
         await createTestEntities();
+        // Retrieving entity by !contain...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test' }, { type: '!&', contain: ['array', 'pickles'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('wrong contain', async () => {
         await createTestEntities();
+        // Testing wrong contain...
         let resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', contain: ['array', 'pickles'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
+        // Testing wrong contain...
         resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', contain: ['string', 'pickles'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('match', async () => {
         await createTestEntities();
+        // Retrieving entity by regex match...
         let resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', match: ['match', '.*'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
         resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test', match: ['match', 'Edward McCheese'] });
@@ -346,11 +410,13 @@ These hats are absolutely fantastic.`;
     });
     it('imatch', async () => {
         await createTestEntities();
+        // Retrieving entity by regex match...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test', imatch: ['match', 'edward mccheese'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('wrong match', async () => {
         await createTestEntities();
+        // Testing wrong regex match...
         let resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', match: ['match', 'Q'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
         resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'pickle', match: ['match', '.*'] });
@@ -366,16 +432,19 @@ These hats are absolutely fantastic.`;
     });
     it('match wrong case', async () => {
         await createTestEntities();
+        // Retrieving entity by regex match...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test', match: ['match', 'edward mccheese'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('match and equal inclusive', async () => {
         await createTestEntities();
+        // Retrieving entity by regex + equal inclusively...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test' }, { type: '|', equal: ['string', 'pickles'], match: ['string', 'test'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('greater than', async () => {
         await createTestEntities();
+        // Retrieving entity by inequality...
         let resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             gt: [
@@ -384,6 +453,7 @@ These hats are absolutely fantastic.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             gt: [
@@ -392,6 +462,7 @@ These hats are absolutely fantastic.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             gt: [
@@ -400,6 +471,7 @@ These hats are absolutely fantastic.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             gt: [
@@ -408,6 +480,7 @@ These hats are absolutely fantastic.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             gt: [
@@ -416,6 +489,7 @@ These hats are absolutely fantastic.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             gt: [
@@ -427,6 +501,7 @@ These hats are absolutely fantastic.`;
     });
     it('greater than or equal', async () => {
         await createTestEntities();
+        // Retrieving entity by inequality...
         let resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             gte: [
@@ -435,6 +510,7 @@ These hats are absolutely fantastic.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             gte: [
@@ -443,6 +519,7 @@ These hats are absolutely fantastic.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             gte: [
@@ -451,6 +528,7 @@ These hats are absolutely fantastic.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             gte: [
@@ -459,6 +537,7 @@ These hats are absolutely fantastic.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             gte: [
@@ -467,6 +546,7 @@ These hats are absolutely fantastic.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             gte: [
@@ -478,6 +558,7 @@ These hats are absolutely fantastic.`;
     });
     it('less than', async () => {
         await createTestEntities();
+        // Retrieving entity by inequality...
         let resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             lt: [
@@ -486,6 +567,7 @@ These hats are absolutely fantastic.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             lt: [
@@ -494,6 +576,7 @@ These hats are absolutely fantastic.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             lt: [
@@ -502,6 +585,7 @@ These hats are absolutely fantastic.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             lt: [
@@ -510,6 +594,7 @@ These hats are absolutely fantastic.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             lt: [
@@ -518,6 +603,7 @@ These hats are absolutely fantastic.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             lt: [
@@ -529,6 +615,7 @@ These hats are absolutely fantastic.`;
     });
     it('less than or equal', async () => {
         await createTestEntities();
+        // Retrieving entity by inequality...
         let resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             lte: [
@@ -537,6 +624,7 @@ These hats are absolutely fantastic.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             lte: [
@@ -545,6 +633,7 @@ These hats are absolutely fantastic.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             lte: [
@@ -553,6 +642,7 @@ These hats are absolutely fantastic.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             lte: [
@@ -561,6 +651,7 @@ These hats are absolutely fantastic.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             lte: [
@@ -569,6 +660,7 @@ These hats are absolutely fantastic.`;
             ],
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
+        // Retrieving entity by inequality...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             lte: [
@@ -580,30 +672,36 @@ These hats are absolutely fantastic.`;
     });
     it('not inequality', async () => {
         await createTestEntities();
+        // Retrieving entity by !inequality...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test' }, { type: '!&', gte: ['number', 60] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('wrong inequality', async () => {
         await createTestEntities();
+        // Testing wrong inequality...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', lte: ['number', 29.99] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('greater than cdate', async () => {
         await createTestEntities();
+        // Retrieving entity by time...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test', gt: ['cdate', (testEntity.cdate ?? 0) - 120] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('wrong cdate', async () => {
         await createTestEntities();
+        // Testing wrong time...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test', gte: ['cdate', (testEntity.cdate ?? 0) + 1] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('time selector', async () => {
         await createTestEntities();
         const referenceEntity = await TestModel.factory(refGuid);
+        // Retrieving entity by relative time...
         let resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', gt: ['timestamp', null, '-1 day'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
         expect(referenceEntity.$inArray(resultEntity)).toEqual(false);
+        // Retrieving entity by relative time inclusively...
         resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             gt: [
@@ -613,9 +711,11 @@ These hats are absolutely fantastic.`;
         });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
         expect(referenceEntity.$inArray(resultEntity)).toEqual(false);
+        // Retrieving entity by relative time...
         resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', gt: ['timestamp', null, '-3 days'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
         expect(referenceEntity.$inArray(resultEntity)).toEqual(true);
+        // Retrieving entity by relative time...
         resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', gt: ['cdate', null, '-1 day'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
         expect(referenceEntity.$inArray(resultEntity)).toEqual(true);
@@ -623,45 +723,55 @@ These hats are absolutely fantastic.`;
     it('wrong time selector', async () => {
         await createTestEntities();
         const referenceEntity = await TestModel.factory(refGuid);
+        // Retrieving entity by relative time...
         let resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test', gt: ['timestamp', null, '+1 day'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
         expect(referenceEntity.$inArray(resultEntity)).toEqual(false);
+        // Retrieving entity by relative time...
         resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test', lt: ['timestamp', null, '-3 days'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
         expect(referenceEntity.$inArray(resultEntity)).toEqual(false);
+        // Retrieving entity by relative time...
         resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test', gt: ['cdate', null, '+1 day'] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
         expect(referenceEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('references', async () => {
         await createTestEntities();
+        // Testing referenced entities...
         await testEntity.reference?.$wake();
         expect(testEntity.reference?.test).toEqual('good');
+        // Testing referenced entity arrays...
         await Promise.all(testEntity.refArray?.map((e) => e.$wake()) || []);
         expect(testEntity.refArray?.[0].test).toEqual('good');
     });
     it('ref', async () => {
         await createTestEntities();
+        // Retrieving entity by reference...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', ref: ['reference', refGuid] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('not ref', async () => {
         await createTestEntities();
+        // Retrieving entity by !reference...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', tag: 'test' }, { type: '!&', ref: ['reference', (0, guid_1.guid)()] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('wrong ref', async () => {
         await createTestEntities();
+        // Testing wrong reference...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', ref: ['reference', (0, guid_1.guid)()] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('nonexistent ref', async () => {
         await createTestEntities();
+        // Testing non-existent reference...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', ref: ['pickle', refGuid] });
         expect(testEntity.$inArray(resultEntity)).toEqual(false);
     });
     it('inclusive ref', async () => {
         await createTestEntities();
+        // Retrieving entity by inclusive reference...
         const resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             ref: [
@@ -673,6 +783,7 @@ These hats are absolutely fantastic.`;
     });
     it('wrong inclusive ref', async () => {
         await createTestEntities();
+        // Testing wrong inclusive reference...
         const resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '|',
             ref: [
@@ -684,11 +795,13 @@ These hats are absolutely fantastic.`;
     });
     it('ref in an array', async () => {
         await createTestEntities();
+        // Retrieving entity by array reference...
         const resultEntity = await nymph.getEntities({ class: TestModel }, { type: '&', ref: ['refArray', refGuid] });
         expect(testEntity.$inArray(resultEntity)).toEqual(true);
     });
     it('wrong ref in an array', async () => {
         await createTestEntities();
+        // Testing wrong array reference...
         const resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '&',
             ref: [
@@ -700,6 +813,7 @@ These hats are absolutely fantastic.`;
     });
     it('logic operations', async () => {
         await createTestEntities();
+        // Testing logic operations...
         const resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '&',
             '!ref': [
@@ -737,6 +851,7 @@ These hats are absolutely fantastic.`;
     it('count return', async () => {
         await createTestEntities();
         const result = await nymph.getEntities({ class: TestModel });
+        // Testing count return...
         const resultCount = await nymph.getEntities({
             class: TestModel,
             return: 'count',
@@ -744,25 +859,30 @@ These hats are absolutely fantastic.`;
         expect(resultCount).toBeGreaterThanOrEqual(1);
         expect(resultCount).toEqual(result.length);
         const resultSelectors = await nymph.getEntities({ class: TestModel }, { type: '&', ref: ['reference', refGuid] });
+        // Testing count return with selectors...
         const resultSelectorsCount = await nymph.getEntities({ class: TestModel, return: 'count' }, { type: '&', ref: ['reference', refGuid] });
         expect(resultSelectorsCount).toBeGreaterThanOrEqual(1);
         expect(resultSelectorsCount).toEqual(resultSelectors.length);
+        // Testing count return with limit...
         const resultSelectorsLimit = await nymph.getEntities({
             class: TestModel,
             limit: 1,
             return: 'count',
         });
         expect(resultSelectorsLimit).toEqual(1);
+        // Testing count return with limit...
         const resultSelectorsSingle = await nymph.getEntity({
             class: TestModel,
             return: 'count',
         });
         expect(resultSelectorsSingle).toEqual(1);
+        // Testing empty count...
         const resultSelectorsEmpty = await nymph.getEntities({ class: TestModel, return: 'count' }, { type: '&', ref: ['reference', (0, guid_1.guid)()] });
         expect(resultSelectorsEmpty).toEqual(0);
     });
     it('guid return', async () => {
         await createTestEntities();
+        // Testing guid return using logic operations...
         const resultGuid = await nymph.getEntities({ class: TestModel, return: 'guid' }, {
             type: '&',
             '!ref': [
@@ -799,6 +919,7 @@ These hats are absolutely fantastic.`;
     });
     it('deep selector', async () => {
         await createTestEntities();
+        // Testing deep selectors...
         const resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '&',
             '!ref': [
@@ -911,6 +1032,7 @@ These hats are absolutely fantastic.`;
         expect(testEntity.$inArray(resultEntity4)).toEqual(true);
     });
     it('wrong deep selector', async () => {
+        // Testing wrong deep selectors...
         const resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '&',
             selector: [
@@ -926,6 +1048,7 @@ These hats are absolutely fantastic.`;
     });
     it('qref', async () => {
         await createTestEntities();
+        // Retrieving entity by qref...
         const resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '&',
             qref: [
@@ -937,6 +1060,7 @@ These hats are absolutely fantastic.`;
     });
     it('not qref', async () => {
         await createTestEntities();
+        // Retrieving entity by !qref...
         const resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '&',
             '!qref': [
@@ -948,6 +1072,7 @@ These hats are absolutely fantastic.`;
     });
     it('wrong qref class', async () => {
         await createTestEntities();
+        // Testing wrong qref...
         const resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '&',
             qref: [
@@ -959,6 +1084,7 @@ These hats are absolutely fantastic.`;
     });
     it('wrong qref data', async () => {
         await createTestEntities();
+        // Testing wrong qref...
         const resultEntity = await nymph.getEntities({ class: TestModel }, {
             type: '&',
             qref: [
@@ -971,11 +1097,13 @@ These hats are absolutely fantastic.`;
     it('cdate and mdate sort option', async () => {
         await createMultipleTestEntities();
         for (const sort of ['cdate', 'mdate']) {
+            // Retrieving entities sorted...
             let resultEntities = await nymph.getEntities({ class: TestModel, sort });
             expect(resultEntities.length).toBeGreaterThan(100);
             for (let i = 0; i < resultEntities.length - 1; i++) {
                 expect(resultEntities[i + 1][sort]).toBeGreaterThan(resultEntities[i][sort] ?? 0);
             }
+            // And test the same with guid return...
             let resultGuids = await nymph.getEntities({
                 class: TestModel,
                 sort,
@@ -985,6 +1113,7 @@ These hats are absolutely fantastic.`;
             for (let i = 0; i < resultGuids.length - 1; i++) {
                 expect(resultGuids[i]).toEqual(resultEntities[i].guid);
             }
+            // Retrieving entities reverse sorted...
             resultEntities = await nymph.getEntities({
                 class: TestModel,
                 sort,
@@ -994,11 +1123,14 @@ These hats are absolutely fantastic.`;
             for (let i = 0; i < resultEntities.length - 1; i++) {
                 expect(resultEntities[i + 1][sort]).toBeLessThan(resultEntities[i][sort] ?? 0);
             }
+            // And again with other selectors.
+            // Retrieving entities sorted...
             resultEntities = await nymph.getEntities({ class: TestModel, sort }, { type: '&', match: ['name', '^Multi Test '] });
             expect(resultEntities.length).toEqual(100);
             for (let i = 0; i < resultEntities.length - 1; i++) {
                 expect(resultEntities[i + 1][sort]).toBeGreaterThan(resultEntities[i][sort] ?? 0);
             }
+            // Retrieving entities reverse sorted...
             resultEntities = await nymph.getEntities({ class: TestModel, sort, reverse: true }, { type: '&', match: ['name', '^Multi Test '] });
             expect(resultEntities.length).toEqual(100);
             for (let i = 0; i < resultEntities.length - 1; i++) {
@@ -1008,6 +1140,7 @@ These hats are absolutely fantastic.`;
     });
     it('property sort option', async () => {
         await createMultipleTestEntities();
+        // Retrieving entities sorted...
         let resultEntities = await nymph.getEntities({
             class: TestModel,
             sort: 'number',
@@ -1016,6 +1149,7 @@ These hats are absolutely fantastic.`;
         for (let i = 0; i < resultEntities.length - 1; i++) {
             expect(resultEntities[i + 1].number ?? Infinity).toBeGreaterThanOrEqual(resultEntities[i].number ?? 0);
         }
+        // And test the same with guid return...
         let resultGuids = await nymph.getEntities({
             class: TestModel,
             sort: 'number',
@@ -1025,6 +1159,7 @@ These hats are absolutely fantastic.`;
         for (let i = 0; i < resultGuids.length - 1; i++) {
             expect(resultGuids[i]).toEqual(resultEntities[i].guid);
         }
+        // Retrieving entities reverse sorted...
         resultEntities = await nymph.getEntities({
             class: TestModel,
             sort: 'number',
@@ -1034,12 +1169,15 @@ These hats are absolutely fantastic.`;
         for (let i = 0; i < resultEntities.length - 1; i++) {
             expect(resultEntities[i + 1].number ?? 0).toBeLessThanOrEqual(resultEntities[i].number ?? Infinity);
         }
+        // And again with other selectors.
+        // Retrieving entities sorted...
         resultEntities = await nymph.getEntities({ class: TestModel, sort: 'number' }, { type: '&', match: ['name', '^Multi Test '] });
         expect(resultEntities.length).toEqual(100);
         for (let i = 0; i < resultEntities.length - 1; i++) {
             expect(resultEntities[i + 1].number ?? Infinity).toBeGreaterThan(resultEntities[i].number ?? 0);
             expect(resultEntities[i].name).toEqual(`Multi Test ${100 - (resultEntities[i].number ?? 0)}`);
         }
+        // Retrieving entities reverse sorted...
         resultEntities = await nymph.getEntities({ class: TestModel, sort: 'number', reverse: true }, { type: '&', match: ['name', '^Multi Test '] });
         expect(resultEntities.length).toEqual(100);
         for (let i = 0; i < resultEntities.length - 1; i++) {
@@ -1049,6 +1187,7 @@ These hats are absolutely fantastic.`;
     });
     it('delete reference', async () => {
         await createTestEntities();
+        // Deleting referenced entities...
         await testEntity.reference?.$wake();
         expect(await testEntity.reference?.$delete()).toEqual(true);
         await Promise.all(testEntity.refArray?.map((e) => e.$wake()) || []);
@@ -1056,6 +1195,7 @@ These hats are absolutely fantastic.`;
     });
     it('delete', async () => {
         await createTestEntities();
+        // Deleting entity...
         expect(await testEntity.$delete()).toEqual(true);
         expect(testEntity.guid).toBeNull();
         const entity = await nymph.getEntity({ class: TestModel }, { type: '&', guid: testGuid });
@@ -1150,7 +1290,9 @@ function ExportImportTest(nymph, it) {
         expect(await nymph.newUID('TestUID2')).toEqual(1);
         for (let i = 0; i < 20; i++) {
             const EntityClass = i < 15 ? TestModel : TestBModel;
+            // Creating entity...
             const testEntity = await EntityClass.factory();
+            // Saving entity...
             testEntity.name = 'Entity Test ' + new Date().toLocaleString();
             testEntity.null = null;
             testEntity.string = 'test';