@squiz/job-runner-lib 2.2.0 → 2.4.0

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

@@ -5,168 +5,205 @@
 
 import {
   AttributeValue,
+  BatchWriteItemCommand,
   DynamoDBClient,
-  DynamoDBClientConfig,
-  GetItemCommandOutput,
-  PutItemCommandOutput,
+  GetItemCommand,
+  PutItemCommand,
+  QueryCommand,
   QueryCommandInput,
-  ScanCommandOutput,
+  UpdateItemCommand,
 } from '@aws-sdk/client-dynamodb';
+import { faker } from '@faker-js/faker';
+import { AwsClientStub, mockClient } from 'aws-sdk-client-mock';
+import 'aws-sdk-client-mock-jest';
 import { initIocContainer, iocContainer } from '../../../../mocks/mockIoc';
-import { testLogger } from '../../../../jest-global-setup';
+import { InjectTokens } from '../../constants/InjectTokens';
+import { JOB_EXECUTION_STATUS } from '../../constants/JobExecutionStatus.constants';
+import { ENTITY_TYPES } from '../../constants/Repository.constants';
 import {
+  createMockClientGetResponse,
   createMockClientPutResponse,
   createMockClientScanResponse,
-  createMockClientGetResponse,
 } from '../../core/dynamoClient.mock';
-import { PARTITION_KEYS } from '../../constants/Repository.constants';
-import { JOB_EXECUTION_STATUS } from '../../constants/JobExecutionStatus.constants';
-import { JobExecution } from '../../model/JobExecution/JobExecution';
-import { createMockJobExecution } from '../../model/JobExecution/mocks/JobExecution.mock';
+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';
+import { JobExecution, UpdateJobExecutionParameters } from '../../model/JobExecution/JobExecution';
+import { createMockJobExecution, createMockJobExecutions } from '../../model/JobExecution/mocks/JobExecution.mock';
 import {
   createMockJobExecutionDto,
   createMockJobExecutionDtos,
 } from '../../model/JobExecution/mocks/JobExecutionDto.mock';
 import { JobExecutionRepository } from './JobExecutionRepository';
-import * as PaginationUtils from '../../core/pagination/utils/PaginationUtils';
-import { PaginationInfo } from '../../core/pagination/model/PaginationInfo';
-import { PAGINATION_DIRECTION_TYPE_BEFORE } from '../../core/pagination/model/PaginationTypes';
 
-// Create a new container tsoa can use
-initIocContainer(testLogger);
+initIocContainer();
 
-// Mock DynamoDB Client
-const mockOptions = {} as DynamoDBClientConfig;
-const mockClient = new DynamoDBClient(mockOptions);
-const mockSend = jest.fn();
-mockClient.send = mockSend;
-
-// Inject JobRepository with a mocked client
-iocContainer.rebind<DynamoDBClient>(DynamoDBClient).toConstantValue(mockClient);
+describe('JobExecutionRepository', (): void => {
+  let dynamoClient: AwsClientStub<DynamoDBClient>;
+  let jobExecutionRepository: JobExecutionRepository;
+  let tenant: string;
+  let tableName: string;
 
-let jobExecutionRepository: JobExecutionRepository;
+  beforeEach(() => {
+    dynamoClient = mockClient(DynamoDBClient);
+    dynamoClient.reset();
 
-describe('JobExecutionRepository', (): void => {
-  beforeAll(() => {
     jobExecutionRepository = iocContainer.get(JobExecutionRepository);
+    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());
+      dynamoClient.on(QueryCommand).resolvesOnce(createMockClientScanResponse());
 
-      const response = await jobExecutionRepository.list({ jobName: 'does-not-exist' });
-      expect(mockSend).toBeCalled();
+      const response = await jobExecutionRepository.list({
+        filters: { jobName: 'does-not-exist' },
+      });
       expect(response).toStrictEqual([]);
+      expect(dynamoClient).toHaveReceivedCommandTimes(QueryCommand, 1);
     });
 
     it(`should return a list of existing job executions`, async (): Promise<void> => {
-      const mockRecord = createMockJobExecutionDto();
+      const mockJobExecution = createMockJobExecution();
 
-      mockSend.mockImplementationOnce(
-        (): ScanCommandOutput =>
-          createMockClientScanResponse({
-            Items: [mockRecord],
-            LastEvaluatedKey: undefined,
-          }),
+      dynamoClient.on(QueryCommand).resolvesOnce(
+        createMockClientScanResponse({
+          Items: [createMockJobExecutionDto(mockJobExecution)],
+          LastEvaluatedKey: undefined,
+        }),
       );
 
       const response = await jobExecutionRepository.list();
-      expect(mockSend).toBeCalledTimes(1);
-      expect(response).toHaveLength(1);
+      expect(response).toEqual([mockJobExecution]);
+      expect(dynamoClient).toHaveReceivedCommandWith(QueryCommand, {
+        ExclusiveStartKey: undefined,
+        ExpressionAttributeNames: { '#pk': 'pk' },
+        ExpressionAttributeValues: { ':pk': { S: `jobExecution~${tenant}` } },
+        IndexName: undefined,
+        KeyConditionExpression: '#pk = :pk',
+        ScanIndexForward: false,
+        TableName: tableName,
+      });
     });
 
     it(`should return a list of existing job executions by name`, async (): Promise<void> => {
       const mockName = `mock`;
-      const mockRecords = [
-        createMockJobExecutionDto({ jobName: mockName }),
-        createMockJobExecutionDto({ jobName: mockName }),
+      const mockJobExecutions = [
+        createMockJobExecution({ jobName: mockName }),
+        createMockJobExecution({ jobName: mockName }),
       ];
 
-      mockSend.mockImplementationOnce(
-        (): ScanCommandOutput =>
-          createMockClientScanResponse({
-            Items: mockRecords,
-            LastEvaluatedKey: undefined,
-          }),
+      dynamoClient.on(QueryCommand).resolvesOnce(
+        createMockClientScanResponse({
+          Items: mockJobExecutions.map((execution) => createMockJobExecutionDto(execution)),
+          LastEvaluatedKey: undefined,
+        }),
       );
 
-      const response = await jobExecutionRepository.list({ jobName: mockName });
-      expect(mockSend).toBeCalledTimes(1);
-      expect(response).toHaveLength(mockRecords.length);
+      const response = await jobExecutionRepository.list({
+        filters: { jobName: mockName },
+      });
+      expect(response).toEqual(mockJobExecutions);
+      expect(dynamoClient).toHaveReceivedCommandWith(QueryCommand, {
+        ExclusiveStartKey: undefined,
+        ExpressionAttributeNames: { '#pk': 'pk', '#sk': 'sk' },
+        ExpressionAttributeValues: {
+          ':pk': { S: `jobExecution~${tenant}` },
+          ':skPrefix': { S: `${mockName}~` },
+        },
+        IndexName: undefined,
+        KeyConditionExpression: '#pk = :pk and begins_with(#sk, :skPrefix)',
+        ScanIndexForward: false,
+        TableName: tableName,
+      });
     });
 
     it(`should return a list of existing job executions by status`, async (): Promise<void> => {
       const mockStatus = JOB_EXECUTION_STATUS.running;
-      const mockRecords = [
-        createMockJobExecutionDto({ status: mockStatus }),
-        createMockJobExecutionDto({ status: mockStatus }),
+      const mockJobExecutions = [
+        createMockJobExecution({ status: mockStatus }),
+        createMockJobExecution({ status: mockStatus }),
       ];
 
-      mockSend.mockImplementationOnce(
-        (): ScanCommandOutput =>
-          createMockClientScanResponse({
-            Items: mockRecords,
-            LastEvaluatedKey: undefined,
-          }),
+      dynamoClient.on(QueryCommand).resolvesOnce(
+        createMockClientScanResponse({
+          Items: mockJobExecutions.map((execution) => createMockJobExecutionDto(execution)),
+          LastEvaluatedKey: undefined,
+        }),
       );
 
-      const response = await jobExecutionRepository.list({ status: mockStatus });
-      expect(mockSend).toBeCalledTimes(1);
-      expect(response).toHaveLength(mockRecords.length);
+      const response = await jobExecutionRepository.list({
+        filters: { status: mockStatus },
+      });
+      expect(response).toEqual(mockJobExecutions);
+      expect(dynamoClient).toHaveReceivedCommandWith(QueryCommand, {
+        ExclusiveStartKey: undefined,
+        ExpressionAttributeNames: {
+          '#lsi1sk': 'lsi1sk',
+          '#pk': 'pk',
+        },
+        ExpressionAttributeValues: {
+          ':lsi1skPrefix': { S: `${mockStatus}~` },
+          ':pk': { S: `jobExecution~${tenant}` },
+        },
+        IndexName: 'lsi1',
+        KeyConditionExpression: '#pk = :pk and begins_with(#lsi1sk, :lsi1skPrefix)',
+        ScanIndexForward: false,
+        TableName: tableName,
+      });
     });
 
     it(`should paginate results to return a list of existing job executions`, async (): Promise<void> => {
       const mockRecordsPage1 = [
-        createMockJobExecutionDto({ jobName: 'testJob1' }),
-        createMockJobExecutionDto({ jobName: 'testJob1' }),
-        createMockJobExecutionDto({ jobName: 'testJob1' }),
+        createMockJobExecution({ jobName: 'testJob1' }),
+        createMockJobExecution({ jobName: 'testJob1' }),
+        createMockJobExecution({ jobName: 'testJob1' }),
       ];
       const mockRecordsPage2 = [
-        createMockJobExecutionDto({ jobName: 'testJob2' }),
-        createMockJobExecutionDto({ jobName: 'testJob2' }),
-        createMockJobExecutionDto({ jobName: 'testJob2' }),
+        createMockJobExecution({ jobName: 'testJob2' }),
+        createMockJobExecution({ jobName: 'testJob2' }),
+        createMockJobExecution({ jobName: 'testJob2' }),
       ];
 
-      mockSend
-        .mockImplementationOnce(
-          (): ScanCommandOutput =>
-            createMockClientScanResponse({
-              Items: mockRecordsPage1,
-              LastEvaluatedKey: mockRecordsPage1.slice(-1)[0],
-            }),
+      dynamoClient
+        .on(QueryCommand)
+        .resolvesOnce(
+          createMockClientScanResponse({
+            Items: mockRecordsPage1.map((execution) => createMockJobExecutionDto(execution)),
+            LastEvaluatedKey: createMockJobExecutionDto(mockRecordsPage1.slice(-1)[0]),
+          }),
         )
-        .mockImplementationOnce(
-          (): ScanCommandOutput =>
-            createMockClientScanResponse({
-              Items: mockRecordsPage2,
-              LastEvaluatedKey: undefined,
-            }),
+        .resolvesOnce(
+          createMockClientScanResponse({
+            Items: mockRecordsPage2.map((execution) => createMockJobExecutionDto(execution)),
+            LastEvaluatedKey: undefined,
+          }),
         );
 
-      const response = await jobExecutionRepository.list({ jobName: 'testJob1' });
-      expect(mockSend).toBeCalledTimes(2);
-      expect(response).toHaveLength(mockRecordsPage1.length + mockRecordsPage2.length);
+      const response = await jobExecutionRepository.list({
+        filters: { jobName: 'testJob1' },
+        limit: 4,
+      });
+      expect(response).toEqual([mockRecordsPage1[0], mockRecordsPage1[1], mockRecordsPage1[2], mockRecordsPage2[0]]);
+      expect(dynamoClient).toHaveReceivedCommandTimes(QueryCommand, 2);
+      expect(dynamoClient).toHaveReceivedCommandWith(QueryCommand, {
+        Limit: 4,
+      });
     });
 
     it(`should stop paginating if unexpected result is returned`, async (): Promise<void> => {
-      mockSend.mockImplementationOnce(() => null);
+      dynamoClient.on(QueryCommand).resolvesOnce({});
 
-      const response = await jobExecutionRepository.list({ jobName: 'testJob1' });
-      expect(mockSend).toBeCalledTimes(1);
-      expect(response).toHaveLength(0);
+      const response = await jobExecutionRepository.list({
+        filters: { jobName: 'testJob1' },
+      });
+      expect(response).toEqual([]);
+      expect(dynamoClient).toHaveReceivedCommandTimes(QueryCommand, 1);
     });
   });
 
   describe('findOne', () => {
-    beforeEach(() => {
-      jest.resetAllMocks();
-    });
-
     it(`should return job execution by timeQueued and id and handle any null values`, async (): Promise<void> => {
       const mockJobExecutionRecord = createMockJobExecutionDto({
         ecsTaskId: 'ecs-task-id',
@@ -175,79 +212,70 @@ describe('JobExecutionRepository', (): void => {
         version: '1.0.0',
       });
 
-      mockSend.mockImplementationOnce(
-        (): GetItemCommandOutput =>
-          createMockClientGetResponse({
-            Item: mockJobExecutionRecord,
-          }),
+      dynamoClient.on(GetItemCommand).resolvesOnce(
+        createMockClientGetResponse({
+          Item: mockJobExecutionRecord,
+        }),
       );
 
-      const response = await jobExecutionRepository.findOne(
-        `${mockJobExecutionRecord.timeQueued.S as string}-${mockJobExecutionRecord.id.S as string}`,
-        mockJobExecutionRecord.jobName.S as string,
-      );
+      const response = await jobExecutionRepository.findOne({
+        jobName: mockJobExecutionRecord.jobName.S as string,
+        id: mockJobExecutionRecord.id.S as string,
+      });
       expect(response).toStrictEqual({
         context: mockJobExecutionRecord.context.S as string,
-        ecsTaskId: mockJobExecutionRecord.ecsTaskId.NULL ? null : (mockJobExecutionRecord.ecsTaskId.S as string),
+        ecsTaskId: mockJobExecutionRecord.ecsTaskId.S as string,
         id: mockJobExecutionRecord.id.S as string,
         jobName: mockJobExecutionRecord.jobName.S as string,
         status: mockJobExecutionRecord.status.S as string,
-        timeFinished: mockJobExecutionRecord.timeFinished.NULL
-          ? null
-          : (mockJobExecutionRecord.timeFinished.S as string),
+        timeFinished: mockJobExecutionRecord.timeFinished.S as string,
         timeQueued: mockJobExecutionRecord.timeQueued.S as string,
-        timeStarted: mockJobExecutionRecord.timeStarted.NULL ? null : (mockJobExecutionRecord.timeStarted.S as string),
+        timeStarted: mockJobExecutionRecord.timeStarted.S as string,
         type: `jobExecution-${mockJobExecutionRecord.jobName.S as string}`,
-        version: mockJobExecutionRecord.version.NULL ? null : (mockJobExecutionRecord.version.S as string),
+        version: mockJobExecutionRecord.version.S as string,
         input: mockJobExecutionRecord.input.NULL ? null : JSON.parse(mockJobExecutionRecord.input.S as string),
+        retryCount: 0,
+        lastFailureReason: null,
+        retryAfter: null,
       } as JobExecution);
-      expect(mockSend).toBeCalledTimes(1);
+      expect(dynamoClient).toHaveReceivedCommandWith(GetItemCommand, {});
     });
 
     it(`should return null if job execution does not exist`, async (): Promise<void> => {
-      mockSend.mockImplementationOnce(
-        (): ScanCommandOutput =>
-          createMockClientScanResponse({
-            Items: [],
-          }),
+      dynamoClient.on(GetItemCommand).resolvesOnce(
+        createMockClientGetResponse({
+          Item: undefined,
+        }),
       );
 
-      const response = await jobExecutionRepository.findOne(`null`, `null`);
-      expect(mockSend).toBeCalledTimes(1);
+      const response = await jobExecutionRepository.findOne({ jobName: 'null', id: 'null' });
       expect(response).toBe(null);
+      expect(dynamoClient).toHaveReceivedCommandTimes(GetItemCommand, 1);
     });
   });
 
   describe('create', () => {
-    beforeEach(() => {
-      jest.resetAllMocks();
-    });
-
     it(`should create a new job execution record and return job execution record in the response`, async (): Promise<void> => {
       const newJobExecutionToCreate = createMockJobExecution();
       const mockResponse = createMockClientPutResponse({
         Attributes: {
           jobName: { S: newJobExecutionToCreate.jobName },
-          pk: { S: PARTITION_KEYS.jobExecution },
+          pk: { S: ENTITY_TYPES.jobExecution },
           sk: { S: `${newJobExecutionToCreate.jobName}` },
         },
       });
 
-      mockSend.mockImplementationOnce((): PutItemCommandOutput => mockResponse);
+      dynamoClient.on(PutItemCommand).resolvesOnce(mockResponse);
 
       const response = await jobExecutionRepository.create(newJobExecutionToCreate);
-      expect(mockSend).toBeCalledTimes(1);
       expect(response).toStrictEqual({
         ...newJobExecutionToCreate,
       });
+      expect(dynamoClient).toHaveReceivedCommandWith(PutItemCommand, {});
     });
   });
 
   describe('begin', () => {
-    beforeEach(() => {
-      jest.resetAllMocks();
-    });
-
     it(`should create a new queued job record`, async (): Promise<void> => {
       const newJobExecutionToCreate = createMockJobExecution({
         status: JOB_EXECUTION_STATUS.queued,
@@ -257,7 +285,7 @@ describe('JobExecutionRepository', (): void => {
       });
       const mockReponse = createMockClientPutResponse({
         Attributes: {
-          pk: { S: `${PARTITION_KEYS.jobExecution}-${newJobExecutionToCreate.jobName}` },
+          pk: { S: `${ENTITY_TYPES.jobExecution}-${newJobExecutionToCreate.jobName}` },
           sk: { S: `${newJobExecutionToCreate.timeQueued}-${newJobExecutionToCreate.id}` },
           name: { S: newJobExecutionToCreate.jobName },
           context: { S: newJobExecutionToCreate.context },
@@ -268,7 +296,7 @@ describe('JobExecutionRepository', (): void => {
         },
       });
 
-      mockSend.mockImplementationOnce(() => Promise.resolve(mockReponse));
+      dynamoClient.on(PutItemCommand).resolvesOnce(mockReponse);
 
       const response = await jobExecutionRepository.begin({
         context: newJobExecutionToCreate.context,
@@ -276,7 +304,6 @@ describe('JobExecutionRepository', (): void => {
         version: newJobExecutionToCreate.version,
         input: newJobExecutionToCreate.input,
       });
-      expect(mockSend).toBeCalledTimes(1);
       expect(response.id).not.toBeNull();
       expect(response.timeQueued).not.toBeNull();
       expect(response.ecsTaskId).toBeNull();
@@ -286,18 +313,21 @@ describe('JobExecutionRepository', (): void => {
       expect(response.jobName).toBe(newJobExecutionToCreate.jobName);
       expect(response.version).toBe(newJobExecutionToCreate.version);
       expect(response.input).toBe(newJobExecutionToCreate.input);
+      expect(dynamoClient).toHaveReceivedCommandWith(PutItemCommand, {});
     });
   });
 
   describe('getExecutions', () => {
+    const jobName = 'something';
+    const jobExecutionId = faker.string.uuid();
     let mockExclusiveStartKey: Record<string, AttributeValue>;
     let mockPaginationInfo: PaginationInfo;
     let mockParams: QueryCommandInput;
 
     beforeEach(() => {
       mockExclusiveStartKey = {
-        pk: { S: `${PARTITION_KEYS.jobExecution}-something` },
-        sk: { S: 'mockSk' },
+        pk: { S: `${ENTITY_TYPES.jobExecution}~${tenant}` },
+        sk: { S: `${jobName}~${jobExecutionId}` },
       };
       mockPaginationInfo = {
         direction: PAGINATION_DIRECTION_TYPE_BEFORE,
@@ -308,61 +338,205 @@ describe('JobExecutionRepository', (): void => {
       mockParams = {
         ExclusiveStartKey: mockExclusiveStartKey,
         ExpressionAttributeValues: {
-          ':pk': { S: `${PARTITION_KEYS.jobExecution}-something` },
+          ':pk': { S: `${ENTITY_TYPES.jobExecution}~${tenant}` },
+          ':skPrefix': { S: `${jobName}~` },
         },
-        KeyConditionExpression: 'pk = :pk',
-        TableName: process.env.DYNAMODB_TABLE,
+        KeyConditionExpression: 'pk = :pk and begins_with(sk, :skPrefix)',
+        TableName: tableName,
       };
 
       jest.spyOn(PaginationUtils, 'decodeTokenString').mockReturnValue(mockExclusiveStartKey);
     });
 
     it('should return an empty array if no executions are found', async () => {
-      mockSend.mockImplementationOnce(() =>
-        Promise.resolve({
-          Items: [],
-          LastEvaluatedKey: null,
-        }),
-      );
-
-      const mockRequestData: PaginationInfo = mockPaginationInfo;
+      dynamoClient.on(QueryCommand).resolvesOnce({
+        Items: [],
+        LastEvaluatedKey: undefined,
+      });
 
-      const result = await jobExecutionRepository.getExecutions(mockRequestData, 'something');
+      const result = await jobExecutionRepository.getExecutions(mockPaginationInfo, 'something');
 
-      expect(mockSend).toHaveBeenCalledWith(
-        expect.objectContaining({
-          input: { ...mockParams },
-        }),
-      );
+      expect(dynamoClient).toHaveReceivedCommandWith(QueryCommand, mockParams);
       expect(result.items).toEqual([]);
-      expect(result.lastEvaluatedKey).toBe(null);
+      expect(result.lastEvaluatedKey).toBe(undefined);
     });
 
-    it('should return an array of jobs if found', async () => {
+    it('should return an array of job executions if found', async () => {
       const mockJobExecutionRecords = createMockJobExecutionDtos();
       const mockLastEvaluatedKey = {
-        pk: { S: `${PARTITION_KEYS.job}-${'something'}` },
+        pk: { S: `${ENTITY_TYPES.job}-${'something'}` },
         sk: { S: 'mockSk' },
       };
 
-      mockSend.mockImplementationOnce(() =>
-        Promise.resolve({
-          Items: mockJobExecutionRecords,
-          LastEvaluatedKey: mockLastEvaluatedKey,
-        }),
-      );
-
-      const mockRequestData: PaginationInfo = mockPaginationInfo;
+      dynamoClient.on(QueryCommand).resolvesOnce({
+        Items: mockJobExecutionRecords,
+        LastEvaluatedKey: mockLastEvaluatedKey,
+      });
 
-      const result = await jobExecutionRepository.getExecutions(mockRequestData, 'something');
+      const result = await jobExecutionRepository.getExecutions(mockPaginationInfo, 'something');
 
-      expect(mockSend).toHaveBeenCalledWith(
-        expect.objectContaining({
-          input: { ...mockParams },
-        }),
-      );
+      expect(dynamoClient).toHaveReceivedCommandWith(QueryCommand, mockParams);
       expect(result.items).toHaveLength(mockJobExecutionRecords.length);
       expect(result.lastEvaluatedKey).toStrictEqual(mockLastEvaluatedKey);
     });
   });
+
+  describe('update', () => {
+    it('Updates the record properties', async () => {
+      const jobExecution = createMockJobExecution({ status: JOB_EXECUTION_STATUS.queued });
+      const updatedAttributes: UpdateJobExecutionParameters = {
+        input: faker.lorem.words(),
+        ecsTaskId: faker.string.uuid(),
+        version: faker.system.semver(),
+        timeStarted: faker.date.recent().toISOString(),
+        timeFinished: null,
+        context: faker.lorem.words(),
+      };
+      const updatedJobExecution = createMockJobExecution({
+        ...jobExecution,
+        ...updatedAttributes,
+      });
+
+      dynamoClient.on(UpdateItemCommand).resolvesOnce({
+        Attributes: createMockJobExecutionDto(updatedJobExecution),
+      });
+
+      const result = await jobExecutionRepository.update(jobExecution, updatedAttributes);
+
+      expect(result).toEqual(updatedJobExecution);
+      expect(dynamoClient).toHaveReceivedCommandWith(UpdateItemCommand, {
+        ExpressionAttributeNames: {
+          '#context': 'context',
+          '#ecsTaskId': 'ecsTaskId',
+          '#input': 'input',
+          '#timeFinished': 'timeFinished',
+          '#timeStarted': 'timeStarted',
+          '#version': 'version',
+        },
+        ExpressionAttributeValues: {
+          ':context': { S: updatedAttributes.context! },
+          ':ecsTaskId': { S: updatedAttributes.ecsTaskId! },
+          ':input': { S: updatedAttributes.input },
+          ':timeFinished': { NULL: true },
+          ':timeStarted': { S: updatedAttributes.timeStarted! },
+          ':version': { S: updatedAttributes.version! },
+        },
+        Key: {
+          pk: { S: `jobExecution~${tenant}` },
+          sk: { S: `${jobExecution.jobName}~${jobExecution.id}` },
+        },
+        ReturnValues: 'ALL_NEW',
+        TableName: tableName,
+        UpdateExpression:
+          'SET #input = :input, #ecsTaskId = :ecsTaskId, #version = :version, #timeStarted = :timeStarted, #timeFinished = :timeFinished, #context = :context',
+      });
+    });
+
+    it('Updates the record keys when the status is updated', async () => {
+      const jobExecution = createMockJobExecution({ status: JOB_EXECUTION_STATUS.queued });
+      const updatedJobExecution = createMockJobExecution({
+        ...jobExecution,
+        status: JOB_EXECUTION_STATUS.running,
+      });
+
+      dynamoClient.on(UpdateItemCommand).resolvesOnce({
+        Attributes: createMockJobExecutionDto(updatedJobExecution),
+      });
+
+      const result = await jobExecutionRepository.update(jobExecution, {
+        status: updatedJobExecution.status,
+      });
+
+      expect(result).toEqual(updatedJobExecution);
+      expect(dynamoClient).toHaveReceivedCommandWith(UpdateItemCommand, {
+        ExpressionAttributeNames: {
+          '#gsi1pk': 'gsi1pk',
+          '#lsi1sk': 'lsi1sk',
+          '#status': 'status',
+        },
+        ExpressionAttributeValues: {
+          ':gsi1pk': { S: `jobExecution~${updatedJobExecution.status}` },
+          ':lsi1sk': { S: `${updatedJobExecution.status}~${updatedJobExecution.jobName}` },
+          ':status': { S: updatedJobExecution.status },
+        },
+        Key: {
+          pk: { S: `jobExecution~${tenant}` },
+          sk: { S: `${jobExecution.jobName}~${jobExecution.id}` },
+        },
+        ReturnValues: 'ALL_NEW',
+        TableName: tableName,
+        UpdateExpression: 'SET #status = :status, #lsi1sk = :lsi1sk, #gsi1pk = :gsi1pk',
+      });
+    });
+  });
+
+  describe('batchDelete', () => {
+    it('should delete the requested dynamo records', async () => {
+      dynamoClient.on(BatchWriteItemCommand).resolves({});
+
+      const jobExecutions = createMockJobExecutions(3);
+      const result = await jobExecutionRepository.batchDelete(jobExecutions);
+
+      expect(result).toEqual({ unprocessedItems: [] });
+      expect(dynamoClient).toHaveReceivedCommandWith(BatchWriteItemCommand, {
+        RequestItems: {
+          [tableName]: [
+            {
+              DeleteRequest: {
+                Key: {
+                  pk: { S: `jobExecution~${tenant}` },
+                  sk: { S: `${jobExecutions[0].jobName}~${jobExecutions[0].id}` },
+                },
+              },
+            },
+            {
+              DeleteRequest: {
+                Key: {
+                  pk: { S: `jobExecution~${tenant}` },
+                  sk: { S: `${jobExecutions[1].jobName}~${jobExecutions[1].id}` },
+                },
+              },
+            },
+            {
+              DeleteRequest: {
+                Key: {
+                  pk: { S: `jobExecution~${tenant}` },
+                  sk: { S: `${jobExecutions[2].jobName}~${jobExecutions[2].id}` },
+                },
+              },
+            },
+          ],
+        },
+      });
+    });
+
+    it('should return without attempting to delete if an empty array of SK is provided', async () => {
+      const result = await jobExecutionRepository.batchDelete([]);
+
+      expect(result).toEqual({ unprocessedItems: [] });
+      expect(dynamoClient).not.toHaveReceivedCommand(BatchWriteItemCommand);
+    });
+
+    it('should return the unprocessed SK items if some items fail to delete', async () => {
+      const jobExecutions = createMockJobExecutions(3);
+
+      dynamoClient.on(BatchWriteItemCommand).resolves({
+        UnprocessedItems: {
+          [tableName]: [
+            {
+              DeleteRequest: {
+                Key: {
+                  pk: { S: `jobExecution~${tenant}` },
+                  sk: { S: `${jobExecutions[1].jobName}~${jobExecutions[1].id}` },
+                },
+              },
+            },
+          ],
+        },
+      });
+
+      const result = await jobExecutionRepository.batchDelete(jobExecutions);
+      expect(result).toEqual({ unprocessedItems: [jobExecutions[1]] });
+    });
+  });
 });