@expo/entity 0.34.0 → 0.36.0

package/src/__tests__/EntityLoader-test.ts

@@ -5,7 +5,9 @@ import { v4 as uuidv4 } from 'uuid';
 import { OrderByOrdering } from '../EntityDatabaseAdapter';
 import EntityLoader from '../EntityLoader';
 import { EntityPrivacyPolicyEvaluationContext } from '../EntityPrivacyPolicy';
+import ViewerContext from '../ViewerContext';
 import { enforceResultsAsync } from '../entityUtils';
+import EntityNotFoundError from '../errors/EntityNotFoundError';
 import EntityDataManager from '../internal/EntityDataManager';
 import ReadThroughEntityCache from '../internal/ReadThroughEntityCache';
 import IEntityMetricsAdapter from '../metrics/IEntityMetricsAdapter';
@@ -14,7 +16,6 @@ import TestEntity, {
   TestEntityPrivacyPolicy,
   testEntityConfiguration,
 } from '../testfixtures/TestEntity';
-import TestViewerContext from '../testfixtures/TestViewerContext';
 import { NoCacheStubCacheAdapterProvider } from '../utils/testing/StubCacheAdapter';
 import StubDatabaseAdapter from '../utils/testing/StubDatabaseAdapter';
 import StubQueryContextProvider from '../utils/testing/StubQueryContextProvider';
@@ -22,10 +23,13 @@ import StubQueryContextProvider from '../utils/testing/StubQueryContextProvider'
 describe(EntityLoader, () => {
   it('loads entities', async () => {
     const dateToInsert = new Date();
-    const viewerContext = instance(mock(TestViewerContext));
-    const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
+    const viewerContext = instance(mock(ViewerContext));
+    const privacyPolicyEvaluationContext =
+      instance(
+        mock<EntityPrivacyPolicyEvaluationContext<TestFields, string, ViewerContext, TestEntity>>(),
+      );
     const metricsAdapter = instance(mock<IEntityMetricsAdapter>());
-    const queryContext = StubQueryContextProvider.getNonTransactionalQueryContext();
+    const queryContext = StubQueryContextProvider.getQueryContext();
 
     const id1 = uuidv4();
     const id2 = uuidv4();
@@ -55,8 +59,8 @@ describe(EntityLoader, () => {
               },
             ],
           ],
-        ])
-      )
+        ]),
+      ),
     );
     const privacyPolicy = new TestEntityPrivacyPolicy();
     const cacheAdapterProvider = new NoCacheStubCacheAdapterProvider();
@@ -67,7 +71,7 @@ describe(EntityLoader, () => {
       entityCache,
       StubQueryContextProvider,
       instance(mock<IEntityMetricsAdapter>()),
-      TestEntity.name
+      TestEntity.name,
     );
     const entityLoader = new EntityLoader(
       viewerContext,
@@ -78,22 +82,28 @@ describe(EntityLoader, () => {
       /* entitySelectedFields */ undefined,
       privacyPolicy,
       dataManager,
-      metricsAdapter
+      metricsAdapter,
+    );
+    const entity = await enforceAsyncResult(
+      entityLoader.withAuthorizationResults().loadByIDAsync(id1),
     );
-    const entity = await enforceAsyncResult(entityLoader.loadByIDAsync(id1));
     expect(entity.getID()).toEqual(id1);
     expect(entity.getField('dateField')).toEqual(dateToInsert);
 
     const entities = await enforceResultsAsync(
-      entityLoader.loadManyByFieldEqualingAsync('stringField', 'huh')
+      entityLoader.withAuthorizationResults().loadManyByFieldEqualingAsync('stringField', 'huh'),
     );
     expect(entities.map((m) => m.getID())).toEqual([id1, id2]);
 
-    const entityResultNumber3 = await entityLoader.loadByFieldEqualingAsync('intField', 3);
+    const entityResultNumber3 = await entityLoader
+      .withAuthorizationResults()
+      .loadByFieldEqualingAsync('intField', 3);
     expect(entityResultNumber3).not.toBeNull();
     expect(entityResultNumber3!.enforceValue().getID()).toEqual(id2);
 
-    const entityResultNumber4 = await entityLoader.loadByFieldEqualingAsync('intField', 4);
+    const entityResultNumber4 = await entityLoader
+      .withAuthorizationResults()
+      .loadByFieldEqualingAsync('intField', 4);
     expect(entityResultNumber4).toBeNull();
 
     const entityResultDuplicateValues = await entityLoader
@@ -102,25 +112,45 @@ describe(EntityLoader, () => {
     expect(entityResultDuplicateValues.size).toBe(1);
     expect(entityResultDuplicateValues.get('huh')?.map((m) => m.getID())).toEqual([id1, id2]);
 
-    await expect(entityLoader.loadByFieldEqualingAsync('stringField', 'huh')).rejects.toThrowError(
-      'loadByFieldEqualing: Multiple entities of type TestEntity found for stringField=huh'
+    await expect(
+      entityLoader.withAuthorizationResults().loadByFieldEqualingAsync('stringField', 'huh'),
+    ).rejects.toThrowError(
+      'loadByFieldEqualing: Multiple entities of type TestEntity found for stringField=huh',
     );
 
-    await expect(entityLoader.loadByIDNullableAsync(uuidv4())).resolves.toBeNull();
-    await expect(entityLoader.loadByIDNullableAsync(id1)).resolves.not.toBeNull();
+    await expect(
+      entityLoader.withAuthorizationResults().loadByIDNullableAsync(uuidv4()),
+    ).resolves.toBeNull();
+    await expect(
+      entityLoader.withAuthorizationResults().loadByIDNullableAsync(id1),
+    ).resolves.not.toBeNull();
 
-    await expect(entityLoader.loadByIDAsync('not-a-uuid')).rejects.toThrowError(
-      'Entity field not valid: TestEntity (customIdField = not-a-uuid)'
-    );
+    const nonExistentId = uuidv4();
+    const manyIdResults = await entityLoader
+      .withAuthorizationResults()
+      .loadManyByIDsNullableAsync([nonExistentId, id1]);
+    expect(manyIdResults.get(nonExistentId)).toBeNull();
+    expect(manyIdResults.get(id1)).not.toBeNull();
+
+    await expect(
+      enforceAsyncResult(entityLoader.withAuthorizationResults().loadByIDAsync(nonExistentId)),
+    ).rejects.toThrow(EntityNotFoundError);
+
+    await expect(
+      entityLoader.withAuthorizationResults().loadByIDAsync('not-a-uuid'),
+    ).rejects.toThrowError('Entity field not valid: TestEntity (customIdField = not-a-uuid)');
   });
 
   it('loads entities with loadManyByFieldEqualityConjunction', async () => {
     const privacyPolicy = new TestEntityPrivacyPolicy();
     const spiedPrivacyPolicy = spy(privacyPolicy);
-    const viewerContext = instance(mock(TestViewerContext));
-    const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
+    const viewerContext = instance(mock(ViewerContext));
+    const privacyPolicyEvaluationContext =
+      instance(
+        mock<EntityPrivacyPolicyEvaluationContext<TestFields, string, ViewerContext, TestEntity>>(),
+      );
     const metricsAdapter = instance(mock<IEntityMetricsAdapter>());
-    const queryContext = StubQueryContextProvider.getNonTransactionalQueryContext();
+    const queryContext = StubQueryContextProvider.getQueryContext();
 
     const id1 = uuidv4();
     const id2 = uuidv4();
@@ -159,8 +189,8 @@ describe(EntityLoader, () => {
               },
             ],
           ],
-        ])
-      )
+        ]),
+      ),
     );
     const cacheAdapterProvider = new NoCacheStubCacheAdapterProvider();
     const cacheAdapter = cacheAdapterProvider.getCacheAdapter(testEntityConfiguration);
@@ -170,7 +200,7 @@ describe(EntityLoader, () => {
       entityCache,
       StubQueryContextProvider,
       instance(mock<IEntityMetricsAdapter>()),
-      TestEntity.name
+      TestEntity.name,
     );
     const entityLoader = new EntityLoader(
       viewerContext,
@@ -181,19 +211,19 @@ describe(EntityLoader, () => {
       /* entitySelectedFields */ undefined,
       privacyPolicy,
       dataManager,
-      metricsAdapter
+      metricsAdapter,
     );
     const entities = await enforceResultsAsync(
-      entityLoader.loadManyByFieldEqualityConjunctionAsync([
+      entityLoader.withAuthorizationResults().loadManyByFieldEqualityConjunctionAsync([
         {
           fieldName: 'stringField',
           fieldValue: 'huh',
         },
         {
           fieldName: 'intField',
-          fieldValue: 4,
+          fieldValues: [4],
         },
-      ])
+      ]),
     );
     expect(entities).toHaveLength(2);
     verify(
@@ -202,24 +232,29 @@ describe(EntityLoader, () => {
         queryContext,
         privacyPolicyEvaluationContext,
         anyOfClass(TestEntity),
-        anything()
-      )
+        anything(),
+      ),
     ).twice();
 
     await expect(
-      entityLoader.loadManyByFieldEqualityConjunctionAsync([
-        { fieldName: 'customIdField', fieldValue: 'not-a-uuid' },
-      ])
+      entityLoader
+        .withAuthorizationResults()
+        .loadManyByFieldEqualityConjunctionAsync([
+          { fieldName: 'customIdField', fieldValue: 'not-a-uuid' },
+        ]),
     ).rejects.toThrowError('Entity field not valid: TestEntity (customIdField = not-a-uuid)');
   });
 
   it('loads entities with loadFirstByFieldEqualityConjunction', async () => {
     const privacyPolicy = new TestEntityPrivacyPolicy();
     const spiedPrivacyPolicy = spy(privacyPolicy);
-    const viewerContext = instance(mock(TestViewerContext));
-    const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
+    const viewerContext = instance(mock(ViewerContext));
+    const privacyPolicyEvaluationContext =
+      instance(
+        mock<EntityPrivacyPolicyEvaluationContext<TestFields, string, ViewerContext, TestEntity>>(),
+      );
     const metricsAdapter = instance(mock<IEntityMetricsAdapter>());
-    const queryContext = StubQueryContextProvider.getNonTransactionalQueryContext();
+    const queryContext = StubQueryContextProvider.getQueryContext();
 
     const id1 = uuidv4();
     const id2 = uuidv4();
@@ -258,8 +293,8 @@ describe(EntityLoader, () => {
               },
             ],
           ],
-        ])
-      )
+        ]),
+      ),
     );
     const cacheAdapterProvider = new NoCacheStubCacheAdapterProvider();
     const cacheAdapter = cacheAdapterProvider.getCacheAdapter(testEntityConfiguration);
@@ -269,7 +304,7 @@ describe(EntityLoader, () => {
       entityCache,
       StubQueryContextProvider,
       instance(mock<IEntityMetricsAdapter>()),
-      TestEntity.name
+      TestEntity.name,
     );
     const entityLoader = new EntityLoader(
       viewerContext,
@@ -280,21 +315,23 @@ describe(EntityLoader, () => {
       /* entitySelectedFields */ undefined,
       privacyPolicy,
       dataManager,
-      metricsAdapter
-    );
-    const result = await entityLoader.loadFirstByFieldEqualityConjunctionAsync(
-      [
-        {
-          fieldName: 'stringField',
-          fieldValue: 'huh',
-        },
-        {
-          fieldName: 'intField',
-          fieldValue: 4,
-        },
-      ],
-      { orderBy: [{ fieldName: 'testIndexedField', order: OrderByOrdering.DESCENDING }] }
+      metricsAdapter,
     );
+    const result = await entityLoader
+      .withAuthorizationResults()
+      .loadFirstByFieldEqualityConjunctionAsync(
+        [
+          {
+            fieldName: 'stringField',
+            fieldValue: 'huh',
+          },
+          {
+            fieldName: 'intField',
+            fieldValue: 4,
+          },
+        ],
+        { orderBy: [{ fieldName: 'testIndexedField', order: OrderByOrdering.DESCENDING }] },
+      );
     expect(result).not.toBeNull();
     expect(result!.ok).toBe(true);
     expect(result!.enforceValue().getField('testIndexedField')).toEqual('5');
@@ -304,8 +341,69 @@ describe(EntityLoader, () => {
         queryContext,
         privacyPolicyEvaluationContext,
         anyOfClass(TestEntity),
-        anything()
-      )
+        anything(),
+      ),
+    ).once();
+  });
+
+  it('loads entities with loadManyByRawWhereClauseAsync', async () => {
+    const privacyPolicy = new TestEntityPrivacyPolicy();
+    const spiedPrivacyPolicy = spy(privacyPolicy);
+    const viewerContext = instance(mock(ViewerContext));
+    const privacyPolicyEvaluationContext =
+      instance(
+        mock<EntityPrivacyPolicyEvaluationContext<TestFields, string, ViewerContext, TestEntity>>(),
+      );
+    const metricsAdapter = instance(mock<IEntityMetricsAdapter>());
+    const queryContext = StubQueryContextProvider.getQueryContext();
+
+    const dataManagerMock = mock<EntityDataManager<TestFields>>(EntityDataManager);
+    when(
+      dataManagerMock.loadManyByRawWhereClauseAsync(
+        queryContext,
+        anything(),
+        anything(),
+        anything(),
+      ),
+    ).thenResolve([
+      {
+        customIdField: 'id',
+        stringField: 'huh',
+        intField: 4,
+        testIndexedField: '4',
+        dateField: new Date(),
+        nullableField: null,
+      },
+    ]);
+    const dataManager = instance(dataManagerMock);
+    const entityLoader = new EntityLoader(
+      viewerContext,
+      queryContext,
+      privacyPolicyEvaluationContext,
+      testEntityConfiguration,
+      TestEntity,
+      /* entitySelectedFields */ undefined,
+      privacyPolicy,
+      dataManager,
+      metricsAdapter,
+    );
+    const result = await entityLoader
+      .withAuthorizationResults()
+      .loadManyByRawWhereClauseAsync('id = ?', [1], {
+        orderBy: [{ fieldName: 'testIndexedField', order: OrderByOrdering.DESCENDING }],
+      });
+    expect(result).toHaveLength(1);
+    expect(result[0]).not.toBeNull();
+    expect(result[0]!.ok).toBe(true);
+    expect(result[0]!.enforceValue().getField('testIndexedField')).toEqual('4');
+    verify(
+      spiedPrivacyPolicy.authorizeReadAsync(
+        viewerContext,
+        queryContext,
+        privacyPolicyEvaluationContext,
+        anyOfClass(TestEntity),
+        anything(),
+      ),
     ).once();
   });
 
@@ -313,10 +411,13 @@ describe(EntityLoader, () => {
     const privacyPolicy = new TestEntityPrivacyPolicy();
     const spiedPrivacyPolicy = spy(privacyPolicy);
 
-    const viewerContext = instance(mock(TestViewerContext));
-    const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
+    const viewerContext = instance(mock(ViewerContext));
+    const privacyPolicyEvaluationContext =
+      instance(
+        mock<EntityPrivacyPolicyEvaluationContext<TestFields, string, ViewerContext, TestEntity>>(),
+      );
     const metricsAdapter = instance(mock<IEntityMetricsAdapter>());
-    const queryContext = StubQueryContextProvider.getNonTransactionalQueryContext();
+    const queryContext = StubQueryContextProvider.getQueryContext();
 
     const id1 = uuidv4();
     const databaseAdapter = new StubDatabaseAdapter<TestFields>(
@@ -337,8 +438,8 @@ describe(EntityLoader, () => {
               },
             ],
           ],
-        ])
-      )
+        ]),
+      ),
     );
     const cacheAdapterProvider = new NoCacheStubCacheAdapterProvider();
     const cacheAdapter = cacheAdapterProvider.getCacheAdapter(testEntityConfiguration);
@@ -348,7 +449,7 @@ describe(EntityLoader, () => {
       entityCache,
       StubQueryContextProvider,
       instance(mock<IEntityMetricsAdapter>()),
-      TestEntity.name
+      TestEntity.name,
     );
     const entityLoader = new EntityLoader(
       viewerContext,
@@ -359,25 +460,30 @@ describe(EntityLoader, () => {
       /* entitySelectedFields */ undefined,
       privacyPolicy,
       dataManager,
-      metricsAdapter
+      metricsAdapter,
+    );
+    const entity = await enforceAsyncResult(
+      entityLoader.withAuthorizationResults().loadByIDAsync(id1),
     );
-    const entity = await enforceAsyncResult(entityLoader.loadByIDAsync(id1));
     verify(
       spiedPrivacyPolicy.authorizeReadAsync(
         viewerContext,
         queryContext,
         privacyPolicyEvaluationContext,
         entity,
-        anything()
-      )
+        anything(),
+      ),
     ).once();
   });
 
   it('invalidates upon invalidate one', async () => {
-    const viewerContext = instance(mock(TestViewerContext));
-    const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
+    const viewerContext = instance(mock(ViewerContext));
+    const privacyPolicyEvaluationContext =
+      instance(
+        mock<EntityPrivacyPolicyEvaluationContext<TestFields, string, ViewerContext, TestEntity>>(),
+      );
     const metricsAdapter = instance(mock<IEntityMetricsAdapter>());
-    const queryContext = StubQueryContextProvider.getNonTransactionalQueryContext();
+    const queryContext = StubQueryContextProvider.getQueryContext();
     const privacyPolicy = instance(mock(TestEntityPrivacyPolicy));
     const dataManagerMock = mock<EntityDataManager<TestFields>>();
     const dataManagerInstance = instance(dataManagerMock);
@@ -392,20 +498,23 @@ describe(EntityLoader, () => {
       /* entitySelectedFields */ undefined,
       privacyPolicy,
       dataManagerInstance,
-      metricsAdapter
+      metricsAdapter,
     );
-    await entityLoader.invalidateFieldsAsync({ customIdField: id1 } as any);
+    await entityLoader.utils().invalidateFieldsAsync({ customIdField: id1 } as any);
 
     verify(
-      dataManagerMock.invalidateObjectFieldsAsync(deepEqual({ customIdField: id1 } as any))
+      dataManagerMock.invalidateObjectFieldsAsync(deepEqual({ customIdField: id1 } as any)),
     ).once();
   });
 
   it('invalidates upon invalidate by field', async () => {
-    const viewerContext = instance(mock(TestViewerContext));
-    const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
+    const viewerContext = instance(mock(ViewerContext));
+    const privacyPolicyEvaluationContext =
+      instance(
+        mock<EntityPrivacyPolicyEvaluationContext<TestFields, string, ViewerContext, TestEntity>>(),
+      );
     const metricsAdapter = instance(mock<IEntityMetricsAdapter>());
-    const queryContext = StubQueryContextProvider.getNonTransactionalQueryContext();
+    const queryContext = StubQueryContextProvider.getQueryContext();
     const privacyPolicy = instance(mock(TestEntityPrivacyPolicy));
     const dataManagerMock = mock<EntityDataManager<TestFields>>();
     const dataManagerInstance = instance(dataManagerMock);
@@ -420,19 +529,22 @@ describe(EntityLoader, () => {
       /* entitySelectedFields */ undefined,
       privacyPolicy,
       dataManagerInstance,
-      metricsAdapter
+      metricsAdapter,
     );
-    await entityLoader.invalidateFieldsAsync({ customIdField: id1 } as any);
+    await entityLoader.utils().invalidateFieldsAsync({ customIdField: id1 } as any);
     verify(
-      dataManagerMock.invalidateObjectFieldsAsync(deepEqual({ customIdField: id1 } as any))
+      dataManagerMock.invalidateObjectFieldsAsync(deepEqual({ customIdField: id1 } as any)),
     ).once();
   });
 
   it('invalidates upon invalidate by entity', async () => {
-    const viewerContext = instance(mock(TestViewerContext));
-    const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
+    const viewerContext = instance(mock(ViewerContext));
+    const privacyPolicyEvaluationContext =
+      instance(
+        mock<EntityPrivacyPolicyEvaluationContext<TestFields, string, ViewerContext, TestEntity>>(),
+      );
     const metricsAdapter = instance(mock<IEntityMetricsAdapter>());
-    const queryContext = StubQueryContextProvider.getNonTransactionalQueryContext();
+    const queryContext = StubQueryContextProvider.getQueryContext();
     const privacyPolicy = instance(mock(TestEntityPrivacyPolicy));
     const dataManagerMock = mock<EntityDataManager<TestFields>>();
     const dataManagerInstance = instance(dataManagerMock);
@@ -451,25 +563,28 @@ describe(EntityLoader, () => {
       /* entitySelectedFields */ undefined,
       privacyPolicy,
       dataManagerInstance,
-      metricsAdapter
+      metricsAdapter,
     );
-    await entityLoader.invalidateEntityAsync(entityInstance);
+    await entityLoader.utils().invalidateEntityAsync(entityInstance);
     verify(
-      dataManagerMock.invalidateObjectFieldsAsync(deepEqual({ customIdField: id1 } as any))
+      dataManagerMock.invalidateObjectFieldsAsync(deepEqual({ customIdField: id1 } as any)),
     ).once();
   });
 
   it('returns error result when not allowed', async () => {
-    const viewerContext = instance(mock(TestViewerContext));
-    const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
+    const viewerContext = instance(mock(ViewerContext));
+    const privacyPolicyEvaluationContext =
+      instance(
+        mock<EntityPrivacyPolicyEvaluationContext<TestFields, string, ViewerContext, TestEntity>>(),
+      );
     const metricsAdapter = instance(mock<IEntityMetricsAdapter>());
-    const queryContext = StubQueryContextProvider.getNonTransactionalQueryContext();
+    const queryContext = StubQueryContextProvider.getQueryContext();
     const privacyPolicyMock = mock(TestEntityPrivacyPolicy);
     const dataManagerMock = mock<EntityDataManager<TestFields>>();
 
     const id1 = uuidv4();
     when(
-      dataManagerMock.loadManyByFieldEqualingAsync(anything(), anything(), anything())
+      dataManagerMock.loadManyByFieldEqualingAsync(anything(), anything(), anything()),
     ).thenResolve(new Map().set(id1, [{ customIdField: id1 }]));
 
     const rejectionError = new Error();
@@ -480,8 +595,8 @@ describe(EntityLoader, () => {
         queryContext,
         privacyPolicyEvaluationContext,
         anyOfClass(TestEntity),
-        anything()
-      )
+        anything(),
+      ),
     ).thenReject(rejectionError);
 
     const privacyPolicy = instance(privacyPolicyMock);
@@ -496,27 +611,30 @@ describe(EntityLoader, () => {
       /* entitySelectedFields */ undefined,
       privacyPolicy,
       dataManagerInstance,
-      metricsAdapter
+      metricsAdapter,
     );
 
-    const entityResult = await entityLoader.loadByIDAsync(id1);
+    const entityResult = await entityLoader.withAuthorizationResults().loadByIDAsync(id1);
     expect(entityResult.ok).toBe(false);
     expect(entityResult.reason).toEqual(rejectionError);
     expect(entityResult.value).toBe(undefined);
   });
 
   it('throws upon database adapter error', async () => {
-    const viewerContext = instance(mock(TestViewerContext));
-    const privacyPolicyEvaluationContext = instance(mock<EntityPrivacyPolicyEvaluationContext>());
+    const viewerContext = instance(mock(ViewerContext));
+    const privacyPolicyEvaluationContext =
+      instance(
+        mock<EntityPrivacyPolicyEvaluationContext<TestFields, string, ViewerContext, TestEntity>>(),
+      );
     const metricsAdapter = instance(mock<IEntityMetricsAdapter>());
-    const queryContext = StubQueryContextProvider.getNonTransactionalQueryContext();
+    const queryContext = StubQueryContextProvider.getQueryContext();
     const privacyPolicy = instance(mock(TestEntityPrivacyPolicy));
     const dataManagerMock = mock<EntityDataManager<TestFields>>();
 
     const error = new Error();
 
     when(
-      dataManagerMock.loadManyByFieldEqualingAsync(anything(), anything(), anything())
+      dataManagerMock.loadManyByFieldEqualingAsync(anything(), anything(), anything()),
     ).thenReject(error);
 
     const dataManagerInstance = instance(dataManagerMock);
@@ -530,30 +648,40 @@ describe(EntityLoader, () => {
       /* entitySelectedFields */ undefined,
       privacyPolicy,
       dataManagerInstance,
-      metricsAdapter
+      metricsAdapter,
     );
 
     const loadByValue = uuidv4();
 
-    await expect(entityLoader.loadByIDAsync(loadByValue)).rejects.toEqual(error);
+    await expect(
+      entityLoader.withAuthorizationResults().loadByIDAsync(loadByValue),
+    ).rejects.toEqual(error);
     await expect(entityLoader.enforcing().loadByIDAsync(loadByValue)).rejects.toEqual(error);
-    await expect(entityLoader.loadManyByIDsAsync([loadByValue])).rejects.toEqual(error);
+    await expect(
+      entityLoader.withAuthorizationResults().loadManyByIDsAsync([loadByValue]),
+    ).rejects.toEqual(error);
     await expect(entityLoader.enforcing().loadManyByIDsAsync([loadByValue])).rejects.toEqual(error);
-    await expect(entityLoader.loadManyByIDsNullableAsync([loadByValue])).rejects.toEqual(error);
     await expect(
-      entityLoader.enforcing().loadManyByIDsNullableAsync([loadByValue])
+      entityLoader.withAuthorizationResults().loadManyByIDsNullableAsync([loadByValue]),
+    ).rejects.toEqual(error);
+    await expect(
+      entityLoader.enforcing().loadManyByIDsNullableAsync([loadByValue]),
     ).rejects.toEqual(error);
     await expect(
-      entityLoader.loadManyByFieldEqualingAsync('customIdField', loadByValue)
+      entityLoader
+        .withAuthorizationResults()
+        .loadManyByFieldEqualingAsync('customIdField', loadByValue),
     ).rejects.toEqual(error);
     await expect(
-      entityLoader.enforcing().loadManyByFieldEqualingAsync('customIdField', loadByValue)
+      entityLoader.enforcing().loadManyByFieldEqualingAsync('customIdField', loadByValue),
     ).rejects.toEqual(error);
     await expect(
-      entityLoader.loadManyByFieldEqualingManyAsync('customIdField', [loadByValue])
+      entityLoader
+        .withAuthorizationResults()
+        .loadManyByFieldEqualingManyAsync('customIdField', [loadByValue]),
     ).rejects.toEqual(error);
     await expect(
-      entityLoader.enforcing().loadManyByFieldEqualingManyAsync('customIdField', [loadByValue])
+      entityLoader.enforcing().loadManyByFieldEqualingManyAsync('customIdField', [loadByValue]),
     ).rejects.toEqual(error);
   });
 });