EW-1083: TSP Refactoring

apps/server/src/infra/sync/console/README.md

@@ -1,19 +1,23 @@
 # Sync console
+
 This is a console application that allows you to start the synchronization process for different sources.
 
 ## Usage
+
 To start the synchronization process, run the following command:
+
 ```bash
 npm run nest:start:console sync run <target>
 ```
 
 Where `<target>` is the name of the system you want to start the synchronization for. The currently available systems are:
+
 - `tsp` - Synchronize Thüringer schulportal.
 - `vidis` - Synchronize Vidis Activation Data.
 - `media_metadata` - Synchronize media metadata in ctl tools in SVS with data from its media source.
 
-
 If the target is not provided, the synchronization will not start and the available targets will be displayed in an error message.
+
 ```bash
 {
     message: 'Either synchronization is not activated or the target entered is invalid',  
@@ -22,4 +26,5 @@ If the target is not provided, the synchronization will not start and the availa
 ```
 
 ## TSP synchronization
-The TSP synchronization is controlled with a feature flag  `FEATURE_TSP_SYNC_ENABLED`. This is now set to `false`.
+
+The TSP synchronization is controlled with a feature flag  `FEATURE_TSP_SYNC_ENABLED`. This is now set to `false`.

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

@@ -1,3 +1,3 @@
-export * from './tsp';
 export * from './media-licenses';
+export { TspSyncConfig, TspSyncStrategy } from './strategy/tsp';
 export * from './media-metadata';

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

@@ -1,13 +1,13 @@
-import { Test, TestingModule } from '@nestjs/testing';
-import { createMock } from '@golevelup/ts-jest';
-import { faker } from '@faker-js/faker';
 import { Logger } from '@core/logger';
+import { faker } from '@faker-js/faker';
+import { createMock } from '@golevelup/ts-jest';
+import { Test, TestingModule } from '@nestjs/testing';
 import { InvalidTargetLoggable } from '../errors/invalid-target.loggable';
+import { VidisSyncStrategy } from '../media-licenses';
+import { MediaMetadataSyncStrategy } from '../media-metadata';
 import { SyncStrategy } from '../strategy/sync-strategy';
+import { TspSyncStrategy } from '../strategy/tsp/tsp-sync.strategy';
 import { SyncStrategyTarget } from '../sync-strategy.types';
-import { TspSyncStrategy } from '../tsp';
-import { MediaMetadataSyncStrategy } from '../media-metadata';
-import { VidisSyncStrategy } from '../media-licenses';
 import { SyncService } from './sync.service';
 
 describe(SyncService.name, () => {

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

@@ -1,10 +1,10 @@
-import { Injectable, Optional } from '@nestjs/common';
 import { Logger } from '@core/logger';
-import { TspSyncStrategy } from '../tsp/tsp-sync.strategy';
-import { SyncStrategy } from '../strategy/sync-strategy';
-import { SyncStrategyTarget } from '../sync-strategy.types';
+import { Injectable, Optional } from '@nestjs/common';
 import { InvalidTargetLoggable } from '../errors/invalid-target.loggable';
 import { VidisSyncStrategy } from '../media-licenses/strategy';
+import { SyncStrategy } from '../strategy/sync-strategy';
+import { TspSyncStrategy } from '../strategy/tsp/tsp-sync.strategy';
+import { SyncStrategyTarget } from '../sync-strategy.types';
 import { MediaMetadataSyncStrategy } from '../media-metadata/strategy';
 
 @Injectable()

apps/server/src/infra/sync/strategy/tsp/loggable/index.ts

@@ -0,0 +1,12 @@
+export { TspDataFetchedLoggable } from './tsp-data-fetched.loggable';
+export { TspLegacyMigrationStartLoggable } from './tsp-legacy-migration-start.loggable';
+export { TspLegacySchoolMigrationCountLoggable } from './tsp-legacy-school-migration-count.loggable';
+export { TspLegacySchoolMigrationSuccessLoggable } from './tsp-legacy-school-migration-success.loggable';
+export { TspMissingExternalIdLoggable } from './tsp-missing-external-id.loggable';
+export { TspSchoolsFetchedLoggable } from './tsp-schools-fetched.loggable';
+export { TspSchoolsSyncedLoggable } from './tsp-schools-synced.loggable';
+export { TspSchulnummerMissingLoggable } from './tsp-schulnummer-missing.loggable';
+export { TspSyncedUsersLoggable } from './tsp-synced-users.loggable';
+export { TspSyncingUsersLoggable } from './tsp-syncing-users.loggable';
+export { TspSystemNotFoundLoggableException } from './tsp-system-not-found.loggable-exception';
+export { TspUsersMigratedLoggable } from './tsp-users-migrated.loggable';

apps/server/src/infra/sync/strategy/tsp/loggable/tsp-access-token.loggable-error.spec.ts

@@ -0,0 +1,23 @@
+import { TspAccessTokenLoggableError } from './tsp-access-token.loggable-error';
+
+describe(TspAccessTokenLoggableError.name, () => {
+	describe('getLogMessage is called', () => {
+		const setup = () => {
+			const expected = {
+				type: 'TSP_ACCESS_TOKEN_ERROR',
+				message: 'The TSP access token could not be generated during the sync',
+				stack: expect.any(String),
+			};
+
+			return { expected };
+		};
+
+		it('should return a log message', () => {
+			const { expected } = setup();
+
+			const loggable = new TspAccessTokenLoggableError();
+
+			expect(loggable.getLogMessage()).toEqual(expected);
+		});
+	});
+});

apps/server/src/infra/sync/strategy/tsp/loggable/tsp-access-token.loggable-error.ts

@@ -0,0 +1,26 @@
+import { Loggable, LogMessage } from '@core/logger';
+import { HttpStatus } from '@nestjs/common';
+import { BusinessError, ErrorLogMessage } from '@shared/common/error';
+
+export class TspAccessTokenLoggableError extends BusinessError implements Loggable {
+	constructor() {
+		super(
+			{
+				type: 'TSP_ACCESS_TOKEN_ERROR',
+				title: 'The TSP access token could not be generated',
+				defaultMessage: 'The TSP access token could not be generated during the sync',
+			},
+			HttpStatus.BAD_REQUEST
+		);
+	}
+
+	public getLogMessage(): LogMessage | ErrorLogMessage {
+		const message: LogMessage | ErrorLogMessage = {
+			message: this.message,
+			type: this.type,
+			stack: this.stack,
+		};
+
+		return message;
+	}
+}

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

@@ -1,5 +1,5 @@
+import { DomainErrorHandler } from '@core/error';
 import { AxiosErrorLoggable, ErrorLoggable } from '@core/error/loggable';
-import { Logger } from '@core/logger';
 import { faker } from '@faker-js/faker';
 import { createMock, DeepMocked } from '@golevelup/ts-jest';
 import {
@@ -12,6 +12,14 @@ import {
 	RobjExportSchule,
 	TspClientFactory,
 } from '@infra/tsp-client';
+import {
+	robjExportKlasseFactory,
+	robjExportLehrerFactory,
+	robjExportLehrerMigrationFactory,
+	robjExportSchuelerFactory,
+	robjExportSchuelerMigrationFactory,
+	robjExportSchuleFactory,
+} from '@infra/tsp-client/testing';
 import { OauthConfigMissingLoggableException } from '@modules/oauth/loggable';
 import { systemFactory } from '@modules/system/testing';
 import { Test, TestingModule } from '@nestjs/testing';
@@ -22,7 +30,7 @@ describe(TspFetchService.name, () => {
 	let module: TestingModule;
 	let sut: TspFetchService;
 	let tspClientFactory: DeepMocked<TspClientFactory>;
-	let logger: DeepMocked<Logger>;
+	let domainErrorHandler: DeepMocked<DomainErrorHandler>;
 
 	beforeAll(async () => {
 		module = await Test.createTestingModule({
@@ -33,19 +41,18 @@ describe(TspFetchService.name, () => {
 					useValue: createMock<TspClientFactory>(),
 				},
 				{
-					provide: Logger,
-					useValue: createMock<Logger>(),
+					provide: DomainErrorHandler,
+					useValue: createMock<DomainErrorHandler>(),
 				},
 			],
 		}).compile();
 
 		sut = module.get(TspFetchService);
 		tspClientFactory = module.get(TspClientFactory);
-		logger = module.get(Logger);
+		domainErrorHandler = module.get(DomainErrorHandler);
 	});
 
 	afterEach(() => {
-		jest.clearAllMocks();
 		jest.resetAllMocks();
 	});
 
@@ -60,8 +67,8 @@ describe(TspFetchService.name, () => {
 	});
 
 	const setupTspClient = () => {
-		const clientId = faker.string.alpha();
-		const clientSecret = faker.string.alpha();
+		const clientId = faker.string.uuid();
+		const clientSecret = faker.string.alphanumeric(40);
 		const tokenEndpoint = faker.internet.url();
 		const system = systemFactory.build({
 			oauthConfig: {
@@ -71,61 +78,37 @@ describe(TspFetchService.name, () => {
 			},
 		});
 
-		const tspSchool: RobjExportSchule = {
-			schuleName: faker.string.alpha(),
-			schuleNummer: faker.string.alpha(),
-		};
+		const tspSchool = robjExportSchuleFactory.build();
 		const schools = [tspSchool];
 		const responseSchools = createMock<AxiosResponse<Array<RobjExportSchule>>>({
 			data: schools,
 		});
 
-		const tspTeacher: RobjExportLehrer = {
-			schuleNummer: faker.string.alpha(),
-			lehrerVorname: faker.string.alpha(),
-			lehrerNachname: faker.string.alpha(),
-			lehrerUid: faker.string.alpha(),
-		};
+		const tspTeacher = robjExportLehrerFactory.build();
 		const teachers = [tspTeacher];
 		const responseTeachers = createMock<AxiosResponse<Array<RobjExportLehrer>>>({
 			data: teachers,
 		});
 
-		const tspStudent: RobjExportSchueler = {
-			schuleNummer: faker.string.alpha(),
-			schuelerVorname: faker.string.alpha(),
-			schuelerNachname: faker.string.alpha(),
-			schuelerUid: faker.string.alpha(),
-		};
+		const tspStudent = robjExportSchuelerFactory.build();
 		const students = [tspStudent];
 		const responseStudents = createMock<AxiosResponse<Array<RobjExportSchueler>>>({
 			data: students,
 		});
 
-		const tspClass: RobjExportKlasse = {
-			schuleNummer: faker.string.alpha(),
-			klasseId: faker.string.alpha(),
-			klasseName: faker.string.alpha(),
-			lehrerUid: faker.string.alpha(),
-		};
+		const tspClass = robjExportKlasseFactory.build();
 		const classes = [tspClass];
 		const responseClasses = createMock<AxiosResponse<Array<RobjExportKlasse>>>({
 			data: classes,
 		});
 
-		const tspTeacherMigration: RobjExportLehrerMigration = {
-			lehrerUidAlt: faker.string.alpha(),
-			lehrerUidNeu: faker.string.alpha(),
-		};
+		const tspTeacherMigration = robjExportLehrerMigrationFactory.build();
 		const teacherMigrations = [tspTeacherMigration];
 		const responseTeacherMigrations = createMock<AxiosResponse<Array<RobjExportLehrerMigration>>>({
 			data: teacherMigrations,
 		});
 
-		const tspStudentMigration: RobjExportSchuelerMigration = {
-			schuelerUidAlt: faker.string.alpha(),
-			schuelerUidNeu: faker.string.alpha(),
-		};
+		const tspStudentMigration = robjExportSchuelerMigrationFactory.build();
 		const studentMigrations = [tspStudentMigration];
 		const responseStudentMigrations = createMock<AxiosResponse<Array<RobjExportSchuelerMigration>>>({
 			data: studentMigrations,
@@ -359,8 +342,8 @@ describe(TspFetchService.name, () => {
 			const setup = () => {
 				const system = systemFactory.build({
 					oauthConfig: {
-						clientId: faker.string.alpha(),
-						clientSecret: faker.string.alpha(),
+						clientId: faker.string.uuid(),
+						clientSecret: faker.string.alphanumeric(40),
 						tokenEndpoint: faker.internet.url(),
 					},
 				});
@@ -383,16 +366,18 @@ describe(TspFetchService.name, () => {
 
 				await sut.fetchTspSchools(system, 1);
 
-				expect(logger.warning).toHaveBeenCalledWith(new AxiosErrorLoggable(new AxiosError(), 'TSP_FETCH_ERROR'));
+				expect(domainErrorHandler.exec).toHaveBeenCalledWith(
+					new AxiosErrorLoggable(new AxiosError(), 'TSP_FETCH_ERROR')
+				);
 			});
 		});
 
 		describe('when generic Error is thrown', () => {
 			const setup = () => {
 				const system = systemFactory.build({
 					oauthConfig: {
-						clientId: faker.string.alpha(),
-						clientSecret: faker.string.alpha(),
+						clientId: faker.string.uuid(),
+						clientSecret: faker.string.alphanumeric(40),
 						tokenEndpoint: faker.internet.url(),
 					},
 				});
@@ -415,7 +400,7 @@ describe(TspFetchService.name, () => {
 
 				await sut.fetchTspSchools(system, 1);
 
-				expect(logger.warning).toHaveBeenCalledWith(new ErrorLoggable(new Error()));
+				expect(domainErrorHandler.exec).toHaveBeenCalledWith(new ErrorLoggable(new Error()));
 			});
 		});
 	});
@@ -428,10 +413,15 @@ describe(TspFetchService.name, () => {
 				return { system };
 			};
 
-			it('should throw an OauthConfigMissingLoggableException', async () => {
+			it('should throw an OauthConfigMissingLoggableException into domainErrorHandler', async () => {
 				const { system } = setup();
 
-				await expect(async () => sut.fetchTspSchools(system, 1)).rejects.toThrow(OauthConfigMissingLoggableException);
+				const result = await sut.fetchTspSchools(system, 1);
+				expect(result).toStrictEqual([]);
+
+				expect(domainErrorHandler.exec).toHaveBeenCalledWith(
+					new ErrorLoggable(new OauthConfigMissingLoggableException(system.id))
+				);
 			});
 		});
 	});

apps/server/src/infra/sync/tsp/tsp-fetch.service.ts → apps/server/src/infra/sync/strategy/tsp/tsp-fetch.service.ts

@@ -1,5 +1,5 @@
+import { DomainErrorHandler } from '@core/error';
 import { AxiosErrorLoggable, ErrorLoggable } from '@core/error/loggable';
-import { Logger } from '@core/logger';
 import {
 	ExportApiInterface,
 	RobjExportKlasse,
@@ -18,9 +18,10 @@ import moment from 'moment';
 
 @Injectable()
 export class TspFetchService {
-	constructor(private readonly tspClientFactory: TspClientFactory, private readonly logger: Logger) {
-		this.logger.setContext(TspFetchService.name);
-	}
+	constructor(
+		private readonly tspClientFactory: TspClientFactory,
+		private readonly domainErrorHandler: DomainErrorHandler
+	) {}
 
 	public fetchTspSchools(system: System, daysToFetch: number): Promise<RobjExportSchule[]> {
 		const lastChangeDate = this.formatChangeDate(daysToFetch);
@@ -64,20 +65,21 @@ export class TspFetchService {
 
 	private async fetchTsp<T>(
 		system: System,
-		fetch: (client: ExportApiInterface) => Promise<AxiosResponse<T>>,
+		fetchFunction: (client: ExportApiInterface) => Promise<AxiosResponse<T>>,
 		defaultValue: T
 	): Promise<T> {
-		const client = this.createClient(system);
 		try {
-			const response = await fetch(client);
+			const client = this.createClient(system);
+
+			const response = await fetchFunction(client);
 			const { data } = response;
 
 			return data;
 		} catch (e) {
 			if (e instanceof AxiosError) {
-				this.logger.warning(new AxiosErrorLoggable(e, 'TSP_FETCH_ERROR'));
+				this.domainErrorHandler.exec(new AxiosErrorLoggable(e, 'TSP_FETCH_ERROR'));
 			} else {
-				this.logger.warning(new ErrorLoggable(e));
+				this.domainErrorHandler.exec(new ErrorLoggable(e));
 			}
 		}
 		return defaultValue;

apps/server/src/infra/sync/tsp/tsp-legacy-migration.service.integration.spec.ts → apps/server/src/infra/sync/strategy/tsp/tsp-legacy-migration.service.integration.spec.ts

@@ -46,10 +46,10 @@ describe('account repo', () => {
 		await cleanupCollections(em);
 	});
 
-	describe('migrateLegacyData', () => {
+	describe('prepareLegacySyncDataForNewSync', () => {
 		describe('when legacy system is not found', () => {
 			it('should log TspLegacyMigrationSystemMissingLoggable', async () => {
-				await sut.migrateLegacyData('');
+				await sut.prepareLegacySyncDataForNewSync('');
 
 				expect(logger.info).toHaveBeenCalledWith(new TspLegacyMigrationSystemMissingLoggable());
 			});
@@ -94,7 +94,7 @@ describe('account repo', () => {
 			it('should update the school to the new format', async () => {
 				const { newSystem, legacySchool, schoolId: schoolIdentifier } = await setup();
 
-				await sut.migrateLegacyData(newSystem.id);
+				await sut.prepareLegacySyncDataForNewSync(newSystem.id);
 
 				const migratedSchool = await em.findOne<SchoolEntity>(SchoolEntity.name, {
 					id: legacySchool.id,