BC-7561 - separate job for failed batch deletion requests

apps/server/src/modules/deletion-console/builder/trigger-deletion-execution-options.builder.spec.ts

@@ -1,4 +1,3 @@
-import { TriggerDeletionExecutionOptions } from '../interface';
 import { TriggerDeletionExecutionOptionsBuilder } from './trigger-deletion-execution-options.builder';
 
 describe(TriggerDeletionExecutionOptionsBuilder.name, () => {
@@ -8,17 +7,15 @@ describe(TriggerDeletionExecutionOptionsBuilder.name, () => {
 				const limit = 1000;
 				const runFailed = false;
 
-				const expectedOutput: TriggerDeletionExecutionOptions = { limit, runFailed };
-
-				return { expectedOutput, limit, runFailed };
+				return { limit, runFailed };
 			};
 
 			it('should return valid object with expected values', () => {
-				const { expectedOutput, limit, runFailed } = setup();
+				const { limit, runFailed } = setup();
 
 				const output = TriggerDeletionExecutionOptionsBuilder.build(limit, runFailed);
 
-				expect(output).toStrictEqual(expectedOutput);
+				expect(output).toStrictEqual({ limit, runFailed });
 			});
 		});
 	});

apps/server/src/modules/deletion-console/deletion-client/deletion.client.spec.ts

@@ -249,5 +249,28 @@ describe(DeletionClient.name, () => {
 				await expect(client.executeDeletions()).rejects.toThrow(Error);
 			});
 		});
+
+		describe('when runFailed is true', () => {
+			const setup = () => {
+				setupConfig();
+
+				const response: AxiosResponse<DeletionRequestOutput> = axiosResponseFactory.build({
+					status: 204,
+				});
+
+				httpService.post.mockReturnValueOnce(of(response));
+
+				const fullUrl = 'http://api-admin:4030/admin/api/v1/deletionExecutions?runFailed=true';
+
+				return { fullUrl };
+			};
+			it('should call endpoint with runFailed param', async () => {
+				const { fullUrl } = setup();
+
+				await client.executeDeletions(undefined, true);
+
+				expect(httpService.post).toHaveBeenCalledWith(fullUrl, null, expect.any(Object));
+			});
+		});
 	});
 });

apps/server/src/modules/deletion-console/deletion-client/deletion.client.ts

@@ -55,7 +55,7 @@ export class DeletionClient {
 		const postDeletionExecutionsEndpoint = new URL(endpoint, baseUrl);
 
 		const params = new URLSearchParams(postDeletionExecutionsEndpoint.search);
-		if (limit && this.isLimitGeaterZero(limit)) {
+		if (limit && this.isLimitGreaterZero(limit)) {
 			params.append('limit', limit.toString());
 		}
 		if (runFailed) {
@@ -99,7 +99,7 @@ export class DeletionClient {
 		}
 	}
 
-	private isLimitGeaterZero(limit?: number): boolean {
+	private isLimitGreaterZero(limit?: number): boolean {
 		return typeof limit === 'number' && limit > 0;
 	}
 

apps/server/src/modules/deletion-console/deletion-execution.console.spec.ts

@@ -6,6 +6,7 @@ import { DeletionExecutionConsole } from './deletion-execution.console';
 import { DeletionExecutionTriggerResultBuilder, TriggerDeletionExecutionOptionsBuilder } from './builder';
 import { DeletionExecutionUc } from './uc';
 import { DeletionConsoleModule } from './deletion-console.app.module';
+import { TriggerDeletionExecutionOptions } from './interface';
 
 describe(DeletionExecutionConsole.name, () => {
 	let module: TestingModule;
@@ -92,5 +93,29 @@ describe(DeletionExecutionConsole.name, () => {
 				expect(spy).toHaveBeenCalledWith(err);
 			});
 		});
+
+		describe('when runFailed is given as string "true"', () => {
+			it('should convert runFailed to boolean', async () => {
+				const options = { limit: 1000, runFailed: 'true' } as unknown as TriggerDeletionExecutionOptions;
+
+				const spy = jest.spyOn(deletionExecutionUc, 'triggerDeletionExecution').mockResolvedValueOnce(undefined);
+
+				await console.triggerDeletionExecution(options);
+
+				expect(spy).toHaveBeenCalledWith(1000, true);
+			});
+		});
+
+		describe('when limit is a string "5"', () => {
+			it('should convert limit to number', async () => {
+				const options = { limit: '5', runFailed: false } as unknown as TriggerDeletionExecutionOptions;
+
+				const spy = jest.spyOn(deletionExecutionUc, 'triggerDeletionExecution').mockResolvedValueOnce(undefined);
+
+				await console.triggerDeletionExecution(options);
+
+				expect(spy).toHaveBeenCalledWith(5, false);
+			});
+		});
 	});
 });

apps/server/src/modules/deletion-console/deletion-execution.console.ts

@@ -14,24 +14,34 @@ export class DeletionExecutionConsole {
 		options: [
 			{
 				flags: '-l, --limit <value>',
-				fn: (value: string) => (value ? Number(value) : undefined),
+				// TODO implemnt fn with proper command testing
+				// fn: (value: string) => (value ? Number(value) : undefined),
 				description: 'Limit of the requested deletion executions that should be performed.',
 				required: false,
 			},
 			{
 				flags: '-f, --runFailed <value>',
-				fn: (value: string) => /^(true|yes|1)$/i.test(value),
+				// TODO implemnt fn with proper command testing
+				// fn: (value: string) => /^(true|yes|1)$/i.test(value),
 				description: 'Limit of the requested deletion executions that should be performed.',
 				required: false,
 			},
 		],
 	})
-	async triggerDeletionExecution(options: TriggerDeletionExecutionOptions): Promise<void> {
+	public async triggerDeletionExecution(options: TriggerDeletionExecutionOptions): Promise<void> {
 		// Try to trigger the deletion execution(s) via Deletion API client,
 		// return successful status in case of a success, otherwise return
 		// a result with a failure status and a proper error message.
 		let result: DeletionExecutionTriggerResult;
 
+		if (typeof options.limit === 'string') {
+			options.limit = Number(options.limit);
+		}
+
+		if (typeof options.runFailed === 'string') {
+			options.runFailed = /^(true|yes|1)$/i.test(options.runFailed);
+		}
+
 		try {
 			await this.deletionExecutionUc.triggerDeletionExecution(options.limit, options.runFailed);
 			result = DeletionExecutionTriggerResultBuilder.buildSuccess();

apps/server/src/modules/deletion-console/interface/trigger-deletion-execution-options.interface.ts

@@ -1,4 +1,4 @@
 export interface TriggerDeletionExecutionOptions {
-	limit: number;
-	runFailed: boolean;
+	limit: string | number;
+	runFailed: string | boolean;
 }

apps/server/src/modules/deletion/api/controller/api-test/deletion-request-create.api.spec.ts

@@ -88,14 +88,14 @@ describe(`deletionRequest create (api)`, () => {
 					deleteAfterMinutes: 0,
 				};
 
-				const defaultdeleteAfterMinutes = 43200;
+				const defaultDeleteAfterMinutes = 43200;
 
 				const operationalTimeToleranceInSeconds = 30;
 
 				return {
 					deletionRequestToCreate,
 					deletionRequestToImmediateRemoval,
-					defaultdeleteAfterMinutes,
+					defaultDeleteAfterMinutes,
 					operationalTimeToleranceInSeconds,
 				};
 			};
@@ -119,7 +119,7 @@ describe(`deletionRequest create (api)`, () => {
 
 			describe('when the "delete after minutes" param has not been provided', () => {
 				it('should set the "deleteAfter" date to the date after the default DELETION_DELETE_AFTER_MINUTES ', async () => {
-					const { deletionRequestToCreate, defaultdeleteAfterMinutes, operationalTimeToleranceInSeconds } = setup();
+					const { deletionRequestToCreate, defaultDeleteAfterMinutes, operationalTimeToleranceInSeconds } = setup();
 
 					const response = await testApiClient.post('', deletionRequestToCreate);
 
@@ -131,7 +131,7 @@ describe(`deletionRequest create (api)`, () => {
 					const isDeletionPlannedAtDateCorrect = isDeletionPlannedWithinAcceptableRange(
 						createdItem.createdAt,
 						createdItem.deleteAfter,
-						defaultdeleteAfterMinutes,
+						defaultDeleteAfterMinutes,
 						operationalTimeToleranceInSeconds
 					);
 

apps/server/src/modules/deletion/api/uc/deletion-request.uc.spec.ts

@@ -1,10 +1,9 @@
 import { LegacyLogger } from '@core/logger';
 import { createMock, DeepMocked } from '@golevelup/ts-jest';
 import { MikroORM } from '@mikro-orm/core';
-import { ConfigModule } from '@nestjs/config';
+import { ConfigService } from '@nestjs/config';
 import { EventBus } from '@nestjs/cqrs';
 import { Test, TestingModule } from '@nestjs/testing';
-import { createConfigModuleOptions } from '@shared/common/config-module-options';
 import { setupEntities } from '@testing/setup-entities';
 import { ObjectId } from 'bson';
 import { DomainDeletionReportBuilder, DomainOperationReportBuilder } from '../../domain/builder';
@@ -17,19 +16,20 @@ import { DeletionRequestLogResponseBuilder } from '../builder';
 import { DeletionRequestBodyProps } from '../controller/dto';
 import { DeletionLogStatisticBuilder, DeletionTargetRefBuilder } from '../controller/dto/builder';
 import { DeletionRequestUc } from './deletion-request.uc';
+import { DeletionConfig } from '../../deletion.config';
 
 describe(DeletionRequestUc.name, () => {
 	let module: TestingModule;
 	let uc: DeletionRequestUc;
 	let deletionRequestService: DeepMocked<DeletionRequestService>;
 	let deletionLogService: DeepMocked<DeletionLogService>;
 	let eventBus: DeepMocked<EventBus>;
+	let configService: DeepMocked<ConfigService<DeletionConfig, true>>;
 
 	beforeAll(async () => {
 		const orm = await setupEntities();
 
 		module = await Test.createTestingModule({
-			imports: [ConfigModule.forRoot(createConfigModuleOptions(deletionTestConfig))],
 			providers: [
 				DeletionRequestUc,
 				{
@@ -54,22 +54,30 @@ describe(DeletionRequestUc.name, () => {
 					provide: MikroORM,
 					useValue: orm,
 				},
+				{
+					provide: ConfigService,
+					useValue: createMock<ConfigService>(),
+				},
 			],
 		}).compile();
 
 		uc = module.get(DeletionRequestUc);
 		deletionRequestService = module.get(DeletionRequestService);
 		deletionLogService = module.get(DeletionLogService);
 		eventBus = module.get(EventBus);
+		configService = module.get(ConfigService);
 	});
 
-	beforeEach(() => {
+	afterEach(() => {
 		jest.clearAllMocks();
+		jest.useRealTimers();
 	});
 
 	describe('createDeletionRequest', () => {
 		describe('when creating a deletionRequest', () => {
 			const setup = () => {
+				jest.useFakeTimers().setSystemTime(new Date());
+
 				const deleteAfterMinutes = 1;
 				const deletionRequestToCreate: DeletionRequestBodyProps = {
 					targetRef: {
@@ -151,22 +159,83 @@ describe(DeletionRequestUc.name, () => {
 
 	describe('executeDeletionRequests', () => {
 		describe('when deletionRequests to execute exists', () => {
-			const setup = () => {
+			const setup = (noDelay = false) => {
+				deletionRequestService.findInProgressCount.mockResolvedValue(1);
+
+				configService.get.mockImplementation((key) => {
+					if (key === 'ADMIN_API__DELETION_DELETE_AFTER_MINUTES') {
+						return 1;
+					}
+					if (key === 'ADMIN_API__DELETION_MODIFICATION_THRESHOLD_MS') {
+						return 100;
+					}
+					if (key === 'ADMIN_API__DELETION_CONSIDER_FAILED_AFTER_MS') {
+						return 1000;
+					}
+					if (key === 'ADMIN_API__DELETION_MAX_CONCURRENT_DELETION_REQUESTS') {
+						return 2;
+					}
+					if (key === 'ADMIN_API__DELETION_DELAY_MILLISECONDS') {
+						return noDelay ? 0 : 100;
+					}
+					return deletionTestConfig()[key];
+				});
+
 				const deletionRequest = deletionRequestFactory.buildWithId({ deleteAfter: new Date('2023-01-01') });
+				deletionRequestService.findAllItemsToExecute.mockResolvedValueOnce([deletionRequest]);
+				deletionRequestService.markDeletionRequestAsPending.mockResolvedValueOnce(true);
 
 				return { deletionRequest };
 			};
-			it('should call deletionRequestService.findAllItemsToExecute', async () => {
+			it('should call deletionRequestService.findInProgressCount', async () => {
+				setup();
+
 				await uc.executeDeletionRequests();
 
-				expect(deletionRequestService.findAllItemsToExecute).toHaveBeenCalled();
+				expect(deletionRequestService.findInProgressCount).toHaveBeenCalled();
+			});
+
+			it('should call deletionRequestService.findAllItemsToExecute with correct limit', async () => {
+				setup();
+
+				await uc.executeDeletionRequests();
+
+				expect(deletionRequestService.findAllItemsToExecute).toHaveBeenCalledWith(1, undefined);
+			});
+
+			describe('when limit is given', () => {
+				it('should call deletionRequestService.findAllItemsToExecute with correct limit', async () => {
+					setup();
+
+					await uc.executeDeletionRequests(10);
+
+					expect(deletionRequestService.findAllItemsToExecute).toHaveBeenCalledWith(9, undefined);
+				});
+			});
+
+			describe('when limit is not given', () => {
+				it('should call deletionRequestService.findAllItemsToExecute with correct limit', async () => {
+					setup();
+
+					await uc.executeDeletionRequests();
+
+					expect(deletionRequestService.findAllItemsToExecute).toHaveBeenCalledWith(1, undefined);
+				});
+			});
+
+			describe('when getFailed is true', () => {
+				it('should call deletionRequestService.findAllItemsToExecute with getFailed true', async () => {
+					setup();
+
+					await uc.executeDeletionRequests(undefined, true);
+
+					expect(deletionRequestService.findAllItemsToExecute).toHaveBeenCalledWith(1, true);
+				});
 			});
 
 			it('should call deletionRequestService.markDeletionRequestAsPending to update status of deletionRequests', async () => {
 				const { deletionRequest } = setup();
 
-				deletionRequestService.findAllItemsToExecute.mockResolvedValueOnce([deletionRequest]);
-
 				await uc.executeDeletionRequests();
 
 				expect(deletionRequestService.markDeletionRequestAsPending).toHaveBeenCalledWith(deletionRequest.id);
@@ -175,21 +244,30 @@ describe(DeletionRequestUc.name, () => {
 			it('should call eventBus.publish', async () => {
 				const { deletionRequest } = setup();
 
-				deletionRequestService.findAllItemsToExecute.mockResolvedValueOnce([deletionRequest]);
-
 				await uc.executeDeletionRequests();
 
 				expect(eventBus.publish).toHaveBeenCalledWith(
 					new UserDeletedEvent(deletionRequest.id, deletionRequest.targetRefId)
 				);
 			});
+
+			it('should work with a delay of 0', async () => {
+				setup(true);
+
+				await uc.executeDeletionRequests();
+
+				expect(deletionRequestService.markDeletionRequestAsFailed).not.toHaveBeenCalled();
+			});
 		});
 
 		describe('when an error occurred', () => {
 			const setup = () => {
 				const deletionRequestToExecute = deletionRequestFactory.build({ deleteAfter: new Date('2023-01-01') });
 
+				configService.get.mockImplementation((key) => deletionTestConfig()[key]);
+
 				deletionRequestService.findAllItemsToExecute.mockResolvedValueOnce([deletionRequestToExecute]);
+				deletionRequestService.findInProgressCount.mockResolvedValueOnce(1);
 				eventBus.publish.mockRejectedValueOnce(new Error());
 
 				return {