@squiz/job-runner-lib 2.2.0 → 2.4.0

package/src/domains/job/repository/JobManifestRepository/JobManifestRepository.ts

@@ -3,56 +3,46 @@
  * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
  */
 
-import * as dotenv from 'dotenv';
-dotenv.config();
-
-import {
-  AttributeValue,
-  DynamoDBClient,
-  PutItemCommand,
-  UpdateItemCommand,
-  UpdateItemCommandInput,
-} from '@aws-sdk/client-dynamodb';
+import { AttributeValue, DynamoDBClient, UpdateItemCommand, UpdateItemCommandInput } from '@aws-sdk/client-dynamodb';
 import { inject } from 'inversify';
 import { provideTransient } from '../../transientProvider';
 import { Repository } from '../AbstractRepository';
-import { PARTITION_KEYS } from '../../constants/Repository.constants';
-import { JobManifest } from '../../manifest/JobManifestTypes';
-import { JobManifestDto, CreateJobManifestRequest } from '../../manifest';
+import { ENTITY_TYPES } from '../../constants/Repository.constants';
+import {
+  CreateJobManifestRequest,
+  JobManifest,
+  JobManifestDto,
+  JobManifestSk,
+  UpdateJobManifestRequest,
+} from '../../manifest';
+import { InjectTokens } from '../../constants/InjectTokens';
 import { parsePartitionKey } from '../../ParsePartitionKey';
 
 @provideTransient(JobManifestRepository)
-export class JobManifestRepository extends Repository<JobManifest, JobManifestDto> {
-  public constructor(@inject(DynamoDBClient) protected dynamoDbClient: DynamoDBClient) {
-    super(dynamoDbClient);
-    this.pk = PARTITION_KEYS.manifest;
-    this.tableName = process.env.DYNAMODB_TABLE as string;
+export class JobManifestRepository extends Repository<JobManifest, JobManifestDto, JobManifestSk> {
+  public constructor(
+    @inject(DynamoDBClient) dynamoDbClient: DynamoDBClient,
+    @inject(InjectTokens.DynamoTableName) tableName: string,
+    @inject(InjectTokens.Tenant) tenant: string,
+  ) {
+    super(dynamoDbClient, tableName, `${ENTITY_TYPES.manifest}~${tenant}`);
   }
 
   public async create(input: CreateJobManifestRequest): Promise<JobManifest> {
     const newJobManifest: JobManifest = {
       ...input,
-      type: this.pk,
+      type: ENTITY_TYPES.manifest,
     };
 
-    const dynamoDbRecord = this.convertToDynamoDbItem(newJobManifest);
-
-    await this.dynamoDbClient.send(
-      new PutItemCommand({
-        Item: dynamoDbRecord,
-        TableName: this.tableName,
-      }),
-    );
-
-    return newJobManifest;
+    return super.create(newJobManifest);
   }
 
-  async update(sk: string, input: Partial<JobManifest>): Promise<JobManifest | null> {
+  async update(sk: JobManifestSk, input: UpdateJobManifestRequest): Promise<JobManifest> {
     // Initialise update command
     const updateParams: UpdateItemCommandInput = {
       Key: {
         pk: { S: this.pk },
-        sk: { S: sk },
+        sk: { S: this.buildSk(sk) },
       },
       ReturnValues: 'ALL_NEW',
       TableName: this.tableName,
@@ -88,8 +78,7 @@ export class JobManifestRepository extends Repository<JobManifest, JobManifestDt
     const updateItemCommand = new UpdateItemCommand(updateParams);
     const updatedJob = await this.dynamoDbClient.send(updateItemCommand);
 
-    /* istanbul ignore next */
-    return updatedJob.Attributes ? this.convertToItem(updatedJob.Attributes as JobManifestDto) : null;
+    return this.convertToItem(updatedJob.Attributes as JobManifestDto);
   }
 
   convertToDynamoDbItem(item: JobManifest): JobManifestDto {
@@ -99,8 +88,8 @@ export class JobManifestRepository extends Repository<JobManifest, JobManifestDt
       entryFunction: { S: JSON.stringify(item.entryFunction) },
       name: { S: item.name },
       version: { S: item.version },
-      pk: { S: item.type },
-      sk: { S: `${item.name}-${item.version}` },
+      pk: { S: this.pk },
+      sk: { S: `${item.name}~${item.version}` },
       timeoutSeconds: { N: item.timeoutSeconds.toString() },
     };
   }
@@ -114,7 +103,11 @@ export class JobManifestRepository extends Repository<JobManifest, JobManifestDt
       name: name.S as string,
       version: version.S as string,
       timeoutSeconds: parseInt(timeoutSeconds.N as string),
-      type: parsePartitionKey(pk.S as string),
+      type: parsePartitionKey(pk.S as string).entityType,
     };
   }
+
+  protected buildSk(sk: JobManifestSk): string {
+    return `${sk.name}~${sk.version}`;
+  }
 }

package/src/domains/job/repository/JobRepository/JobRepository.spec.ts

@@ -5,6 +5,7 @@
 
 import {
   AttributeValue,
+  DeleteItemCommandOutput,
   DynamoDBClient,
   DynamoDBClientConfig,
   GetItemCommandOutput,
@@ -13,13 +14,12 @@ import {
   ScanCommandOutput,
 } from '@aws-sdk/client-dynamodb';
 import { initIocContainer, iocContainer } from '../../../../mocks/mockIoc';
-import { testLogger } from '../../../../jest-global-setup';
 import {
   createMockClientPutResponse,
   createMockClientScanResponse,
   createMockClientGetResponse,
 } from '../../core/dynamoClient.mock';
-import { PARTITION_KEYS } from '../../constants/Repository.constants';
+import { ENTITY_TYPES } from '../../constants/Repository.constants';
 import { PaginationInfo } from '../../core/pagination/model/PaginationInfo';
 import { PAGINATION_DIRECTION_TYPE_BEFORE } from '../../core/pagination/model/PaginationTypes';
 import * as PaginationUtils from '../../core/pagination/utils/PaginationUtils';
@@ -27,8 +27,10 @@ import { Job } from '../../model/Job/Job';
 import { createMockJobDto, createMockJobDtos } from '../../model/Job/mocks/JobDto.mock';
 import { createMockCreateJobRequest } from '../../model/Job/mocks/JobRequest.mock';
 import { JobRepository } from './JobRepository';
-// Create a new container tsoa can use
-initIocContainer(testLogger);
+import { createMockJob, createMockJobRecord } from '../../model/Job';
+import { InjectTokens } from '../../constants/InjectTokens';
+
+initIocContainer();
 
 // Mock DynamoDB Client
 const mockOptions = {} as DynamoDBClientConfig;
@@ -39,18 +41,18 @@ mockClient.send = mockSend;
 // Inject JobRepository with a mocked client
 iocContainer.rebind<DynamoDBClient>(DynamoDBClient).toConstantValue(mockClient);
 
-let jobRepository: JobRepository;
-
 describe('JobRepository', (): void => {
+  let jobRepository: JobRepository;
+  let tenant: string;
+  let tableName: string;
+
   beforeAll(() => {
     jobRepository = iocContainer.get(JobRepository);
+    tenant = iocContainer.get(InjectTokens.Tenant);
+    tableName = iocContainer.get(InjectTokens.DynamoTableName);
   });
 
   describe('list', () => {
-    beforeEach(() => {
-      jest.resetAllMocks();
-    });
-
     it(`should return an empty list`, async (): Promise<void> => {
       mockSend.mockImplementationOnce((): ScanCommandOutput => createMockClientScanResponse());
 
@@ -87,7 +89,9 @@ describe('JobRepository', (): void => {
           }),
       );
 
-      const response = await jobRepository.list({ name: mockName });
+      const response = await jobRepository.list({
+        filters: { name: mockName },
+      });
       expect(mockSend).toBeCalledTimes(1);
       expect(response).toHaveLength(mockRecords.length);
     });
@@ -104,14 +108,16 @@ describe('JobRepository', (): void => {
           }),
       );
 
-      const response = await jobRepository.list({ version: mockVersion });
+      const response = await jobRepository.list({
+        filters: { version: mockVersion },
+      });
       expect(mockSend).toBeCalledTimes(1);
       expect(response).toHaveLength(mockRecords.length);
     });
 
     it(`should paginate results to return a list of existing jobs`, async (): Promise<void> => {
-      const mockRecordsPage1 = createMockJobDtos();
-      const mockRecordsPage2 = createMockJobDtos();
+      const mockRecordsPage1 = createMockJobDtos(2);
+      const mockRecordsPage2 = createMockJobDtos(2);
 
       mockSend
         .mockImplementationOnce(
@@ -129,9 +135,11 @@ describe('JobRepository', (): void => {
             }),
         );
 
-      const response = await jobRepository.list();
+      const response = await jobRepository.list({
+        limit: 3,
+      });
       expect(mockSend).toBeCalledTimes(2);
-      expect(response).toHaveLength(mockRecordsPage1.length + mockRecordsPage2.length);
+      expect(response).toHaveLength(3);
     });
 
     it(`should stop paginating if unexpect result is returned`, async (): Promise<void> => {
@@ -144,10 +152,6 @@ describe('JobRepository', (): void => {
   });
 
   describe('findOne', () => {
-    beforeEach(() => {
-      jest.resetAllMocks();
-    });
-
     it(`should return job by name`, async (): Promise<void> => {
       const mockJobRecord = createMockJobDto();
       mockSend.mockImplementationOnce(
@@ -157,7 +161,10 @@ describe('JobRepository', (): void => {
           }),
       );
 
-      const response = await jobRepository.findOne(mockJobRecord.sk.S as string);
+      const response = await jobRepository.findOne({
+        name: mockJobRecord.name.S as string,
+        version: mockJobRecord.version.S as string,
+      });
       expect(response).toStrictEqual({
         name: mockJobRecord.name.S as string,
         type: `job`,
@@ -175,22 +182,18 @@ describe('JobRepository', (): void => {
           }),
       );
 
-      const response = await jobRepository.findOne(`null`);
+      const response = await jobRepository.findOne({ name: 'unknown', version: '0.0.1' });
       expect(mockSend).toBeCalledTimes(1);
       expect(response).toBe(null);
     });
   });
 
   describe('create', () => {
-    beforeEach(() => {
-      jest.resetAllMocks();
-    });
-
     it(`should create a new job record and return job in the response`, async (): Promise<void> => {
       const newJobToCreate = createMockCreateJobRequest();
       const mockReponse = createMockClientPutResponse({
         Attributes: {
-          pk: { S: PARTITION_KEYS.job },
+          pk: { S: ENTITY_TYPES.job },
           sk: { S: `${newJobToCreate.name}-${newJobToCreate.version}` },
           name: { S: newJobToCreate.name },
           version: { S: newJobToCreate.version },
@@ -203,7 +206,7 @@ describe('JobRepository', (): void => {
       expect(mockSend).toBeCalledTimes(1);
       expect(response).toStrictEqual({
         ...newJobToCreate,
-        type: PARTITION_KEYS.job,
+        type: ENTITY_TYPES.job,
       });
     });
   });
@@ -215,7 +218,7 @@ describe('JobRepository', (): void => {
 
     beforeEach(() => {
       mockExclusiveStartKey = {
-        pk: { S: PARTITION_KEYS.job },
+        pk: { S: `${ENTITY_TYPES.job}~${tenant}` },
         sk: { S: 'mockSk' },
       };
       mockPaginationInfo = {
@@ -227,11 +230,11 @@ describe('JobRepository', (): void => {
       mockParams = {
         ExclusiveStartKey: mockExclusiveStartKey,
         ExpressionAttributeValues: {
-          ':pk': { S: PARTITION_KEYS.job },
+          ':pk': { S: `${ENTITY_TYPES.job}~${tenant}` },
         },
         KeyConditionExpression: 'pk = :pk',
         ScanIndexForward: false,
-        TableName: process.env.DYNAMODB_TABLE,
+        TableName: tableName,
       };
 
       jest.spyOn(PaginationUtils, 'decodeTokenString').mockReturnValue(mockExclusiveStartKey);
@@ -261,7 +264,7 @@ describe('JobRepository', (): void => {
     it('should return an array of jobs if found', async () => {
       const mockJobRecords = createMockJobDtos();
       const mockLastEvaluatedKey = {
-        pk: { S: PARTITION_KEYS.job },
+        pk: { S: ENTITY_TYPES.job },
         sk: { S: 'mockSk' },
       };
 
@@ -286,52 +289,41 @@ describe('JobRepository', (): void => {
     });
   });
 
-  // describe('update', () => {
-  //   beforeEach(() => {
-  //     jest.resetAllMocks();
-  //   });
-
-  //   it(`should update a job record`, async (): Promise<void> => {
-  //     const jobToUpdate = createMockJob();
-  //     const updatedJob: Job = {
-  //       ...jobToUpdate,
-  //       name: `new-name`,
-  //       version: `9.9.9`,
-  //     };
-  //     const updatedJobRecord = createMockJobRecord({
-  //       sk: updatedJob.name,
-  //       version: updatedJob.version,
-  //     });
-  //     const updatedJobRecordDto = createMockJobDto({
-  //       ...updatedJobRecord,
-  //     });
-  //     const putResponse = createMockClientPutResponse({
-  //       Attributes: { ...updatedJobRecordDto },
-  //     });
-
-  //     mockSend.mockImplementation((): PutItemCommandOutput => putResponse);
-
-  //     const response = await jobRepository.update(jobToUpdate.name, updatedJobRecord);
-  //     expect(response).toStrictEqual(updatedJob);
-  //     expect(mockSend).toBeCalledTimes(1);
-  //   });
-  // });
-
-  // describe('delete', () => {
-  //   beforeEach(() => {
-  //     jest.resetAllMocks();
-  //   });
-
-  //   it(`should return undefined when calling the delete operation`, async (): Promise<void> => {
-  //     mockSend.mockImplementationOnce((): DeleteItemCommandOutput => {
-  //       return {
-  //         $metadata: {},
-  //       };
-  //     });
-
-  //     const response = await jobRepository.delete(`name`);
-  //     expect(response).toBe(undefined);
-  //     expect(mockSend).toBeCalledTimes(1);
-  //   });
-  // });
+  describe('update', () => {
+    it(`should update a job record`, async (): Promise<void> => {
+      const jobToUpdate = createMockJob();
+      const updatedJob: Job = {
+        ...jobToUpdate,
+        description: `updated description`,
+      };
+      const updatedJobRecord = createMockJobRecord(updatedJob);
+      const updatedJobRecordDto = createMockJobDto(updatedJobRecord);
+      const putResponse = createMockClientPutResponse({
+        Attributes: { ...updatedJobRecordDto },
+      });
+
+      mockSend.mockImplementation((): PutItemCommandOutput => putResponse);
+
+      const response = await jobRepository.update(
+        { name: jobToUpdate.name, version: jobToUpdate.version },
+        updatedJobRecord,
+      );
+      expect(response).toStrictEqual(updatedJob);
+      expect(mockSend).toBeCalledTimes(1);
+    });
+  });
+
+  describe('delete', () => {
+    it(`should return undefined when calling the delete operation`, async (): Promise<void> => {
+      mockSend.mockImplementationOnce((): DeleteItemCommandOutput => {
+        return {
+          $metadata: {},
+        };
+      });
+
+      const response = await jobRepository.delete({ name: `name`, version: '1.0.0' });
+      expect(response).toBe(undefined);
+      expect(mockSend).toBeCalledTimes(1);
+    });
+  });
 });

package/src/domains/job/repository/JobRepository/JobRepository.ts

@@ -3,53 +3,44 @@
  * Copyright Squiz Australia Pty Ltd. All Rights Reserved.
  */
 
-import * as dotenv from 'dotenv';
-dotenv.config();
-
 import {
   AttributeValue,
   DynamoDBClient,
-  PutItemCommand,
   QueryCommand,
   QueryCommandInput,
-  ScanCommand,
-  ScanCommandOutput,
+  QueryCommandOutput,
 } from '@aws-sdk/client-dynamodb';
 import { inject } from 'inversify';
 import { provideTransient } from '../../transientProvider';
-import { Repository } from '../../repository/AbstractRepository';
-import { PARTITION_KEYS } from '../../constants/Repository.constants';
+import { Repository } from '../AbstractRepository';
+import { ENTITY_TYPES } from '../../constants/Repository.constants';
 import { parsePartitionKey } from '../../ParsePartitionKey';
-import { CreateJobRequest, Job, JobDto, ListJobParameters } from '../../model/Job/Job';
-import { PaginationInfo } from '../../core/pagination/model/PaginationInfo';
-import { PaginationQueryResponse } from '../../core/pagination/model/PaginationQueryResponse';
-import { decodeTokenString } from '../../core/pagination/utils/PaginationUtils';
-import { PAGINATION_DIRECTION_TYPE_BEFORE } from '../../core/pagination/model/PaginationTypes';
+import { CreateJobRequest, Job, JobDto, JobSk, ListJobParameters } from '../../model/Job';
+import {
+  decodeTokenString,
+  PAGINATION_DIRECTION_TYPE_BEFORE,
+  PaginationInfo,
+  PaginationQueryResponse,
+} from '../../core/pagination';
+import { InjectTokens } from '../../constants/InjectTokens';
 
 @provideTransient(JobRepository)
-export class JobRepository extends Repository<Job, JobDto> {
-  public constructor(@inject(DynamoDBClient) protected dynamoDbClient: DynamoDBClient) {
-    super(dynamoDbClient);
-    this.pk = PARTITION_KEYS.job;
-    this.tableName = process.env.DYNAMODB_TABLE as string;
+export class JobRepository extends Repository<Job, JobDto, JobSk> {
+  public constructor(
+    @inject(DynamoDBClient) dynamoDbClient: DynamoDBClient,
+    @inject(InjectTokens.DynamoTableName) tableName: string,
+    @inject(InjectTokens.Tenant) tenant: string,
+  ) {
+    super(dynamoDbClient, tableName, `${ENTITY_TYPES.job}~${tenant}`);
   }
 
   public async create(input: CreateJobRequest): Promise<Job> {
     const newJob: Job = {
       ...input,
-      type: this.pk,
+      type: ENTITY_TYPES.job,
     };
 
-    const dynamoDbRecord = this.convertToDynamoDbItem(newJob);
-
-    await this.dynamoDbClient.send(
-      new PutItemCommand({
-        Item: dynamoDbRecord,
-        TableName: this.tableName,
-      }),
-    );
-
-    return newJob;
+    return super.create(newJob);
   }
 
   /**
@@ -58,7 +49,9 @@ export class JobRepository extends Repository<Job, JobDto> {
    * @returns {Promise<Array<T>>} The retrieved records.
    * @memberof Repository
    */
-  async list(parameters?: ListJobParameters): Promise<Array<Job>> {
+  async list(parameters: ListJobParameters = {}): Promise<Array<Job>> {
+    const keyConditionExpressions = ['#pk = :pk'];
+    const filterExpressions: Array<string> = [];
     const expressionAttributeNames: Record<string, string> = {
       '#pk': 'pk',
     };
@@ -66,26 +59,21 @@ export class JobRepository extends Repository<Job, JobDto> {
       ':pk': { S: this.pk },
     };
 
-    const params = {
-      ExpressionAttributeNames: expressionAttributeNames,
-      ExpressionAttributeValues: expressionAttributeValues,
-      FilterExpression: '#pk = :pk',
-      TableName: this.tableName,
-    };
-
-    if (parameters) {
-      const { name, version } = parameters;
-
-      if (name) {
-        params.ExpressionAttributeNames['#name'] = 'name';
-        params.ExpressionAttributeValues[':name'] = { S: name };
-        params.FilterExpression += ` and #name = :name`;
-      }
-
-      if (version) {
-        params.ExpressionAttributeNames['#version'] = 'version';
-        params.ExpressionAttributeValues[':version'] = { S: version };
-        params.FilterExpression += ` and #version = :version`;
+    if (parameters.filters) {
+      const { name, version } = parameters.filters;
+
+      if (name && version) {
+        expressionAttributeNames['#sk'] = 'sk';
+        expressionAttributeValues[':sk'] = { S: `${name}~${version}` };
+        keyConditionExpressions.push(`#sk = :sk`);
+      } else if (name) {
+        expressionAttributeNames['#sk'] = 'sk';
+        expressionAttributeValues[':skPrefix'] = { S: `${name}~` };
+        keyConditionExpressions.push(`begins_with(#sk, :skPrefix)`);
+      } else if (version) {
+        expressionAttributeNames['#version'] = 'version';
+        expressionAttributeValues[':version'] = { S: version };
+        filterExpressions.push(`#version = :version`);
       }
     }
 
@@ -93,29 +81,33 @@ export class JobRepository extends Repository<Job, JobDto> {
     // By default, the Scan operation processes data sequentially.
     // DynamoDB returns data in increments of 1 MB increments.
 
-    let startKey; /* Indicator of where to paginate from. */
+    let startKey: Record<string, AttributeValue> | undefined = undefined; /* Indicator of where to paginate from. */
     const results: Array<Record<string, AttributeValue>> = [];
 
     // Iterate through pages until no more results are found.
-    while (startKey !== null) {
-      const res: ScanCommandOutput = await this.dynamoDbClient.send(
-        new ScanCommand({ ...params, ExclusiveStartKey: startKey }),
+    do {
+      const res: QueryCommandOutput = await this.dynamoDbClient.send(
+        new QueryCommand({
+          ExpressionAttributeNames: expressionAttributeNames,
+          ExpressionAttributeValues: expressionAttributeValues,
+          KeyConditionExpression: keyConditionExpressions.join(' and '),
+          FilterExpression: filterExpressions.length > 0 ? filterExpressions.join(' and ') : undefined,
+          TableName: this.tableName,
+          ExclusiveStartKey: startKey,
+          Limit: parameters.limit,
+          ConsistentRead: parameters.consistentRead,
+        }),
       );
 
-      if (!res) {
-        // Stop paginating if result is unexpected.
-        startKey = null;
-      } else {
-        results.push(
-          ...(res.Items ??
-            /* istanbul ignore next */
-            []),
-        );
-
-        // If no more results, set key to null to terminate loop
-        startKey = res.LastEvaluatedKey ?? null;
+      results.push(...(res?.Items || []));
+      startKey = res?.LastEvaluatedKey;
+
+      if (parameters.limit !== undefined && results.length >= parameters.limit) {
+        // Truncate list to max requested items, stop querying.
+        results.length = parameters.limit;
+        break;
       }
-    }
+    } while (startKey);
 
     return results.length ? results.map((item) => this.convertToItem(item as JobDto)) : [];
   }
@@ -160,8 +152,8 @@ export class JobRepository extends Repository<Job, JobDto> {
 
   convertToDynamoDbItem(item: Job): JobDto {
     return {
-      pk: { S: item.type },
-      sk: { S: `${item.name}-${item.version}` },
+      pk: { S: this.pk },
+      sk: { S: this.buildSk(item) },
       name: { S: item.name },
       description: item.description ? { S: item.description } : { NULL: true },
       version: { S: item.version },
@@ -181,8 +173,12 @@ export class JobRepository extends Repository<Job, JobDto> {
     return {
       name: name.S as string,
       description: description.S ? (description.S as string) : '',
-      type: parsePartitionKey(pk.S as string),
+      type: parsePartitionKey(pk.S as string).entityType,
       version: version.S as string,
     };
   }
+
+  protected buildSk(sk: JobSk): string {
+    return `${sk.name}~${sk.version}`;
+  }
 }

package/src/domains/job/repository/MultiTenantJobExecutionRepository/MultiTenantJobExecutionRepository.spec.ts

@@ -0,0 +1,60 @@
+import 'aws-sdk-client-mock-jest';
+import { mockClient } from 'aws-sdk-client-mock';
+import { DynamoDBClient, QueryCommand, QueryCommandInput } from '@aws-sdk/client-dynamodb';
+import { faker } from '@faker-js/faker';
+import { createMockJobExecution, createMockJobExecutionDto } from '../../model/JobExecution';
+import { MultiTenantJobExecutionRepository } from './MultiTenantJobExecutionRepository';
+import { JOB_EXECUTION_STATUS } from '../../constants/JobExecutionStatus.constants';
+import { ENTITY_TYPES } from '../../constants/Repository.constants';
+
+describe('MultiTenantJobExecutionRepository', () => {
+  const mockDynamoClient = mockClient(DynamoDBClient);
+  const tableName = faker.lorem.words();
+  let repository: MultiTenantJobExecutionRepository;
+
+  beforeEach(() => {
+    mockDynamoClient.reset();
+    repository = new MultiTenantJobExecutionRepository(new DynamoDBClient(), tableName);
+  });
+
+  describe('findByStatus', () => {
+    it('Queries job executions by status', async () => {
+      const tenant1 = faker.string.uuid();
+      const tenant2 = faker.string.uuid();
+      const executions = [createMockJobExecution(), createMockJobExecution(), createMockJobExecution()];
+      const expectedQueryInput: QueryCommandInput = {
+        KeyConditionExpression: 'gsi1pk = :gsi1pk',
+        ExpressionAttributeValues: {
+          ':gsi1pk': { S: `${ENTITY_TYPES.jobExecution}~running` },
+        },
+        TableName: tableName,
+        IndexName: 'gsi1',
+      };
+
+      mockDynamoClient
+        .on(QueryCommand)
+        .resolvesOnce({
+          Items: [createMockJobExecutionDto({ pk: `${ENTITY_TYPES.jobExecution}~${tenant1}`, ...executions[0] })],
+          LastEvaluatedKey: { pk: { S: 'page-2' } },
+        })
+        .resolvesOnce({
+          Items: [
+            createMockJobExecutionDto({ pk: `${ENTITY_TYPES.jobExecution}~${tenant1}`, ...executions[1] }),
+            createMockJobExecutionDto({ pk: `${ENTITY_TYPES.jobExecution}~${tenant2}`, ...executions[2] }),
+          ],
+        });
+
+      const results = await repository.findByStatus(JOB_EXECUTION_STATUS.running);
+
+      expect(results).toEqual({
+        [tenant1]: [executions[0], executions[1]],
+        [tenant2]: [executions[2]],
+      });
+      expect(mockDynamoClient).toHaveReceivedNthCommandWith(1, QueryCommand, expectedQueryInput);
+      expect(mockDynamoClient).toHaveReceivedNthCommandWith(2, QueryCommand, {
+        ...expectedQueryInput,
+        ExclusiveStartKey: { pk: { S: 'page-2' } },
+      });
+    });
+  });
+});