N21-1507 copy ctl tools

apps/server/src/modules/board/service/board-do-copy-service/board-do-copy.service.spec.ts

@@ -1,6 +1,9 @@
-import { createMock } from '@golevelup/ts-jest';
+import { createMock, DeepMocked } from '@golevelup/ts-jest';
+import { Configuration } from '@hpi-schul-cloud/commons/lib';
 import { FileRecordParentType } from '@infra/rabbitmq';
 import { CopyElementType, CopyStatus, CopyStatusEnum } from '@modules/copy-helper';
+import { ContextExternalTool } from '@modules/tool/context-external-tool/domain';
+import { ContextExternalToolService } from '@modules/tool/context-external-tool/service';
 import { Test, TestingModule } from '@nestjs/testing';
 import {
 	Card,
@@ -9,9 +12,6 @@ import {
 	DrawingElement,
 	ExternalToolElement,
 	FileElement,
-	LinkElement,
-	RichTextElement,
-	SubmissionContainerElement,
 	isCard,
 	isColumn,
 	isColumnBoard,
@@ -21,11 +21,15 @@ import {
 	isLinkElement,
 	isRichTextElement,
 	isSubmissionContainerElement,
+	LinkElement,
+	RichTextElement,
+	SubmissionContainerElement,
 } from '@shared/domain/domainobject';
 import {
 	cardFactory,
 	columnBoardFactory,
 	columnFactory,
+	contextExternalToolFactory,
 	drawingElementFactory,
 	externalToolElementFactory,
 	fileElementFactory,
@@ -43,12 +47,21 @@ describe('recursive board copy visitor', () => {
 	let module: TestingModule;
 	let service: BoardDoCopyService;
 
+	let contextExternalToolService: DeepMocked<ContextExternalToolService>;
+
 	beforeAll(async () => {
 		module = await Test.createTestingModule({
-			providers: [BoardDoCopyService],
+			providers: [
+				BoardDoCopyService,
+				{
+					provide: ContextExternalToolService,
+					useValue: createMock<ContextExternalToolService>(),
+				},
+			],
 		}).compile();
 
 		service = module.get(BoardDoCopyService);
+		contextExternalToolService = module.get(ContextExternalToolService);
 
 		await setupEntities();
 	});
@@ -711,61 +724,196 @@ describe('recursive board copy visitor', () => {
 		});
 	});
 
-	describe('when copying a external tool element', () => {
-		const setup = () => {
-			const original = externalToolElementFactory.build();
+	describe('when copying an external tool element', () => {
+		describe('when the element has no linked tool', () => {
+			const setup = () => {
+				const original = externalToolElementFactory.build();
 
-			return { original, ...setupfileCopyService() };
-		};
+				return { original, ...setupfileCopyService() };
+			};
 
-		const getExternalToolElementFromStatus = (status: CopyStatus): ExternalToolElement => {
-			const copy = status.copyEntity;
+			const getExternalToolElementFromStatus = (status: CopyStatus): ExternalToolElement => {
+				const copy = status.copyEntity;
 
-			expect(isExternalToolElement(copy)).toEqual(true);
+				expect(isExternalToolElement(copy)).toEqual(true);
 
-			return copy as ExternalToolElement;
-		};
+				return copy as ExternalToolElement;
+			};
 
-		it('should return a external tool element as copy', async () => {
-			const { original, fileCopyService } = setup();
+			it('should return a external tool element as copy', async () => {
+				const { original, fileCopyService } = setup();
 
-			const result = await service.copy({ original, fileCopyService });
+				const result = await service.copy({ original, fileCopyService });
 
-			expect(isExternalToolElement(result.copyEntity)).toEqual(true);
-		});
+				expect(isExternalToolElement(result.copyEntity)).toEqual(true);
+			});
 
-		it('should not copy tool', async () => {
-			const { original, fileCopyService } = setup();
+			it('should not copy tool', async () => {
+				const { original, fileCopyService } = setup();
 
-			const result = await service.copy({ original, fileCopyService });
-			const copy = getExternalToolElementFromStatus(result);
+				const result = await service.copy({ original, fileCopyService });
+				const copy = getExternalToolElementFromStatus(result);
 
-			expect(copy.contextExternalToolId).toBeUndefined();
-		});
+				expect(copy.contextExternalToolId).toBeUndefined();
+			});
 
-		it('should create new id', async () => {
-			const { original, fileCopyService } = setup();
+			it('should create new id', async () => {
+				const { original, fileCopyService } = setup();
 
-			const result = await service.copy({ original, fileCopyService });
-			const copy = getExternalToolElementFromStatus(result);
+				const result = await service.copy({ original, fileCopyService });
+				const copy = getExternalToolElementFromStatus(result);
 
-			expect(copy.id).not.toEqual(original.id);
-		});
+				expect(copy.id).not.toEqual(original.id);
+			});
 
-		it('should show status successful', async () => {
-			const { original, fileCopyService } = setup();
+			it('should show status successful', async () => {
+				const { original, fileCopyService } = setup();
 
-			const result = await service.copy({ original, fileCopyService });
+				const result = await service.copy({ original, fileCopyService });
 
-			expect(result.status).toEqual(CopyStatusEnum.SUCCESS);
+				expect(result.status).toEqual(CopyStatusEnum.SUCCESS);
+			});
+
+			it('should show type ExternalToolElement', async () => {
+				const { original, fileCopyService } = setup();
+
+				const result = await service.copy({ original, fileCopyService });
+
+				expect(result.type).toEqual(CopyElementType.EXTERNAL_TOOL_ELEMENT);
+			});
 		});
 
-		it('should show type RichTextElement', async () => {
-			const { original, fileCopyService } = setup();
+		describe('when the element has a linked tool and the feature is active', () => {
+			describe('when the linked tool exists', () => {
+				const setup = () => {
+					const originalTool: ContextExternalTool = contextExternalToolFactory.buildWithId();
+					const copiedTool: ContextExternalTool = contextExternalToolFactory.buildWithId();
 
-			const result = await service.copy({ original, fileCopyService });
+					const original: ExternalToolElement = externalToolElementFactory.build({
+						contextExternalToolId: originalTool.id,
+					});
+
+					contextExternalToolService.findById.mockResolvedValueOnce(originalTool);
+					contextExternalToolService.copyContextExternalTool.mockResolvedValueOnce(copiedTool);
+
+					Configuration.set('FEATURE_CTL_TOOLS_COPY_ENABLED', true);
+
+					return { original, ...setupfileCopyService(), copiedTool };
+				};
+
+				const getExternalToolElementFromStatus = (status: CopyStatus): ExternalToolElement => {
+					const copy = status.copyEntity;
+
+					expect(isExternalToolElement(copy)).toEqual(true);
+
+					return copy as ExternalToolElement;
+				};
+
+				it('should return a external tool element as copy', async () => {
+					const { original, fileCopyService } = setup();
+
+					const result = await service.copy({ original, fileCopyService });
+
+					expect(isExternalToolElement(result.copyEntity)).toEqual(true);
+				});
+
+				it('should copy tool', async () => {
+					const { original, fileCopyService, copiedTool } = setup();
+
+					const result = await service.copy({ original, fileCopyService });
+					const copy = getExternalToolElementFromStatus(result);
+
+					expect(copy.contextExternalToolId).toEqual(copiedTool.id);
+				});
+
+				it('should create new id', async () => {
+					const { original, fileCopyService } = setup();
+
+					const result = await service.copy({ original, fileCopyService });
+					const copy = getExternalToolElementFromStatus(result);
+
+					expect(copy.id).not.toEqual(original.id);
+				});
+
+				it('should show status successful', async () => {
+					const { original, fileCopyService } = setup();
+
+					const result = await service.copy({ original, fileCopyService });
+
+					expect(result.status).toEqual(CopyStatusEnum.SUCCESS);
+				});
+
+				it('should show type ExternalToolElement', async () => {
+					const { original, fileCopyService } = setup();
+
+					const result = await service.copy({ original, fileCopyService });
+
+					expect(result.type).toEqual(CopyElementType.EXTERNAL_TOOL_ELEMENT);
+				});
+			});
 
-			expect(result.type).toEqual(CopyElementType.EXTERNAL_TOOL_ELEMENT);
+			describe('when the linked tool does not exist anymore', () => {
+				const setup = () => {
+					const original: ExternalToolElement = externalToolElementFactory.build({
+						contextExternalToolId: new ObjectId().toHexString(),
+					});
+
+					contextExternalToolService.findById.mockResolvedValueOnce(null);
+
+					Configuration.set('FEATURE_CTL_TOOLS_COPY_ENABLED', true);
+
+					return { original, ...setupfileCopyService() };
+				};
+
+				const getExternalToolElementFromStatus = (status: CopyStatus): ExternalToolElement => {
+					const copy = status.copyEntity;
+
+					expect(isExternalToolElement(copy)).toEqual(true);
+
+					return copy as ExternalToolElement;
+				};
+
+				it('should return a external tool element as copy', async () => {
+					const { original, fileCopyService } = setup();
+
+					const result = await service.copy({ original, fileCopyService });
+
+					expect(isExternalToolElement(result.copyEntity)).toEqual(true);
+				});
+
+				it('should not try to copy the tool', async () => {
+					const { original, fileCopyService } = setup();
+
+					await service.copy({ original, fileCopyService });
+
+					expect(contextExternalToolService.copyContextExternalTool).not.toHaveBeenCalled();
+				});
+
+				it('should create new id', async () => {
+					const { original, fileCopyService } = setup();
+
+					const result = await service.copy({ original, fileCopyService });
+					const copy = getExternalToolElementFromStatus(result);
+
+					expect(copy.id).not.toEqual(original.id);
+				});
+
+				it('should show status fail', async () => {
+					const { original, fileCopyService } = setup();
+
+					const result = await service.copy({ original, fileCopyService });
+
+					expect(result.status).toEqual(CopyStatusEnum.FAIL);
+				});
+
+				it('should show type ExternalToolElement', async () => {
+					const { original, fileCopyService } = setup();
+
+					const result = await service.copy({ original, fileCopyService });
+
+					expect(result.type).toEqual(CopyElementType.EXTERNAL_TOOL_ELEMENT);
+				});
+			});
 		});
 	});
 

apps/server/src/modules/board/service/board-do-copy-service/board-do-copy.service.ts

@@ -1,3 +1,4 @@
+import { ContextExternalToolService } from '@modules//tool/context-external-tool/service';
 import { CopyStatus } from '@modules/copy-helper';
 import { Injectable } from '@nestjs/common';
 import { AnyBoardDo } from '@shared/domain/domainobject';
@@ -11,8 +12,10 @@ export type BoardDoCopyParams = {
 
 @Injectable()
 export class BoardDoCopyService {
+	constructor(private readonly contextExternalToolService: ContextExternalToolService) {}
+
 	public async copy(params: BoardDoCopyParams): Promise<CopyStatus> {
-		const visitor = new RecursiveCopyVisitor(params.fileCopyService);
+		const visitor = new RecursiveCopyVisitor(params.fileCopyService, this.contextExternalToolService);
 
 		const result = await visitor.copy(params.original);
 

apps/server/src/modules/board/service/board-do-copy-service/recursive-copy.visitor.spec.ts

@@ -3,27 +3,35 @@ import { Test, TestingModule } from '@nestjs/testing';
 import { LinkElement } from '@shared/domain/domainobject';
 import { linkElementFactory, setupEntities } from '@shared/testing';
 import { CopyFileDto } from '@src/modules/files-storage-client/dto';
+import { ContextExternalToolService } from '../../../tool/context-external-tool/service';
 
 import { RecursiveCopyVisitor } from './recursive-copy.visitor';
 import { SchoolSpecificFileCopyServiceFactory } from './school-specific-file-copy-service.factory';
 import { SchoolSpecificFileCopyService } from './school-specific-file-copy.interface';
 
 describe(RecursiveCopyVisitor.name, () => {
 	let module: TestingModule;
+
 	let fileCopyServiceFactory: DeepMocked<SchoolSpecificFileCopyServiceFactory>;
+	let contextExternalToolService: DeepMocked<ContextExternalToolService>;
 
 	beforeAll(async () => {
 		module = await Test.createTestingModule({
 			providers: [
+				RecursiveCopyVisitor,
 				{
 					provide: SchoolSpecificFileCopyServiceFactory,
 					useValue: createMock<SchoolSpecificFileCopyServiceFactory>(),
 				},
-				RecursiveCopyVisitor,
+				{
+					provide: ContextExternalToolService,
+					useValue: createMock<ContextExternalToolService>(),
+				},
 			],
 		}).compile();
 
 		fileCopyServiceFactory = module.get(SchoolSpecificFileCopyServiceFactory);
+		contextExternalToolService = module.get(ContextExternalToolService);
 
 		await setupEntities();
 	});
@@ -57,7 +65,7 @@ describe(RecursiveCopyVisitor.name, () => {
 				const { fileCopyServiceMock } = setup();
 
 				const linkElement = linkElementFactory.build();
-				const visitor = new RecursiveCopyVisitor(fileCopyServiceMock);
+				const visitor = new RecursiveCopyVisitor(fileCopyServiceMock, contextExternalToolService);
 
 				await visitor.visitLinkElementAsync(linkElement);
 
@@ -70,7 +78,7 @@ describe(RecursiveCopyVisitor.name, () => {
 				const { fileCopyServiceMock, imageUrl } = setup({ withFileCopy: true });
 
 				const linkElement = linkElementFactory.build({ imageUrl });
-				const visitor = new RecursiveCopyVisitor(fileCopyServiceMock);
+				const visitor = new RecursiveCopyVisitor(fileCopyServiceMock, contextExternalToolService);
 
 				await visitor.visitLinkElementAsync(linkElement);
 
@@ -83,7 +91,7 @@ describe(RecursiveCopyVisitor.name, () => {
 				const { fileCopyServiceMock, imageUrl, newFileId } = setup({ withFileCopy: true });
 
 				const linkElement = linkElementFactory.build({ imageUrl });
-				const visitor = new RecursiveCopyVisitor(fileCopyServiceMock);
+				const visitor = new RecursiveCopyVisitor(fileCopyServiceMock, contextExternalToolService);
 
 				await visitor.visitLinkElementAsync(linkElement);
 				const copy = visitor.copyMap.get(linkElement.id) as LinkElement;
@@ -97,7 +105,7 @@ describe(RecursiveCopyVisitor.name, () => {
 				const { fileCopyServiceMock } = setup({ withFileCopy: true });
 
 				const linkElement = linkElementFactory.build({ imageUrl: `https://abc.de/file/unknown-file-id` });
-				const visitor = new RecursiveCopyVisitor(fileCopyServiceMock);
+				const visitor = new RecursiveCopyVisitor(fileCopyServiceMock, contextExternalToolService);
 
 				await visitor.visitLinkElementAsync(linkElement);
 				const copy = visitor.copyMap.get(linkElement.id) as LinkElement;