@nymphjs/nymph 1.0.0-beta.13 → 1.0.0-beta.130

package/src/Entity.test.ts

@@ -1,10 +1,14 @@
-import { MockNymph } from './testMocks';
+import { jest } from '@jest/globals';
+
+import { cloneDeep } from 'lodash-es';
+
+import { EntityConflictError } from './errors/index.js';
+import { MockNymph } from './testMocks.js';
 import {
   TestBModel as TestBModelClass,
   TestModel as TestModelClass,
   TestModelData,
-} from './testArtifacts';
-import { cloneDeep } from 'lodash';
+} from './testArtifacts.js';
 
 const nymph = new MockNymph();
 
@@ -41,22 +45,22 @@ describe('Entity', () => {
     expect(testEntity.array).toEqual(['full', 'of', 'values', 500]);
     expect(testEntity.number).toEqual(30);
 
-    expect(await testEntity.$save()).toEqual(true);
+    await testEntity.$save();
     expect(typeof testEntity.guid).toEqual('string');
 
     entityReferenceTest = await TestModel.factory();
     entityReferenceTest.string = 'wrong';
-    expect(await entityReferenceTest.$save()).toEqual(true);
+    await entityReferenceTest.$save();
     entityReferenceGuid = entityReferenceTest.guid as string;
     testEntity.reference = entityReferenceTest;
     testEntity.refArray = [entityReferenceTest];
     testEntity.refObject = {
       entity: entityReferenceTest,
     };
-    expect(await testEntity.$save()).toEqual(true);
+    await testEntity.$save();
 
     entityReferenceTest.test = 'good';
-    expect(await entityReferenceTest.$save()).toEqual(true);
+    await entityReferenceTest.$save();
   });
 
   it('comparisons work', async () => {
@@ -115,14 +119,14 @@ describe('Entity', () => {
   it('refresh updates', async () => {
     expect(testEntity.string).toEqual('test');
     testEntity.string = 'updated';
-    expect(await testEntity.$save()).toEqual(true);
+    await testEntity.$save();
     await testEntity.$refresh();
-    expect(await testEntity.$save()).toEqual(true);
+    await testEntity.$save();
 
     const retrieve = await TestModel.factory(testEntity.guid as string);
     expect(retrieve.string).toEqual('updated');
     retrieve.string = 'test';
-    expect(await retrieve.$save()).toBe(true);
+    await retrieve.$save();
 
     await testEntity.$refresh();
     expect(testEntity.string).toEqual('test');
@@ -132,17 +136,23 @@ describe('Entity', () => {
     await new Promise((resolve) => setTimeout(resolve, 500));
 
     const testEntityCopy = await TestModel.factory(testEntity.guid as string);
-    expect(await testEntityCopy.$save()).toEqual(true);
+    await testEntityCopy.$save();
     expect(testEntityCopy.mdate ?? 0).toBeGreaterThan(testEntity.mdate ?? 0);
 
     await new Promise((resolve) => setTimeout(resolve, 500));
 
-    expect(await testEntity.$save()).toEqual(false);
+    try {
+      await testEntity.$save();
+
+      throw new Error('Should have thrown.');
+    } catch (e: any) {
+      expect(e).toBeInstanceOf(EntityConflictError);
+    }
 
     await testEntity.$refresh();
 
     expect(testEntityCopy.mdate ?? Infinity).toBeLessThanOrEqual(
-      testEntity.mdate ?? 0
+      testEntity.mdate ?? 0,
     );
   });
 
@@ -156,13 +166,25 @@ describe('Entity', () => {
     ]);
   });
 
+  it('toReference works even on an unsaved entity', () => {
+    const unsavedEntity = TestModel.factorySync();
+    const reference = unsavedEntity.$toReference();
+
+    expect(unsavedEntity.guid).toBeNull();
+    expect(reference).toEqual([
+      'nymph_entity_reference',
+      unsavedEntity.$getGuaranteedGUID(),
+      'TestModel',
+    ]);
+  });
+
   it('tags work', async () => {
     expect(testEntity.$hasTag('test')).toEqual(true);
     testEntity.$addTag('test', 'test2');
     expect(testEntity.$hasTag('test', 'test2')).toEqual(true);
     testEntity.$addTag('test', 'test3', 'test4', 'test5', 'test6');
     expect(
-      testEntity.$hasTag('test', 'test3', 'test4', 'test5', 'test6')
+      testEntity.$hasTag('test', 'test3', 'test4', 'test5', 'test6'),
     ).toEqual(true);
     testEntity.$removeTag('test2');
     expect(testEntity.$hasTag('test2')).toEqual(false);
@@ -174,36 +196,43 @@ describe('Entity', () => {
 
     // Remove all tags.
     testEntity.$removeTag('test');
-    expect(await testEntity.$save()).toEqual(true);
+    await testEntity.$save();
     expect(await testEntity.$refresh()).toEqual(true);
     expect(testEntity.$hasTag('test')).toEqual(false);
     expect(testEntity.$getTags()).toEqual([]);
     testEntity.$addTag('test');
-    expect(await testEntity.$save()).toEqual(true);
+    await testEntity.$save();
     expect(testEntity.$hasTag('test')).toEqual(true);
   });
 
-  it('references works', async () => {
+  it('references work', async () => {
     await testEntity.$refresh();
 
+    await testEntity.reference?.$wake();
     expect(testEntity.reference?.guid).toEqual(entityReferenceGuid);
+    await Promise.all(testEntity.refArray?.map((e) => e.$wake()) || []);
     expect(testEntity.refArray?.[0].guid).toEqual(entityReferenceGuid);
+    await testEntity.refObject?.entity.$wake();
     expect(testEntity.refObject?.entity.guid).toEqual(entityReferenceGuid);
 
     const entity = await TestModel.factory(testEntity.guid as string);
 
+    await entity.reference?.$wake();
     expect(entity.reference?.guid).toEqual(entityReferenceGuid);
+    await Promise.all(entity.refArray?.map((e) => e.$wake()) || []);
     expect(entity.refArray?.[0].guid).toEqual(entityReferenceGuid);
+    await entity.refObject?.entity.$wake();
     expect(entity.refObject?.entity.guid).toEqual(entityReferenceGuid);
   });
 
-  it('sleeping references wake up', () => {
+  it('sleeping references wake up', async () => {
     const entity = TestModel.factoryReference([
       'nymph_entity_reference',
       testEntity.guid as string,
       'TestModel',
     ]) as TestModelClass & TestModelData;
 
+    await entity.$wake();
     expect(entity.guid).toEqual(testEntity.guid);
     expect(entity.cdate).toEqual(testEntity.cdate);
     expect(entity.mdate).toEqual(testEntity.mdate);
@@ -213,8 +242,11 @@ describe('Entity', () => {
     expect(entity.string).toEqual('test');
     expect(entity.array).toEqual(['full', 'of', 'values', 500]);
     expect(entity.number).toEqual(30);
+    await entity.reference?.$wake();
     expect(entity.reference?.guid).toEqual(entityReferenceGuid);
+    await Promise.all(entity.refArray?.map((e) => e.$wake()) || []);
     expect(entity.refArray?.[0].guid).toEqual(entityReferenceGuid);
+    await entity.refObject?.entity.$wake();
     expect(entity.refObject?.entity.guid).toEqual(entityReferenceGuid);
   });
 
@@ -239,8 +271,9 @@ describe('Entity', () => {
         array: ['full', 'of', 'values', 500],
         string: 'test',
         null: null,
+        uniques: [],
       },
-      class: 'TestModel',
+      class: ['nymph_class_reference', 'TestModel'],
     });
   });
 
@@ -288,8 +321,11 @@ describe('Entity', () => {
     expect(testEntity.string).toEqual('good');
     expect(testEntity.array).toEqual(['imanarray']);
     expect(testEntity.number).toEqual(30);
+    await testEntity.reference?.$wake();
     expect(testEntity.reference?.guid).toEqual(entityReferenceGuid);
+    await Promise.all(testEntity.refArray?.map((e) => e.$wake()) || []);
     expect(testEntity.refArray?.[0].guid).toEqual(entityReferenceGuid);
+    await testEntity.refObject?.entity.$wake();
     expect(testEntity.refObject?.entity.guid).toEqual(entityReferenceGuid);
 
     expect(await testEntity.$refresh()).toEqual(true);
@@ -297,7 +333,7 @@ describe('Entity', () => {
     testEntity.cdate = 13;
     testEntity.mdate = 14;
     testEntity.$jsonAcceptPatch({
-      class: TestModel.class,
+      class: TestModel,
       guid: testEntity.guid as string,
       mdate: 15,
       set: {
@@ -311,7 +347,9 @@ describe('Entity', () => {
     expect(testEntity.$hasTag('notag')).toEqual(false);
     expect(testEntity.$hasTag('test')).toEqual(true);
     expect(testEntity.$hasTag('newtag')).toEqual(true);
+    await testEntity.reference?.$wake();
     expect(testEntity.reference?.guid).toEqual(entityReferenceGuid);
+    await Promise.all(testEntity.refArray?.map((e) => e.$wake()) || []);
     expect(testEntity.refArray?.[0].guid).toEqual(entityReferenceGuid);
 
     expect(await testEntity.$refresh()).toEqual(true);
@@ -341,7 +379,7 @@ describe('Entity', () => {
     testEntity.cdate = 13;
     testEntity.mdate = 14;
     testEntity.$jsonAcceptPatch({
-      class: TestModel.class,
+      class: TestModel,
       guid: testEntity.guid as string,
       mdate: 15,
       set: {
@@ -365,7 +403,7 @@ describe('Entity', () => {
     // Test that an old JSON payload causes a conflict.
     const json = JSON.stringify(testEntity);
 
-    expect(await testEntity.$save()).toEqual(true);
+    await testEntity.$save();
 
     let thrown = false;
     let thrownName: string = '';
@@ -386,7 +424,7 @@ describe('Entity', () => {
 
     try {
       testEntity.$jsonAcceptPatch({
-        class: TestModel.class,
+        class: TestModel,
         guid: data.guid,
         mdate: data.mdate,
         set: {
@@ -403,4 +441,16 @@ describe('Entity', () => {
 
     expect(thrown).toEqual(true);
   });
+
+  it('JSON with new entities works', async () => {
+    testEntity.reference = await TestModel.factory();
+
+    // Test that an old JSON payload causes a conflict.
+    const json = JSON.stringify(testEntity);
+    const data = JSON.parse(json);
+
+    testEntity.$jsonAcceptData(data);
+
+    expect(testEntity.reference.guid).toBeNull();
+  });
 });