@expo/entity 0.34.0 → 0.36.0

package/src/__tests__/Entity-test.ts

@@ -1,30 +1,22 @@
 import Entity from '../Entity';
-import { EntityCompanionDefinition } from '../EntityCompanionProvider';
-import EntityConfiguration from '../EntityConfiguration';
-import { UUIDField } from '../EntityFields';
 import { CreateMutator, UpdateMutator } from '../EntityMutator';
-import EntityPrivacyPolicy from '../EntityPrivacyPolicy';
-import AlwaysAllowPrivacyPolicyRule from '../rules/AlwaysAllowPrivacyPolicyRule';
-import AlwaysDenyPrivacyPolicyRule from '../rules/AlwaysDenyPrivacyPolicyRule';
+import ViewerContext from '../ViewerContext';
 import SimpleTestEntity from '../testfixtures/SimpleTestEntity';
-import TestViewerContext from '../testfixtures/TestViewerContext';
 import { createUnitTestEntityCompanionProvider } from '../utils/testing/createUnitTestEntityCompanionProvider';
 
 describe(Entity, () => {
   describe('creator', () => {
     it('creates a new CreateMutator', () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
-      const viewerContext = new TestViewerContext(companionProvider);
-      expect(
-        SimpleTestEntity.creator(viewerContext, viewerContext.getQueryContext())
-      ).toBeInstanceOf(CreateMutator);
+      const viewerContext = new ViewerContext(companionProvider);
+      expect(SimpleTestEntity.creator(viewerContext)).toBeInstanceOf(CreateMutator);
     });
   });
 
   describe('updater', () => {
     it('creates a new UpdateMutator', () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
-      const viewerContext = new TestViewerContext(companionProvider);
+      const viewerContext = new ViewerContext(companionProvider);
       const data = {
         id: 'what',
       };
@@ -34,217 +26,7 @@ describe(Entity, () => {
         databaseFields: data,
         selectedFields: data,
       });
-      expect(SimpleTestEntity.updater(testEntity, viewerContext.getQueryContext())).toBeInstanceOf(
-        UpdateMutator
-      );
-    });
-  });
-
-  describe('canViewerUpdateAsync', () => {
-    it('appropriately executes update privacy policy', async () => {
-      const companionProvider = createUnitTestEntityCompanionProvider();
-      const viewerContext = new TestViewerContext(companionProvider);
-      const data = {
-        id: 'what',
-      };
-      const testEntity = new SimpleTestDenyDeleteEntity({
-        viewerContext,
-        id: 'what',
-        databaseFields: data,
-        selectedFields: data,
-      });
-      const canViewerUpdate = await SimpleTestDenyDeleteEntity.canViewerUpdateAsync(
-        testEntity,
-        viewerContext.getQueryContext()
-      );
-      expect(canViewerUpdate).toBe(true);
-    });
-
-    it('denies when policy denies', async () => {
-      const companionProvider = createUnitTestEntityCompanionProvider();
-      const viewerContext = new TestViewerContext(companionProvider);
-      const data = {
-        id: 'what',
-      };
-      const testEntity = new SimpleTestDenyUpdateEntity({
-        viewerContext,
-        id: 'what',
-        databaseFields: data,
-        selectedFields: data,
-      });
-      const canViewerUpdate = await SimpleTestDenyUpdateEntity.canViewerUpdateAsync(
-        testEntity,
-        viewerContext.getQueryContext()
-      );
-      expect(canViewerUpdate).toBe(false);
-    });
-  });
-
-  describe('canViewerDeleteAsync', () => {
-    it('appropriately executes update privacy policy', async () => {
-      const companionProvider = createUnitTestEntityCompanionProvider();
-      const viewerContext = new TestViewerContext(companionProvider);
-      const data = {
-        id: 'what',
-      };
-      const testEntity = new SimpleTestDenyUpdateEntity({
-        viewerContext,
-        id: 'what',
-        databaseFields: data,
-        selectedFields: data,
-      });
-      const canViewerDelete = await SimpleTestDenyUpdateEntity.canViewerDeleteAsync(
-        testEntity,
-        viewerContext.getQueryContext()
-      );
-      expect(canViewerDelete).toBe(true);
-    });
-
-    it('denies when policy denies', async () => {
-      const companionProvider = createUnitTestEntityCompanionProvider();
-      const viewerContext = new TestViewerContext(companionProvider);
-      const data = {
-        id: 'what',
-      };
-      const testEntity = new SimpleTestDenyDeleteEntity({
-        viewerContext,
-        id: 'what',
-        databaseFields: data,
-        selectedFields: data,
-      });
-      const canViewerDelete = await SimpleTestDenyDeleteEntity.canViewerDeleteAsync(
-        testEntity,
-        viewerContext.getQueryContext()
-      );
-      expect(canViewerDelete).toBe(false);
+      expect(SimpleTestEntity.updater(testEntity)).toBeInstanceOf(UpdateMutator);
     });
   });
 });
-
-type TestEntityFields = {
-  id: string;
-};
-
-const testEntityConfiguration = new EntityConfiguration<TestEntityFields>({
-  idField: 'id',
-  tableName: 'blah',
-  schema: {
-    id: new UUIDField({
-      columnName: 'custom_id',
-    }),
-  },
-  databaseAdapterFlavor: 'postgres',
-  cacheAdapterFlavor: 'redis',
-});
-
-class SimpleTestDenyUpdateEntityPrivacyPolicy extends EntityPrivacyPolicy<
-  TestEntityFields,
-  string,
-  TestViewerContext,
-  SimpleTestDenyUpdateEntity
-> {
-  protected override readonly readRules = [
-    new AlwaysAllowPrivacyPolicyRule<
-      TestEntityFields,
-      string,
-      TestViewerContext,
-      SimpleTestDenyUpdateEntity
-    >(),
-  ];
-  protected override readonly createRules = [
-    new AlwaysAllowPrivacyPolicyRule<
-      TestEntityFields,
-      string,
-      TestViewerContext,
-      SimpleTestDenyUpdateEntity
-    >(),
-  ];
-  protected override readonly updateRules = [
-    new AlwaysDenyPrivacyPolicyRule<
-      TestEntityFields,
-      string,
-      TestViewerContext,
-      SimpleTestDenyUpdateEntity
-    >(),
-  ];
-  protected override readonly deleteRules = [
-    new AlwaysAllowPrivacyPolicyRule<
-      TestEntityFields,
-      string,
-      TestViewerContext,
-      SimpleTestDenyUpdateEntity
-    >(),
-  ];
-}
-
-class SimpleTestDenyDeleteEntityPrivacyPolicy extends EntityPrivacyPolicy<
-  TestEntityFields,
-  string,
-  TestViewerContext,
-  SimpleTestDenyDeleteEntity
-> {
-  protected override readonly readRules = [
-    new AlwaysAllowPrivacyPolicyRule<
-      TestEntityFields,
-      string,
-      TestViewerContext,
-      SimpleTestDenyDeleteEntity
-    >(),
-  ];
-  protected override readonly createRules = [
-    new AlwaysAllowPrivacyPolicyRule<
-      TestEntityFields,
-      string,
-      TestViewerContext,
-      SimpleTestDenyDeleteEntity
-    >(),
-  ];
-  protected override readonly updateRules = [
-    new AlwaysAllowPrivacyPolicyRule<
-      TestEntityFields,
-      string,
-      TestViewerContext,
-      SimpleTestDenyDeleteEntity
-    >(),
-  ];
-  protected override readonly deleteRules = [
-    new AlwaysDenyPrivacyPolicyRule<
-      TestEntityFields,
-      string,
-      TestViewerContext,
-      SimpleTestDenyDeleteEntity
-    >(),
-  ];
-}
-
-class SimpleTestDenyUpdateEntity extends Entity<TestEntityFields, string, TestViewerContext> {
-  static defineCompanionDefinition(): EntityCompanionDefinition<
-    TestEntityFields,
-    string,
-    TestViewerContext,
-    SimpleTestDenyUpdateEntity,
-    SimpleTestDenyUpdateEntityPrivacyPolicy
-  > {
-    return {
-      entityClass: SimpleTestDenyUpdateEntity,
-      entityConfiguration: testEntityConfiguration,
-      privacyPolicyClass: SimpleTestDenyUpdateEntityPrivacyPolicy,
-    };
-  }
-}
-
-class SimpleTestDenyDeleteEntity extends Entity<TestEntityFields, string, TestViewerContext> {
-  static defineCompanionDefinition(): EntityCompanionDefinition<
-    TestEntityFields,
-    string,
-    TestViewerContext,
-    SimpleTestDenyDeleteEntity,
-    SimpleTestDenyDeleteEntityPrivacyPolicy
-  > {
-    return {
-      entityClass: SimpleTestDenyDeleteEntity,
-      entityConfiguration: testEntityConfiguration,
-      privacyPolicyClass: SimpleTestDenyDeleteEntityPrivacyPolicy,
-    };
-  }
-}

package/src/__tests__/EntityAssociationLoader-test.ts

@@ -14,24 +14,20 @@ describe(EntityAssociationLoader, () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new TestViewerContext(companionProvider);
       const testOtherEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext, viewerContext.getQueryContext()).createAsync()
+        TestEntity.creator(viewerContext).createAsync(),
       );
       const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext, viewerContext.getQueryContext())
+        TestEntity.creator(viewerContext)
           .setField('stringField', testOtherEntity.getID())
-          .createAsync()
+          .createAsync(),
       );
       const loadedOther = await enforceAsyncResult(
-        testEntity
-          .associationLoader()
-          .loadAssociatedEntityAsync('stringField', TestEntity, viewerContext.getQueryContext())
+        testEntity.associationLoader().loadAssociatedEntityAsync('stringField', TestEntity),
       );
       expect(loadedOther.getID()).toEqual(testOtherEntity.getID());
 
       const loadedOther2 = await enforceAsyncResult(
-        testEntity
-          .associationLoader()
-          .loadAssociatedEntityAsync('nullableField', TestEntity, viewerContext.getQueryContext())
+        testEntity.associationLoader().loadAssociatedEntityAsync('nullableField', TestEntity),
       );
       expect(loadedOther2).toBeNull();
     });
@@ -41,27 +37,15 @@ describe(EntityAssociationLoader, () => {
     it('loads many associated entities referencing this entity', async () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new TestViewerContext(companionProvider);
-      const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext, viewerContext.getQueryContext()).createAsync()
-      );
+      const testEntity = await enforceAsyncResult(TestEntity.creator(viewerContext).createAsync());
       const testOtherEntity1 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext, viewerContext.getQueryContext())
-          .setField('stringField', testEntity.getID())
-          .createAsync()
+        TestEntity.creator(viewerContext).setField('stringField', testEntity.getID()).createAsync(),
       );
       const testOtherEntity2 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext, viewerContext.getQueryContext())
-          .setField('stringField', testEntity.getID())
-          .createAsync()
+        TestEntity.creator(viewerContext).setField('stringField', testEntity.getID()).createAsync(),
       );
       const loaded = await enforceResultsAsync(
-        testEntity
-          .associationLoader()
-          .loadManyAssociatedEntitiesAsync(
-            TestEntity,
-            'stringField',
-            viewerContext.getQueryContext()
-          )
+        testEntity.associationLoader().loadManyAssociatedEntitiesAsync(TestEntity, 'stringField'),
       );
       expect(loaded).toHaveLength(2);
       expect(loaded.find((e) => e.getID() === testOtherEntity1.getID())).not.toBeUndefined();
@@ -74,21 +58,16 @@ describe(EntityAssociationLoader, () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new TestViewerContext(companionProvider);
       const testOtherEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext, viewerContext.getQueryContext()).createAsync()
+        TestEntity.creator(viewerContext).createAsync(),
       );
       const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext, viewerContext.getQueryContext())
+        TestEntity.creator(viewerContext)
           .setField('stringField', testOtherEntity.getID())
-          .createAsync()
+          .createAsync(),
       );
       const loadedOtherResult = await testEntity
         .associationLoader()
-        .loadAssociatedEntityByFieldEqualingAsync(
-          'stringField',
-          TestEntity,
-          'customIdField',
-          viewerContext.getQueryContext()
-        );
+        .loadAssociatedEntityByFieldEqualingAsync('stringField', TestEntity, 'customIdField');
       expect(loadedOtherResult?.enforceValue().getID()).toEqual(testOtherEntity.getID());
     });
 
@@ -96,18 +75,11 @@ describe(EntityAssociationLoader, () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new TestViewerContext(companionProvider);
       const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext, viewerContext.getQueryContext())
-          .setField('stringField', uuidv4())
-          .createAsync()
+        TestEntity.creator(viewerContext).setField('stringField', uuidv4()).createAsync(),
       );
       const loadedOtherResult = await testEntity
         .associationLoader()
-        .loadAssociatedEntityByFieldEqualingAsync(
-          'stringField',
-          TestEntity,
-          'customIdField',
-          viewerContext.getQueryContext()
-        );
+        .loadAssociatedEntityByFieldEqualingAsync('stringField', TestEntity, 'customIdField');
       expect(loadedOtherResult).toBeNull();
     });
 
@@ -115,18 +87,11 @@ describe(EntityAssociationLoader, () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new TestViewerContext(companionProvider);
       const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext, viewerContext.getQueryContext())
-          .setField('stringField', 'blah')
-          .createAsync()
+        TestEntity.creator(viewerContext).setField('stringField', 'blah').createAsync(),
       );
       const loadedOtherResult = await testEntity
         .associationLoader()
-        .loadAssociatedEntityByFieldEqualingAsync(
-          'nullableField',
-          TestEntity,
-          'customIdField',
-          viewerContext.getQueryContext()
-        );
+        .loadAssociatedEntityByFieldEqualingAsync('nullableField', TestEntity, 'customIdField');
       expect(loadedOtherResult).toBeNull();
     });
   });
@@ -135,18 +100,12 @@ describe(EntityAssociationLoader, () => {
     it('loads many associated entities by field equaling', async () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new TestViewerContext(companionProvider);
-      const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext, viewerContext.getQueryContext()).createAsync()
-      );
+      const testEntity = await enforceAsyncResult(TestEntity.creator(viewerContext).createAsync());
       const testOtherEntity1 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext, viewerContext.getQueryContext())
-          .setField('stringField', testEntity.getID())
-          .createAsync()
+        TestEntity.creator(viewerContext).setField('stringField', testEntity.getID()).createAsync(),
       );
       const testOtherEntity2 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext, viewerContext.getQueryContext())
-          .setField('stringField', testEntity.getID())
-          .createAsync()
+        TestEntity.creator(viewerContext).setField('stringField', testEntity.getID()).createAsync(),
       );
       const loaded = await enforceResultsAsync(
         testEntity
@@ -155,8 +114,7 @@ describe(EntityAssociationLoader, () => {
             'customIdField',
             TestEntity,
             'stringField',
-            viewerContext.getQueryContext()
-          )
+          ),
       );
       expect(loaded).toHaveLength(2);
       expect(loaded.find((e) => e.getID() === testOtherEntity1.getID())).not.toBeUndefined();
@@ -166,9 +124,7 @@ describe(EntityAssociationLoader, () => {
     it('returns empty results when field being queried by is null', async () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new TestViewerContext(companionProvider);
-      const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext, viewerContext.getQueryContext()).createAsync()
-      );
+      const testEntity = await enforceAsyncResult(TestEntity.creator(viewerContext).createAsync());
       const loaded = await enforceResultsAsync(
         testEntity
           .associationLoader()
@@ -176,8 +132,7 @@ describe(EntityAssociationLoader, () => {
             'nullableField',
             TestEntity,
             'stringField',
-            viewerContext.getQueryContext()
-          )
+          ),
       );
       expect(loaded).toHaveLength(0);
     });
@@ -187,68 +142,57 @@ describe(EntityAssociationLoader, () => {
     it('chain loads associated entities', async () => {
       const companionProvider = createUnitTestEntityCompanionProvider();
       const viewerContext = new TestViewerContext(companionProvider);
-      const testEntity4 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext, viewerContext.getQueryContext()).createAsync()
-      );
+      const testEntity4 = await enforceAsyncResult(TestEntity.creator(viewerContext).createAsync());
       const testEntity3 = await enforceAsyncResult(
-        TestEntity2.creator(viewerContext, viewerContext.getQueryContext())
+        TestEntity2.creator(viewerContext)
           .setField('foreignKey', testEntity4.getID())
-          .createAsync()
+          .createAsync(),
       );
       const testEntity2 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext, viewerContext.getQueryContext())
+        TestEntity.creator(viewerContext)
           .setField('testIndexedField', testEntity3.getID())
-          .createAsync()
+          .createAsync(),
       );
       const testEntity = await enforceAsyncResult(
-        TestEntity2.creator(viewerContext, viewerContext.getQueryContext())
+        TestEntity2.creator(viewerContext)
           .setField('foreignKey', testEntity2.getID())
-          .createAsync()
+          .createAsync(),
       );
 
-      const loaded2Result = await testEntity.associationLoader().loadAssociatedEntityThroughAsync(
-        [
-          {
-            associatedEntityClass: TestEntity,
-            fieldIdentifyingAssociatedEntity: 'foreignKey',
-          },
-        ],
-        viewerContext.getQueryContext()
-      );
+      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',
-          },
-        ],
-        viewerContext.getQueryContext()
-      );
+      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',
-          },
-        ],
-        viewerContext.getQueryContext()
-      );
+      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());
     });
 
@@ -257,20 +201,15 @@ describe(EntityAssociationLoader, () => {
       const viewerContext = new TestViewerContext(companionProvider);
 
       const testEntity = await enforceAsyncResult(
-        TestEntity2.creator(viewerContext, viewerContext.getQueryContext())
-          .setField('foreignKey', uuidv4())
-          .createAsync()
+        TestEntity2.creator(viewerContext).setField('foreignKey', uuidv4()).createAsync(),
       );
 
-      const loadResult = await testEntity.associationLoader().loadAssociatedEntityThroughAsync(
-        [
-          {
-            associatedEntityClass: TestEntity,
-            fieldIdentifyingAssociatedEntity: 'foreignKey',
-          },
-        ],
-        viewerContext.getQueryContext()
-      );
+      const loadResult = await testEntity.associationLoader().loadAssociatedEntityThroughAsync([
+        {
+          associatedEntityClass: TestEntity,
+          fieldIdentifyingAssociatedEntity: 'foreignKey',
+        },
+      ]);
       expect(loadResult?.ok).toBe(false);
     });
 
@@ -280,26 +219,19 @@ describe(EntityAssociationLoader, () => {
 
       const fieldValue = uuidv4();
       const testEntity2 = await enforceAsyncResult(
-        TestEntity.creator(viewerContext, viewerContext.getQueryContext())
-          .setField('stringField', fieldValue)
-          .createAsync()
+        TestEntity.creator(viewerContext).setField('stringField', fieldValue).createAsync(),
       );
       const testEntity = await enforceAsyncResult(
-        TestEntity2.creator(viewerContext, viewerContext.getQueryContext())
-          .setField('foreignKey', fieldValue)
-          .createAsync()
+        TestEntity2.creator(viewerContext).setField('foreignKey', fieldValue).createAsync(),
       );
 
-      const loaded2Result = await testEntity.associationLoader().loadAssociatedEntityThroughAsync(
-        [
-          {
-            associatedEntityClass: TestEntity,
-            fieldIdentifyingAssociatedEntity: 'foreignKey',
-            associatedEntityLookupByField: 'stringField',
-          },
-        ],
-        viewerContext.getQueryContext()
-      );
+      const loaded2Result = await testEntity.associationLoader().loadAssociatedEntityThroughAsync([
+        {
+          associatedEntityClass: TestEntity,
+          fieldIdentifyingAssociatedEntity: 'foreignKey',
+          associatedEntityLookupByField: 'stringField',
+        },
+      ]);
       expect(loaded2Result?.enforceValue().getID()).toEqual(testEntity2.getID());
     });
 
@@ -308,21 +240,16 @@ describe(EntityAssociationLoader, () => {
       const viewerContext = new TestViewerContext(companionProvider);
 
       const testEntity = await enforceAsyncResult(
-        TestEntity2.creator(viewerContext, viewerContext.getQueryContext())
-          .setField('foreignKey', uuidv4())
-          .createAsync()
+        TestEntity2.creator(viewerContext).setField('foreignKey', uuidv4()).createAsync(),
       );
 
-      const loaded2Result = await testEntity.associationLoader().loadAssociatedEntityThroughAsync(
-        [
-          {
-            associatedEntityClass: TestEntity,
-            fieldIdentifyingAssociatedEntity: 'foreignKey',
-            associatedEntityLookupByField: 'stringField',
-          },
-        ],
-        viewerContext.getQueryContext()
-      );
+      const loaded2Result = await testEntity.associationLoader().loadAssociatedEntityThroughAsync([
+        {
+          associatedEntityClass: TestEntity,
+          fieldIdentifyingAssociatedEntity: 'foreignKey',
+          associatedEntityLookupByField: 'stringField',
+        },
+      ]);
       expect(loaded2Result).toBeNull();
     });
 
@@ -331,20 +258,15 @@ describe(EntityAssociationLoader, () => {
       const viewerContext = new TestViewerContext(companionProvider);
 
       const testEntity = await enforceAsyncResult(
-        TestEntity.creator(viewerContext, viewerContext.getQueryContext())
-          .setField('nullableField', null)
-          .createAsync()
+        TestEntity.creator(viewerContext).setField('nullableField', null).createAsync(),
       );
 
-      const loadedResult = await testEntity.associationLoader().loadAssociatedEntityThroughAsync(
-        [
-          {
-            associatedEntityClass: TestEntity,
-            fieldIdentifyingAssociatedEntity: 'nullableField',
-          },
-        ],
-        viewerContext.getQueryContext()
-      );
+      const loadedResult = await testEntity.associationLoader().loadAssociatedEntityThroughAsync([
+        {
+          associatedEntityClass: TestEntity,
+          fieldIdentifyingAssociatedEntity: 'nullableField',
+        },
+      ]);
       expect(loadedResult).toBeNull();
     });
   });