@expo/entity 0.39.0 → 0.41.0

package/src/__tests__/EnforcingEntityAssociationLoader-test.ts

@@ -0,0 +1,253 @@
+import { result } from '@expo/results';
+import { mock, instance, when, anything } from 'ts-mockito';
+
+import AuthorizationResultBasedEntityAssociationLoader from '../AuthorizationResultBasedEntityAssociationLoader';
+import EnforcingEntityAssociationLoader from '../EnforcingEntityAssociationLoader';
+
+describe(EnforcingEntityAssociationLoader, () => {
+  describe('loadAssociatedEntityAsync', () => {
+    it('throws when result is unsuccessful', async () => {
+      const nonEnforcingEntityAssociationLoaderMock =
+        mock<AuthorizationResultBasedEntityAssociationLoader<any, any, any, any, any>>();
+      const rejection = new Error();
+      when(
+        nonEnforcingEntityAssociationLoaderMock.loadAssociatedEntityAsync(anything(), anything()),
+      ).thenResolve(result(rejection));
+      const nonEnforcingEntityAssociationLoader = instance(nonEnforcingEntityAssociationLoaderMock);
+      const enforcingEntityAssociationLoader = new EnforcingEntityAssociationLoader(
+        nonEnforcingEntityAssociationLoader,
+      );
+      await expect(
+        enforcingEntityAssociationLoader.loadAssociatedEntityAsync(anything(), anything()),
+      ).rejects.toThrow(rejection);
+    });
+
+    it('returns value when result is successful', async () => {
+      const nonEnforcingEntityAssociationLoaderMock =
+        mock<AuthorizationResultBasedEntityAssociationLoader<any, any, any, any, any>>();
+      const resolved = {} as any;
+      when(
+        nonEnforcingEntityAssociationLoaderMock.loadAssociatedEntityAsync(anything(), anything()),
+      ).thenResolve(result(resolved));
+      const nonEnforcingEntityAssociationLoader = instance(nonEnforcingEntityAssociationLoaderMock);
+      const enforcingEntityLoader = new EnforcingEntityAssociationLoader(
+        nonEnforcingEntityAssociationLoader,
+      );
+      await expect(
+        enforcingEntityLoader.loadAssociatedEntityAsync(anything(), anything()),
+      ).resolves.toEqual(resolved);
+    });
+  });
+
+  describe('loadManyAssociatedEntitiesAsync', () => {
+    it('throws when result is unsuccessful', async () => {
+      const nonEnforcingEntityAssociationLoaderMock =
+        mock<AuthorizationResultBasedEntityAssociationLoader<any, any, any, any, any>>();
+      const rejection = new Error();
+      when(
+        nonEnforcingEntityAssociationLoaderMock.loadManyAssociatedEntitiesAsync(
+          anything(),
+          anything() as never,
+        ),
+      ).thenResolve([result(rejection)]);
+      const nonEnforcingEntityAssociationLoader = instance(nonEnforcingEntityAssociationLoaderMock);
+      const enforcingEntityAssociationLoader = new EnforcingEntityAssociationLoader(
+        nonEnforcingEntityAssociationLoader,
+      );
+      await expect(
+        enforcingEntityAssociationLoader.loadManyAssociatedEntitiesAsync(
+          anything(),
+          anything() as never,
+        ),
+      ).rejects.toThrow(rejection);
+    });
+
+    it('returns value when result is successful', async () => {
+      const nonEnforcingEntityAssociationLoaderMock =
+        mock<AuthorizationResultBasedEntityAssociationLoader<any, any, any, any, any>>();
+      const resolved = [] as any;
+      when(
+        nonEnforcingEntityAssociationLoaderMock.loadManyAssociatedEntitiesAsync(
+          anything(),
+          anything() as never,
+        ),
+      ).thenResolve([result(resolved)]);
+      const nonEnforcingEntityAssociationLoader = instance(nonEnforcingEntityAssociationLoaderMock);
+      const enforcingEntityLoader = new EnforcingEntityAssociationLoader(
+        nonEnforcingEntityAssociationLoader,
+      );
+      await expect(
+        enforcingEntityLoader.loadManyAssociatedEntitiesAsync(anything(), anything() as never),
+      ).resolves.toEqual([resolved]);
+    });
+  });
+
+  describe('loadAssociatedEntityByFieldEqualingAsync', () => {
+    it('throws when result is unsuccessful', async () => {
+      const nonEnforcingEntityAssociationLoaderMock =
+        mock<AuthorizationResultBasedEntityAssociationLoader<any, any, any, any, any>>();
+      const rejection = new Error();
+      when(
+        nonEnforcingEntityAssociationLoaderMock.loadAssociatedEntityByFieldEqualingAsync(
+          anything(),
+          anything(),
+          anything() as never,
+        ),
+      ).thenResolve(result(rejection));
+      const nonEnforcingEntityAssociationLoader = instance(nonEnforcingEntityAssociationLoaderMock);
+      const enforcingEntityAssociationLoader = new EnforcingEntityAssociationLoader(
+        nonEnforcingEntityAssociationLoader,
+      );
+      await expect(
+        enforcingEntityAssociationLoader.loadAssociatedEntityByFieldEqualingAsync(
+          anything(),
+          anything(),
+          anything() as never,
+        ),
+      ).rejects.toThrow(rejection);
+    });
+
+    it('returns value when result is successful', async () => {
+      const nonEnforcingEntityAssociationLoaderMock =
+        mock<AuthorizationResultBasedEntityAssociationLoader<any, any, any, any, any>>();
+      const resolved = {} as any;
+      when(
+        nonEnforcingEntityAssociationLoaderMock.loadAssociatedEntityByFieldEqualingAsync(
+          anything(),
+          anything(),
+          anything() as never,
+        ),
+      ).thenResolve(result(resolved));
+      const nonEnforcingEntityAssociationLoader = instance(nonEnforcingEntityAssociationLoaderMock);
+      const enforcingEntityLoader = new EnforcingEntityAssociationLoader(
+        nonEnforcingEntityAssociationLoader,
+      );
+      await expect(
+        enforcingEntityLoader.loadAssociatedEntityByFieldEqualingAsync(
+          anything(),
+          anything(),
+          anything() as never,
+        ),
+      ).resolves.toEqual(resolved);
+    });
+
+    it('returns null when result is successful but null', async () => {
+      const nonEnforcingEntityAssociationLoaderMock =
+        mock<AuthorizationResultBasedEntityAssociationLoader<any, any, any, any, any>>();
+      const resolved = null;
+      when(
+        nonEnforcingEntityAssociationLoaderMock.loadAssociatedEntityByFieldEqualingAsync(
+          anything(),
+          anything(),
+          anything() as never,
+        ),
+      ).thenResolve(resolved);
+      const nonEnforcingEntityAssociationLoader = instance(nonEnforcingEntityAssociationLoaderMock);
+      const enforcingEntityLoader = new EnforcingEntityAssociationLoader(
+        nonEnforcingEntityAssociationLoader,
+      );
+      await expect(
+        enforcingEntityLoader.loadAssociatedEntityByFieldEqualingAsync(
+          anything(),
+          anything(),
+          anything() as never,
+        ),
+      ).resolves.toEqual(resolved);
+    });
+  });
+
+  describe('loadManyAssociatedEntitiesByFieldEqualingAsync', () => {
+    it('throws when result is unsuccessful', async () => {
+      const nonEnforcingEntityAssociationLoaderMock =
+        mock<AuthorizationResultBasedEntityAssociationLoader<any, any, any, any, any>>();
+      const rejection = new Error();
+      when(
+        nonEnforcingEntityAssociationLoaderMock.loadManyAssociatedEntitiesByFieldEqualingAsync(
+          anything(),
+          anything(),
+          anything() as never,
+        ),
+      ).thenResolve([result(rejection)]);
+      const nonEnforcingEntityAssociationLoader = instance(nonEnforcingEntityAssociationLoaderMock);
+      const enforcingEntityAssociationLoader = new EnforcingEntityAssociationLoader(
+        nonEnforcingEntityAssociationLoader,
+      );
+      await expect(
+        enforcingEntityAssociationLoader.loadManyAssociatedEntitiesByFieldEqualingAsync(
+          anything(),
+          anything(),
+          anything() as never,
+        ),
+      ).rejects.toThrow(rejection);
+    });
+
+    it('returns value when result is successful', async () => {
+      const nonEnforcingEntityAssociationLoaderMock =
+        mock<AuthorizationResultBasedEntityAssociationLoader<any, any, any, any, any>>();
+      const resolved = [] as any;
+      when(
+        nonEnforcingEntityAssociationLoaderMock.loadManyAssociatedEntitiesByFieldEqualingAsync(
+          anything(),
+          anything(),
+          anything() as never,
+        ),
+      ).thenResolve([result(resolved)]);
+      const nonEnforcingEntityAssociationLoader = instance(nonEnforcingEntityAssociationLoaderMock);
+      const enforcingEntityLoader = new EnforcingEntityAssociationLoader(
+        nonEnforcingEntityAssociationLoader,
+      );
+      await expect(
+        enforcingEntityLoader.loadManyAssociatedEntitiesByFieldEqualingAsync(
+          anything(),
+          anything(),
+          anything() as never,
+        ),
+      ).resolves.toEqual([resolved]);
+    });
+  });
+
+  describe('loadAssociatedEntityThroughAsync', () => {
+    it('throws when result is unsuccessful', async () => {
+      const nonEnforcingEntityAssociationLoaderMock =
+        mock<AuthorizationResultBasedEntityAssociationLoader<any, any, any, any, any>>();
+      const rejection = new Error();
+      when(
+        nonEnforcingEntityAssociationLoaderMock.loadAssociatedEntityThroughAsync(anything()),
+      ).thenResolve(result(rejection));
+      const nonEnforcingEntityAssociationLoader = instance(nonEnforcingEntityAssociationLoaderMock);
+      const enforcingEntityAssociationLoader = new EnforcingEntityAssociationLoader(
+        nonEnforcingEntityAssociationLoader,
+      );
+      await expect(
+        enforcingEntityAssociationLoader.loadAssociatedEntityThroughAsync(anything()),
+      ).rejects.toThrow(rejection);
+    });
+
+    it('returns value when result is successful', async () => {
+      const nonEnforcingEntityAssociationLoaderMock =
+        mock<AuthorizationResultBasedEntityAssociationLoader<any, any, any, any, any>>();
+      const resolved = {} as any;
+      when(
+        nonEnforcingEntityAssociationLoaderMock.loadAssociatedEntityThroughAsync(anything()),
+      ).thenResolve(result(resolved));
+      const nonEnforcingEntityAssociationLoader = instance(nonEnforcingEntityAssociationLoaderMock);
+      const enforcingEntityLoader = new EnforcingEntityAssociationLoader(
+        nonEnforcingEntityAssociationLoader,
+      );
+      await expect(
+        enforcingEntityLoader.loadAssociatedEntityThroughAsync(anything()),
+      ).resolves.toEqual(resolved);
+    });
+  });
+
+  it('has the same method names as AuthorizationResultBasedEntityAssociationLoader', () => {
+    const enforcingLoaderProperties = Object.getOwnPropertyNames(
+      EnforcingEntityAssociationLoader.prototype,
+    );
+    const nonEnforcingLoaderProperties = Object.getOwnPropertyNames(
+      AuthorizationResultBasedEntityAssociationLoader.prototype,
+    );
+
+    expect(enforcingLoaderProperties).toEqual(nonEnforcingLoaderProperties);
+  });
+});

package/src/__tests__/Entity-test.ts

@@ -1,20 +1,90 @@
+import {
+  AuthorizationResultBasedCreateMutator,
+  AuthorizationResultBasedDeleteMutator,
+  AuthorizationResultBasedUpdateMutator,
+} from '../AuthorizationResultBasedEntityMutator';
+import EnforcingEntityCreator from '../EnforcingEntityCreator';
+import EnforcingEntityDeleter from '../EnforcingEntityDeleter';
+import EnforcingEntityUpdater from '../EnforcingEntityUpdater';
 import Entity from '../Entity';
-import { CreateMutator, UpdateMutator } from '../EntityMutator';
 import ViewerContext from '../ViewerContext';
 import SimpleTestEntity from '../testfixtures/SimpleTestEntity';
 import { createUnitTestEntityCompanionProvider } from '../utils/testing/createUnitTestEntityCompanionProvider';
 
 describe(Entity, () => {
   describe('creator', () => {
-    it('creates a new CreateMutator', () => {
+    it('creates a new EnforcingEntityCreator', () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new ViewerContext(companionProvider);
-      expect(SimpleTestEntity.creator(viewerContext)).toBeInstanceOf(CreateMutator);
+      expect(SimpleTestEntity.creator(viewerContext)).toBeInstanceOf(EnforcingEntityCreator);
+    });
+  });
+
+  describe('creatorWithAuthorizationResults', () => {
+    it('creates a new AuthorizationResultBasedCreateMutator', () => {
+      const companionProvider = createUnitTestEntityCompanionProvider();
+      const viewerContext = new ViewerContext(companionProvider);
+      expect(SimpleTestEntity.creatorWithAuthorizationResults(viewerContext)).toBeInstanceOf(
+        AuthorizationResultBasedCreateMutator,
+      );
     });
   });
 
   describe('updater', () => {
-    it('creates a new UpdateMutator', () => {
+    it('creates a new EnforcingEntityUpdater', () => {
+      const companionProvider = createUnitTestEntityCompanionProvider();
+      const viewerContext = new ViewerContext(companionProvider);
+      const data = {
+        id: 'what',
+      };
+      const testEntity = new SimpleTestEntity({
+        viewerContext,
+        id: 'what',
+        databaseFields: data,
+        selectedFields: data,
+      });
+      expect(SimpleTestEntity.updater(testEntity)).toBeInstanceOf(EnforcingEntityUpdater);
+    });
+  });
+
+  describe('updaterWithAuthorizationResults', () => {
+    it('creates a new AuthorizationResultBasedUpdateMutator', () => {
+      const companionProvider = createUnitTestEntityCompanionProvider();
+      const viewerContext = new ViewerContext(companionProvider);
+      const data = {
+        id: 'what',
+      };
+      const testEntity = new SimpleTestEntity({
+        viewerContext,
+        id: 'what',
+        databaseFields: data,
+        selectedFields: data,
+      });
+      expect(SimpleTestEntity.updaterWithAuthorizationResults(testEntity)).toBeInstanceOf(
+        AuthorizationResultBasedUpdateMutator,
+      );
+    });
+  });
+
+  describe('deleter', () => {
+    it('creates a new EnforcingEntityDeleter', () => {
+      const companionProvider = createUnitTestEntityCompanionProvider();
+      const viewerContext = new ViewerContext(companionProvider);
+      const data = {
+        id: 'what',
+      };
+      const testEntity = new SimpleTestEntity({
+        viewerContext,
+        id: 'what',
+        databaseFields: data,
+        selectedFields: data,
+      });
+      expect(SimpleTestEntity.deleter(testEntity)).toBeInstanceOf(EnforcingEntityDeleter);
+    });
+  });
+
+  describe('deleterWithAuthorizationResults', () => {
+    it('creates a new AuthorizationResultBasedDeleteMutator', () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new ViewerContext(companionProvider);
       const data = {
@@ -26,7 +96,9 @@ describe(Entity, () => {
         databaseFields: data,
         selectedFields: data,
       });
-      expect(SimpleTestEntity.updater(testEntity)).toBeInstanceOf(UpdateMutator);
+      expect(SimpleTestEntity.deleterWithAuthorizationResults(testEntity)).toBeInstanceOf(
+        AuthorizationResultBasedDeleteMutator,
+      );
     });
   });
 });

package/src/__tests__/EntityAssociationLoader-test.ts

@@ -1,273 +1,28 @@
-import { enforceAsyncResult } from '@expo/results';
-import { v4 as uuidv4 } from 'uuid';
-
+import AuthorizationResultBasedEntityAssociationLoader from '../AuthorizationResultBasedEntityAssociationLoader';
+import EnforcingEntityAssociationLoader from '../EnforcingEntityAssociationLoader';
 import EntityAssociationLoader from '../EntityAssociationLoader';
-import { enforceResultsAsync } from '../entityUtils';
-import TestEntity from '../testfixtures/TestEntity';
-import TestEntity2 from '../testfixtures/TestEntity2';
-import TestViewerContext from '../testfixtures/TestViewerContext';
+import ViewerContext from '../ViewerContext';
+import SimpleTestEntity from '../testfixtures/SimpleTestEntity';
 import { createUnitTestEntityCompanionProvider } from '../utils/testing/createUnitTestEntityCompanionProvider';
 
 describe(EntityAssociationLoader, () => {
-  describe('loadAssociatedEntityAsync', () => {
-    it('loads associated entities by ID and correctly handles a null value', async () => {
-      const companionProvider = createUnitTestEntityCompanionProvider();
-      const viewerContext = new TestViewerContext(companionProvider);
-      const testOtherEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).createAsync(),
-      );
-      const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext)
-          .setField('stringField', testOtherEntity.getID())
-          .createAsync(),
-      );
-      const loadedOther = await enforceAsyncResult(
-        testEntity.associationLoader().loadAssociatedEntityAsync('stringField', TestEntity),
-      );
-      expect(loadedOther.getID()).toEqual(testOtherEntity.getID());
-
-      const loadedOther2 = await enforceAsyncResult(
-        testEntity.associationLoader().loadAssociatedEntityAsync('nullableField', TestEntity),
-      );
-      expect(loadedOther2).toBeNull();
-    });
-  });
-
-  describe('loadManyAssociatedEntitiesAsync', () => {
-    it('loads many associated entities referencing this entity', async () => {
-      const companionProvider = createUnitTestEntityCompanionProvider();
-      const viewerContext = new TestViewerContext(companionProvider);
-      const testEntity = await enforceAsyncResult(TestEntity.creator(viewerContext).createAsync());
-      const testOtherEntity1 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).setField('stringField', testEntity.getID()).createAsync(),
-      );
-      const testOtherEntity2 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).setField('stringField', testEntity.getID()).createAsync(),
-      );
-      const loaded = await enforceResultsAsync(
-        testEntity.associationLoader().loadManyAssociatedEntitiesAsync(TestEntity, 'stringField'),
-      );
-      expect(loaded).toHaveLength(2);
-      expect(loaded.find((e) => e.getID() === testOtherEntity1.getID())).not.toBeUndefined();
-      expect(loaded.find((e) => e.getID() === testOtherEntity2.getID())).not.toBeUndefined();
-    });
-  });
-
-  describe('loadAssociatedEntityByFieldEqualingAsync', () => {
-    it('loads associated entity by field equaling', async () => {
-      const companionProvider = createUnitTestEntityCompanionProvider();
-      const viewerContext = new TestViewerContext(companionProvider);
-      const testOtherEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).createAsync(),
-      );
-      const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext)
-          .setField('stringField', testOtherEntity.getID())
-          .createAsync(),
-      );
-      const loadedOtherResult = await testEntity
-        .associationLoader()
-        .loadAssociatedEntityByFieldEqualingAsync('stringField', TestEntity, 'customIdField');
-      expect(loadedOtherResult?.enforceValue().getID()).toEqual(testOtherEntity.getID());
-    });
-
-    it('returns null when loading associated entities by field equaling a non existent association', async () => {
-      const companionProvider = createUnitTestEntityCompanionProvider();
-      const viewerContext = new TestViewerContext(companionProvider);
-      const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).setField('stringField', uuidv4()).createAsync(),
-      );
-      const loadedOtherResult = await testEntity
-        .associationLoader()
-        .loadAssociatedEntityByFieldEqualingAsync('stringField', TestEntity, 'customIdField');
-      expect(loadedOtherResult).toBeNull();
-    });
-
-    it('returns null when load-by field is null', async () => {
-      const companionProvider = createUnitTestEntityCompanionProvider();
-      const viewerContext = new TestViewerContext(companionProvider);
-      const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).setField('stringField', 'blah').createAsync(),
-      );
-      const loadedOtherResult = await testEntity
-        .associationLoader()
-        .loadAssociatedEntityByFieldEqualingAsync('nullableField', TestEntity, 'customIdField');
-      expect(loadedOtherResult).toBeNull();
-    });
-  });
-
-  describe('loadManyAssociatedEntitiesByFieldEqualingAsync', () => {
-    it('loads many associated entities by field equaling', async () => {
-      const companionProvider = createUnitTestEntityCompanionProvider();
-      const viewerContext = new TestViewerContext(companionProvider);
-      const testEntity = await enforceAsyncResult(TestEntity.creator(viewerContext).createAsync());
-      const testOtherEntity1 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).setField('stringField', testEntity.getID()).createAsync(),
-      );
-      const testOtherEntity2 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).setField('stringField', testEntity.getID()).createAsync(),
-      );
-      const loaded = await enforceResultsAsync(
-        testEntity
-          .associationLoader()
-          .loadManyAssociatedEntitiesByFieldEqualingAsync(
-            'customIdField',
-            TestEntity,
-            'stringField',
-          ),
-      );
-      expect(loaded).toHaveLength(2);
-      expect(loaded.find((e) => e.getID() === testOtherEntity1.getID())).not.toBeUndefined();
-      expect(loaded.find((e) => e.getID() === testOtherEntity2.getID())).not.toBeUndefined();
-    });
-
-    it('returns empty results when field being queried by is null', async () => {
+  describe('enforcing', () => {
+    it('creates a new EnforcingEntityLoader', async () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
-      const viewerContext = new TestViewerContext(companionProvider);
-      const testEntity = await enforceAsyncResult(TestEntity.creator(viewerContext).createAsync());
-      const loaded = await enforceResultsAsync(
-        testEntity
-          .associationLoader()
-          .loadManyAssociatedEntitiesByFieldEqualingAsync(
-            'nullableField',
-            TestEntity,
-            'stringField',
-          ),
-      );
-      expect(loaded).toHaveLength(0);
+      const viewerContext = new ViewerContext(companionProvider);
+      const testEntity = await SimpleTestEntity.creator(viewerContext).createAsync();
+      expect(testEntity.associationLoader()).toBeInstanceOf(EnforcingEntityAssociationLoader);
     });
   });
 
-  describe('loadAssociatedEntityThroughAsync', () => {
-    it('chain loads associated entities', async () => {
-      const companionProvider = createUnitTestEntityCompanionProvider();
-      const viewerContext = new TestViewerContext(companionProvider);
-      const testEntity4 = await enforceAsyncResult(TestEntity.creator(viewerContext).createAsync());
-      const testEntity3 = await enforceAsyncResult(
-        TestEntity2.creator(viewerContext)
-          .setField('foreignKey', testEntity4.getID())
-          .createAsync(),
-      );
-      const testEntity2 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext)
-          .setField('testIndexedField', testEntity3.getID())
-          .createAsync(),
-      );
-      const testEntity = await enforceAsyncResult(
-        TestEntity2.creator(viewerContext)
-          .setField('foreignKey', testEntity2.getID())
-          .createAsync(),
-      );
-
-      const loaded2Result = await testEntity.associationLoader().loadAssociatedEntityThroughAsync([
-        {
-          associatedEntityClass: TestEntity,
-          fieldIdentifyingAssociatedEntity: 'foreignKey',
-        },
-      ]);
-      expect(loaded2Result?.enforceValue().getID()).toEqual(testEntity2.getID());
-
-      const loaded3Result = await testEntity.associationLoader().loadAssociatedEntityThroughAsync([
-        {
-          associatedEntityClass: TestEntity,
-          fieldIdentifyingAssociatedEntity: 'foreignKey',
-        },
-        {
-          associatedEntityClass: TestEntity2,
-          fieldIdentifyingAssociatedEntity: 'testIndexedField',
-        },
-      ]);
-      expect(loaded3Result?.enforceValue().getID()).toEqual(testEntity3.getID());
-
-      const loaded4Result = await testEntity.associationLoader().loadAssociatedEntityThroughAsync([
-        {
-          associatedEntityClass: TestEntity,
-          fieldIdentifyingAssociatedEntity: 'foreignKey',
-        },
-        {
-          associatedEntityClass: TestEntity2,
-          fieldIdentifyingAssociatedEntity: 'testIndexedField',
-        },
-        {
-          associatedEntityClass: TestEntity,
-          fieldIdentifyingAssociatedEntity: 'foreignKey',
-        },
-      ]);
-      expect(loaded4Result?.enforceValue().getID()).toEqual(testEntity4.getID());
-    });
-
-    it('fails when chain loading associated entity fails', async () => {
-      const companionProvider = createUnitTestEntityCompanionProvider();
-      const viewerContext = new TestViewerContext(companionProvider);
-
-      const testEntity = await enforceAsyncResult(
-        TestEntity2.creator(viewerContext).setField('foreignKey', uuidv4()).createAsync(),
-      );
-
-      const loadResult = await testEntity.associationLoader().loadAssociatedEntityThroughAsync([
-        {
-          associatedEntityClass: TestEntity,
-          fieldIdentifyingAssociatedEntity: 'foreignKey',
-        },
-      ]);
-      expect(loadResult?.ok).toBe(false);
-    });
-
-    it('supports chain loading by field equality', async () => {
+  describe('withAuthorizationResults', () => {
+    it('creates a new AuthorizationResultBasedEntityAssociationLoader', async () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
-      const viewerContext = new TestViewerContext(companionProvider);
-
-      const fieldValue = uuidv4();
-      const testEntity2 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).setField('stringField', fieldValue).createAsync(),
+      const viewerContext = new ViewerContext(companionProvider);
+      const testEntity = await SimpleTestEntity.creator(viewerContext).createAsync();
+      expect(testEntity.associationLoaderWithAuthorizationResults()).toBeInstanceOf(
+        AuthorizationResultBasedEntityAssociationLoader,
       );
-      const testEntity = await enforceAsyncResult(
-        TestEntity2.creator(viewerContext).setField('foreignKey', fieldValue).createAsync(),
-      );
-
-      const loaded2Result = await testEntity.associationLoader().loadAssociatedEntityThroughAsync([
-        {
-          associatedEntityClass: TestEntity,
-          fieldIdentifyingAssociatedEntity: 'foreignKey',
-          associatedEntityLookupByField: 'stringField',
-        },
-      ]);
-      expect(loaded2Result?.enforceValue().getID()).toEqual(testEntity2.getID());
-    });
-
-    it('returns null when chain loading by field equality returns null', async () => {
-      const companionProvider = createUnitTestEntityCompanionProvider();
-      const viewerContext = new TestViewerContext(companionProvider);
-
-      const testEntity = await enforceAsyncResult(
-        TestEntity2.creator(viewerContext).setField('foreignKey', uuidv4()).createAsync(),
-      );
-
-      const loaded2Result = await testEntity.associationLoader().loadAssociatedEntityThroughAsync([
-        {
-          associatedEntityClass: TestEntity,
-          fieldIdentifyingAssociatedEntity: 'foreignKey',
-          associatedEntityLookupByField: 'stringField',
-        },
-      ]);
-      expect(loaded2Result).toBeNull();
-    });
-
-    it('returns null when chain loading by field is null', async () => {
-      const companionProvider = createUnitTestEntityCompanionProvider();
-      const viewerContext = new TestViewerContext(companionProvider);
-
-      const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext).setField('nullableField', null).createAsync(),
-      );
-
-      const loadedResult = await testEntity.associationLoader().loadAssociatedEntityThroughAsync([
-        {
-          associatedEntityClass: TestEntity,
-          fieldIdentifyingAssociatedEntity: 'nullableField',
-        },
-      ]);
-      expect(loadedResult).toBeNull();
     });
   });
 });