EW-998 created a new sync Module

apps/server/src/console/console.module.ts

@@ -1,6 +1,6 @@
 import { Configuration } from '@hpi-schul-cloud/commons/lib';
 import { ConsoleWriterModule } from '@infra/console/console-writer/console-writer.module';
 import { KeycloakModule } from '@infra/identity-management/keycloak/keycloak.module';
 import { MikroOrmModule } from '@mikro-orm/nestjs';
 import { FilesModule } from '@modules/files';
 import { ManagementModule } from '@modules/management/management.module';
@@ -9,6 +9,7 @@
 import { ConfigModule } from '@nestjs/config';
 import { createConfigModuleOptions } from '@src/config';
 import { ConsoleModule } from 'nestjs-console';
+import { SyncModule } from '@infra/sync/sync.module';
 import { ServerConsole } from './server.console';
 import { mikroOrmCliConfig } from '../config/mikro-orm-cli.config';
 
@@ -21,6 +22,7 @@
 		ConfigModule.forRoot(createConfigModuleOptions(serverConfig)),
 		...((Configuration.get('FEATURE_IDENTITY_MANAGEMENT_ENABLED') as boolean) ? [KeycloakModule] : []),
 		MikroOrmModule.forRoot(mikroOrmCliConfig),
+		SyncModule,
 	],
 	providers: [
 		/** add console services as providers */

apps/server/src/infra/sync/console/sync.console.spec.ts

@@ -0,0 +1,49 @@
+import { createMock } from '@golevelup/ts-jest';
+import { Test } from '@nestjs/testing';
+import { Logger } from '@src/core/logger';
+import { SyncUc } from '../uc/sync.uc';
+import { SyncConsole } from './sync.console';
+
+describe(SyncConsole.name, () => {
+	let syncConsole: SyncConsole;
+	let syncUc: SyncUc;
+
+	beforeAll(async () => {
+		const module = await Test.createTestingModule({
+			providers: [
+				SyncConsole,
+				{
+					provide: SyncUc,
+					useValue: createMock<SyncUc>(),
+				},
+				{
+					provide: Logger,
+					useValue: createMock<Logger>(),
+				},
+			],
+		}).compile();
+
+		syncConsole = module.get(SyncConsole);
+		syncUc = module.get(SyncUc);
+	});
+
+	describe('when sync console is initialized', () => {
+		it('should be defined', () => {
+			expect(syncConsole).toBeDefined();
+		});
+	});
+
+	describe('startSync', () => {
+		const setup = () => {
+			const target = 'tsp';
+			return { target };
+		};
+
+		it('should call startSync method of syncUc', async () => {
+			const { target } = setup();
+			await syncConsole.startSync(target);
+
+			expect(syncUc.startSync).toHaveBeenCalledWith(target);
+		});
+	});
+});

apps/server/src/infra/sync/console/sync.console.ts

@@ -0,0 +1,18 @@
+import { Logger } from '@src/core/logger';
+import { Command, Console } from 'nestjs-console';
+import { SyncUc } from '../uc/sync.uc';
+
+@Console({ command: 'sync', description: 'Prefixes all synchronization related console commands.' })
+export class SyncConsole {
+	constructor(private readonly syncUc: SyncUc, private readonly logger: Logger) {
+		this.logger.setContext(SyncConsole.name);
+	}
+
+	@Command({
+		command: 'run <target>',
+		description: 'Starts the synchronization process.',
+	})
+	public async startSync(target: string): Promise<void> {
+		await this.syncUc.startSync(target);
+	}
+}

apps/server/src/infra/sync/errors/invalid-target.loggable.spec.ts

@@ -0,0 +1,28 @@
+import { SyncStrategyTarget } from '../sync-strategy.types';
+import { InvalidTargetLoggable } from './invalid-target.loggable';
+
+describe(InvalidTargetLoggable.name, () => {
+	let loggable: InvalidTargetLoggable;
+
+	beforeAll(() => {
+		loggable = new InvalidTargetLoggable('invalid-target');
+	});
+
+	describe('when loggable is initialized', () => {
+		it('should be defined', () => {
+			expect(loggable).toBeDefined();
+		});
+	});
+
+	describe('getLogMessage', () => {
+		it('should return a log message with the entered target and available targets', () => {
+			expect(loggable.getLogMessage()).toEqual({
+				message: 'Either synchronization is not activated or the target entered is invalid',
+				data: {
+					enteredTarget: 'invalid-target',
+					avaliableTargets: SyncStrategyTarget,
+				},
+			});
+		});
+	});
+});

apps/server/src/infra/sync/errors/invalid-target.loggable.ts

@@ -0,0 +1,16 @@
+import { ErrorLogMessage, LogMessage, Loggable, ValidationErrorLogMessage } from '@src/core/logger';
+import { SyncStrategyTarget } from '../sync-strategy.types';
+
+export class InvalidTargetLoggable implements Loggable {
+	constructor(private readonly target: string) {}
+
+	getLogMessage(): LogMessage | ErrorLogMessage | ValidationErrorLogMessage {
+		return {
+			message: 'Either synchronization is not activated or the target entered is invalid',
+			data: {
+				enteredTarget: this.target,
+				avaliableTargets: SyncStrategyTarget,
+			},
+		};
+	}
+}

apps/server/src/infra/sync/service/sync.service.spec.ts

@@ -0,0 +1,86 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { createMock } from '@golevelup/ts-jest';
+import { faker } from '@faker-js/faker';
+import { Logger } from '@src/core/logger';
+import { SyncService } from './sync.service';
+import { TspSyncStrategy } from '../tsp/tsp-sync.strategy';
+import { SyncStrategyTarget } from '../sync-strategy.types';
+import { InvalidTargetLoggable } from '../errors/invalid-target.loggable';
+
+describe(SyncService.name, () => {
+	let module: TestingModule;
+	let service: SyncService;
+	let tspSyncStrategy: TspSyncStrategy;
+	let logger: Logger;
+
+	beforeAll(async () => {
+		module = await Test.createTestingModule({
+			providers: [
+				SyncService,
+				{
+					provide: TspSyncStrategy,
+					useValue: createMock<TspSyncStrategy>({
+						getType(): SyncStrategyTarget {
+							return SyncStrategyTarget.TSP;
+						},
+						sync(): Promise<void> {
+							return Promise.resolve();
+						},
+					}),
+				},
+				{
+					provide: Logger,
+					useValue: createMock<Logger>(),
+				},
+			],
+		}).compile();
+
+		service = module.get(SyncService);
+		tspSyncStrategy = module.get(TspSyncStrategy);
+		logger = module.get(Logger);
+	});
+
+	afterAll(async () => {
+		await module.close();
+	});
+
+	describe('when sync service is initialized', () => {
+		it('should be defined', () => {
+			expect(service).toBeDefined();
+		});
+	});
+
+	describe('startSync', () => {
+		describe('when provided target is invalid or the sync is deactivated', () => {
+			const setup = () => {
+				const invalidTarget = faker.lorem.word();
+				const output = new InvalidTargetLoggable(invalidTarget);
+
+				return { output, invalidTarget };
+			};
+
+			it('should throw an invalid provided target error', async () => {
+				const { output, invalidTarget } = setup();
+				await service.startSync(invalidTarget);
+
+				expect(logger.info).toHaveBeenCalledWith(output);
+			});
+		});
+
+		describe('when provided target is valid and synchronization is activated', () => {
+			const setup = () => {
+				const validSystem = 'tsp';
+				Reflect.set(service, 'strategies', new Map([[SyncStrategyTarget.TSP, tspSyncStrategy]]));
+
+				return { validSystem };
+			};
+
+			it('should call sync method of the provided target', async () => {
+				const { validSystem } = setup();
+				await service.startSync(validSystem);
+
+				expect(tspSyncStrategy.sync).toHaveBeenCalled();
+			});
+		});
+	});
+});

apps/server/src/infra/sync/service/sync.service.ts

@@ -0,0 +1,30 @@
+import { Injectable, Optional } from '@nestjs/common';
+import { Logger } from '@src/core/logger';
+import { TspSyncStrategy } from '../tsp/tsp-sync.strategy';
+import { SyncStrategy } from '../strategy/sync-strategy';
+import { SyncStrategyTarget } from '../sync-strategy.types';
+import { InvalidTargetLoggable } from '../errors/invalid-target.loggable';
+
+@Injectable()
+export class SyncService {
+	private strategies: Map<SyncStrategyTarget, SyncStrategy> = new Map<SyncStrategyTarget, SyncStrategy>();
+
+	constructor(private readonly logger: Logger, @Optional() private readonly tspSyncStrategy?: TspSyncStrategy) {
+		this.logger.setContext(SyncService.name);
+		this.registerStrategy(tspSyncStrategy);
+	}
+
+	protected registerStrategy(strategy?: SyncStrategy) {
+		if (strategy) {
+			this.strategies.set(strategy.getType(), strategy);
+		}
+	}
+
+	public async startSync(target: string): Promise<void> {
+		const targetStrategy = target as SyncStrategyTarget;
+		if (!this.strategies.has(targetStrategy)) {
+			this.logger.info(new InvalidTargetLoggable(target));
+		}
+		await this.strategies.get(targetStrategy)?.sync();
+	}
+}

apps/server/src/infra/sync/strategy/sync-strategy.ts

@@ -0,0 +1,7 @@
+import { SyncStrategyTarget } from '../sync-strategy.types';
+
+export abstract class SyncStrategy {
+	abstract getType(): SyncStrategyTarget;
+
+	abstract sync(): Promise<void>;
+}

apps/server/src/infra/sync/sync-strategy.types.ts

@@ -0,0 +1,3 @@
+export enum SyncStrategyTarget {
+	TSP = 'tsp',
+}

apps/server/src/infra/sync/sync.module.ts

@@ -0,0 +1,20 @@
+import { Module } from '@nestjs/common';
+import { LoggerModule } from '@src/core/logger';
+import { ConsoleWriterModule } from '@infra/console';
+import { Configuration } from '@hpi-schul-cloud/commons/lib';
+import { SyncConsole } from './console/sync.console';
+import { SyncUc } from './uc/sync.uc';
+import { SyncService } from './service/sync.service';
+import { TspSyncStrategy } from './tsp/tsp-sync.strategy';
+
+@Module({
+	imports: [LoggerModule, ConsoleWriterModule],
+	providers: [
+		SyncConsole,
+		SyncUc,
+		SyncService,
+		...((Configuration.get('FEATURE_TSP_SYNC_ENABLED') as boolean) ? [TspSyncStrategy] : []),
+	],
+	exports: [SyncConsole],
+})
+export class SyncModule {}

apps/server/src/infra/sync/tsp/tsp-sync.strategy.spec.ts

@@ -0,0 +1,42 @@
+import { TestingModule, Test } from '@nestjs/testing';
+import { SyncStrategyTarget } from '../sync-strategy.types';
+import { TspSyncStrategy } from './tsp-sync.strategy';
+
+describe(TspSyncStrategy.name, () => {
+	let module: TestingModule;
+	let strategy: TspSyncStrategy;
+
+	beforeAll(async () => {
+		module = await Test.createTestingModule({
+			providers: [TspSyncStrategy],
+		}).compile();
+
+		strategy = module.get(TspSyncStrategy);
+	});
+
+	afterAll(async () => {
+		await module.close();
+	});
+
+	describe('when tsp sync strategy is initialized', () => {
+		it('should be defined', () => {
+			expect(strategy).toBeDefined();
+		});
+	});
+
+	describe('getType', () => {
+		describe('when tsp sync strategy is initialized', () => {
+			it('should return tsp', () => {
+				expect(strategy.getType()).toBe(SyncStrategyTarget.TSP);
+			});
+		});
+	});
+
+	describe('sync', () => {
+		it('should return a promise', () => {
+			const result = strategy.sync();
+
+			expect(result).toBeInstanceOf(Promise);
+		});
+	});
+});

apps/server/src/infra/sync/tsp/tsp-sync.strategy.ts

@@ -0,0 +1,15 @@
+import { Injectable } from '@nestjs/common';
+import { SyncStrategy } from '../strategy/sync-strategy';
+import { SyncStrategyTarget } from '../sync-strategy.types';
+
+@Injectable()
+export class TspSyncStrategy extends SyncStrategy {
+	getType(): SyncStrategyTarget {
+		return SyncStrategyTarget.TSP;
+	}
+
+	sync(): Promise<void> {
+		// implementation
+		return Promise.resolve();
+	}
+}

apps/server/src/infra/sync/uc/sync.uc.spec.ts

@@ -0,0 +1,47 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { createMock } from '@golevelup/ts-jest';
+import { SyncUc } from './sync.uc';
+import { SyncService } from '../service/sync.service';
+
+describe(SyncUc.name, () => {
+	let module: TestingModule;
+	let uc: SyncUc;
+	let service: SyncService;
+
+	beforeAll(async () => {
+		module = await Test.createTestingModule({
+			providers: [
+				SyncUc,
+				{
+					provide: SyncService,
+					useValue: createMock<SyncService>({}),
+				},
+			],
+		}).compile();
+		uc = module.get(SyncUc);
+		service = module.get(SyncService);
+	});
+
+	describe('when sync uc is initialized', () => {
+		it('should be defined', () => {
+			expect(uc).toBeDefined();
+		});
+	});
+
+	describe('startSync', () => {
+		describe('when calling startSync', () => {
+			const setup = () => {
+				const validTarget = 'tsp';
+
+				return { validTarget };
+			};
+
+			it('should call sync method', async () => {
+				const { validTarget } = setup();
+				await uc.startSync(validTarget);
+
+				expect(service.startSync).toHaveBeenCalledWith(validTarget);
+			});
+		});
+	});
+});