N21-2120 force migration extension

apps/server/src/modules/user-login-migration/controller/api-test/user-login-migration.api.spec.ts

@@ -27,6 +27,7 @@ import axios from 'axios';
 import MockAdapter from 'axios-mock-adapter';
 import { UUID } from 'bson';
 import { Response } from 'supertest';
+import { DeepPartial } from 'fishery';
 import { ForceMigrationParams, Oauth2MigrationParams, UserLoginMigrationResponse } from '../dto';
 
 jest.mock('jwks-rsa', () => () => {
@@ -1405,7 +1406,33 @@ describe('UserLoginMigrationController (API)', () => {
 		});
 	});
 
-	describe('[GET] /user-login-migrations/force-migration', () => {
+	describe('[POST] /user-login-migrations/force-migration', () => {
+		const expectSchoolMigrationUnchanged = (
+			school: SchoolEntity,
+			externalId: string,
+			sourceSystem: SystemEntity,
+			targetSystem: SystemEntity
+		) => {
+			const expectedSchoolPartial: DeepPartial<SchoolEntity> = {
+				externalId,
+			};
+			expect(school).toEqual(expect.objectContaining(expectedSchoolPartial));
+
+			const systems: SystemEntity[] = school?.systems.getItems();
+			systems?.forEach((system) => {
+				expect([sourceSystem.id, targetSystem.id]).toContainEqual(system.id);
+			});
+		};
+
+		const expectUserMigrated = (migratedUser: User, preMigratedUser: User, externalId: string) => {
+			const expectedUserPartial: DeepPartial<User> = {
+				externalId,
+			};
+			expect(migratedUser).toEqual(expect.objectContaining(expectedUserPartial));
+			expect(migratedUser.lastLoginSystemChange).not.toEqual(preMigratedUser.lastLoginSystemChange);
+			expect(migratedUser.previousExternalId).toEqual(preMigratedUser.externalId);
+		};
+
 		describe('when forcing a school to migrate', () => {
 			const setup = async () => {
 				const targetSystem: SystemEntity = systemEntityFactory
@@ -1464,17 +1491,309 @@ describe('UserLoginMigrationController (API)', () => {
 				expect(userLoginMigration.sourceSystem?.id).toEqual(sourceSystem.id);
 				expect(userLoginMigration.targetSystem.id).toEqual(targetSystem.id);
 
-				expect(await em.findOne(User, adminUser.id)).toEqual(
-					expect.objectContaining({
-						externalId: requestBody.externalUserId,
-					})
-				);
-
-				expect(await em.findOne(SchoolEntity, school.id)).toEqual(
+				const schoolEntity = await em.findOneOrFail(SchoolEntity, school.id);
+				expect(schoolEntity).toEqual(
 					expect.objectContaining({
 						externalId: requestBody.externalSchoolId,
 					})
 				);
+
+				const migratedUser = await em.findOneOrFail(User, adminUser.id);
+				expectUserMigrated(migratedUser, adminUser, requestBody.externalUserId);
+			});
+		});
+
+		describe('when forcing a user in a migrated school to migrate', () => {
+			describe('when the provided external school id is valid', () => {
+				const setup = async () => {
+					const targetSystem: SystemEntity = systemEntityFactory
+						.withOauthConfig()
+						.buildWithId({ alias: 'SANIS', provisioningStrategy: SystemProvisioningStrategy.SANIS });
+
+					const sourceSystem: SystemEntity = systemEntityFactory.buildWithId();
+
+					const externalSchoolId = 'externalSchoolId';
+					const school: SchoolEntity = schoolEntityFactory.buildWithId({
+						systems: [sourceSystem, targetSystem],
+						externalId: externalSchoolId,
+					});
+
+					const email = '[email protected]';
+					const { studentAccount, studentUser } = UserAndAccountTestFactory.buildStudent({
+						email,
+						school,
+					});
+					const { superheroAccount, superheroUser } = UserAndAccountTestFactory.buildSuperhero();
+
+					const userLoginMigration: UserLoginMigrationEntity = userLoginMigrationFactory.buildWithId({
+						school,
+						targetSystem,
+					});
+
+					await em.persistAndFlush([
+						sourceSystem,
+						targetSystem,
+						school,
+						superheroAccount,
+						superheroUser,
+						studentAccount,
+						studentUser,
+						userLoginMigration,
+					]);
+					em.clear();
+
+					const loggedInClient = await testApiClient.login(superheroAccount);
+
+					const requestBody: ForceMigrationParams = new ForceMigrationParams();
+					requestBody.email = email;
+					requestBody.externalUserId = 'externalUserId';
+					requestBody.externalSchoolId = externalSchoolId;
+
+					return {
+						requestBody,
+						loggedInClient,
+						sourceSystem,
+						targetSystem,
+						school,
+						studentUser,
+					};
+				};
+
+				it('should migrate the user without changing the school migration', async () => {
+					const { requestBody, loggedInClient, school, sourceSystem, targetSystem, studentUser } = await setup();
+
+					const response: Response = await loggedInClient.post(`/force-migration`, requestBody);
+
+					expect(response.status).toEqual(HttpStatus.CREATED);
+
+					const userLoginMigration = await em.findOneOrFail(UserLoginMigrationEntity, {
+						school: school.id,
+					});
+					expect(userLoginMigration.targetSystem.id).toEqual(targetSystem.id);
+
+					const migratedSchool = await em.findOneOrFail(SchoolEntity, school.id);
+					expectSchoolMigrationUnchanged(migratedSchool, requestBody.externalSchoolId, sourceSystem, targetSystem);
+
+					const migratedUser = await em.findOneOrFail(User, studentUser.id);
+					expectUserMigrated(migratedUser, studentUser, requestBody.externalUserId);
+				});
+			});
+
+			describe('when the provided external school id is invalid', () => {
+				const setup = async () => {
+					const targetSystem: SystemEntity = systemEntityFactory
+						.withOauthConfig()
+						.buildWithId({ alias: 'SANIS', provisioningStrategy: SystemProvisioningStrategy.SANIS });
+
+					const sourceSystem: SystemEntity = systemEntityFactory.buildWithId();
+
+					const externalSchoolId = 'externalSchoolId';
+					const school: SchoolEntity = schoolEntityFactory.buildWithId({
+						systems: [sourceSystem, targetSystem],
+						externalId: 'otherExternalSchoolId',
+					});
+
+					const email = '[email protected]';
+					const { studentAccount, studentUser } = UserAndAccountTestFactory.buildStudent({
+						email,
+						school,
+					});
+					const { superheroAccount, superheroUser } = UserAndAccountTestFactory.buildSuperhero();
+
+					const userLoginMigration: UserLoginMigrationEntity = userLoginMigrationFactory.buildWithId({
+						school,
+						targetSystem,
+					});
+
+					await em.persistAndFlush([
+						sourceSystem,
+						targetSystem,
+						school,
+						superheroAccount,
+						superheroUser,
+						studentAccount,
+						studentUser,
+						userLoginMigration,
+					]);
+					em.clear();
+
+					const loggedInClient = await testApiClient.login(superheroAccount);
+
+					const requestBody: ForceMigrationParams = new ForceMigrationParams();
+					requestBody.email = email;
+					requestBody.externalUserId = 'externalUserId';
+					requestBody.externalSchoolId = externalSchoolId;
+
+					return {
+						requestBody,
+						loggedInClient,
+						sourceSystem,
+						targetSystem,
+						school,
+						studentUser,
+					};
+				};
+
+				it('throw an UnprocessableEntityException', async () => {
+					const { requestBody, loggedInClient } = await setup();
+
+					const response: Response = await loggedInClient.post(`/force-migration`, requestBody);
+
+					expect(response.status).toEqual(HttpStatus.UNPROCESSABLE_ENTITY);
+				});
+			});
+		});
+
+		describe('when forcing a correction on a migrated user', () => {
+			const setup = async () => {
+				const targetSystem: SystemEntity = systemEntityFactory
+					.withOauthConfig()
+					.buildWithId({ alias: 'SANIS', provisioningStrategy: SystemProvisioningStrategy.SANIS });
+
+				const sourceSystem: SystemEntity = systemEntityFactory.buildWithId();
+
+				const externalSchoolId = 'externalSchoolId';
+				const school: SchoolEntity = schoolEntityFactory.buildWithId({
+					systems: [sourceSystem, targetSystem],
+					externalId: externalSchoolId,
+				});
+
+				const userLoginMigration: UserLoginMigrationEntity = userLoginMigrationFactory.buildWithId({
+					school,
+					targetSystem,
+					sourceSystem,
+				});
+
+				const email = '[email protected]';
+				const { teacherAccount, teacherUser } = UserAndAccountTestFactory.buildTeacher({
+					email,
+					school,
+				});
+				teacherUser.externalId = 'badExternalUserId';
+				const loginChange = new Date(userLoginMigration.startedAt);
+				loginChange.setDate(loginChange.getDate() + 1);
+				teacherUser.lastLoginSystemChange = loginChange;
+
+				const { superheroAccount, superheroUser } = UserAndAccountTestFactory.buildSuperhero();
+
+				await em.persistAndFlush([
+					sourceSystem,
+					targetSystem,
+					school,
+					superheroAccount,
+					superheroUser,
+					teacherAccount,
+					teacherUser,
+					userLoginMigration,
+				]);
+				em.clear();
+
+				const loggedInClient = await testApiClient.login(superheroAccount);
+
+				const requestBody: ForceMigrationParams = new ForceMigrationParams();
+				requestBody.email = email;
+				requestBody.externalUserId = 'correctExternalUserId';
+				requestBody.externalSchoolId = externalSchoolId;
+
+				return {
+					requestBody,
+					loggedInClient,
+					sourceSystem,
+					targetSystem,
+					school,
+					teacherUser,
+				};
+			};
+
+			it('should correct the user without changing the migration', async () => {
+				const { requestBody, loggedInClient, school, sourceSystem, targetSystem, teacherUser } = await setup();
+
+				const response: Response = await loggedInClient.post(`/force-migration`, requestBody);
+
+				expect(response.status).toEqual(HttpStatus.CREATED);
+
+				const userLoginMigration = await em.findOneOrFail(UserLoginMigrationEntity, { school: school.id });
+				expect(userLoginMigration.targetSystem.id).toEqual(targetSystem.id);
+
+				const migratedSchool = await em.findOneOrFail(SchoolEntity, school.id);
+				expectSchoolMigrationUnchanged(migratedSchool, requestBody.externalSchoolId, sourceSystem, targetSystem);
+
+				const expectedUserPartial: DeepPartial<User> = {
+					externalId: requestBody.externalUserId,
+					lastLoginSystemChange: teacherUser.lastLoginSystemChange,
+					previousExternalId: teacherUser.previousExternalId,
+				};
+				const correctedUser = await em.findOneOrFail(User, teacherUser.id);
+				expect(correctedUser).toEqual(expect.objectContaining(expectedUserPartial));
+			});
+		});
+
+		describe('when forcing a user migration after the migration is closed or finished', () => {
+			const setup = async () => {
+				const targetSystem: SystemEntity = systemEntityFactory
+					.withOauthConfig()
+					.buildWithId({ alias: 'SANIS', provisioningStrategy: SystemProvisioningStrategy.SANIS });
+
+				const sourceSystem: SystemEntity = systemEntityFactory.buildWithId();
+
+				const externalSchoolId = 'externalSchoolId';
+				const school: SchoolEntity = schoolEntityFactory.buildWithId({
+					systems: [sourceSystem, targetSystem],
+					externalId: externalSchoolId,
+				});
+
+				const now = new Date();
+				const closedAt = new Date(now);
+				closedAt.setMonth(now.getMonth() - 1);
+				const finishedAt = new Date(closedAt);
+				finishedAt.setDate(finishedAt.getDate() + 7);
+				const userLoginMigration: UserLoginMigrationEntity = userLoginMigrationFactory.buildWithId({
+					school,
+					targetSystem,
+					sourceSystem,
+					closedAt,
+					finishedAt,
+				});
+
+				const email = '[email protected]';
+				const { teacherAccount, teacherUser } = UserAndAccountTestFactory.buildTeacher({
+					email,
+					school,
+				});
+
+				const { superheroAccount, superheroUser } = UserAndAccountTestFactory.buildSuperhero();
+
+				await em.persistAndFlush([
+					sourceSystem,
+					targetSystem,
+					school,
+					superheroAccount,
+					superheroUser,
+					teacherAccount,
+					teacherUser,
+					userLoginMigration,
+				]);
+				em.clear();
+
+				const loggedInClient = await testApiClient.login(superheroAccount);
+
+				const requestBody: ForceMigrationParams = new ForceMigrationParams();
+				requestBody.email = email;
+				requestBody.externalUserId = 'externalUserId';
+				requestBody.externalSchoolId = externalSchoolId;
+
+				return {
+					requestBody,
+					loggedInClient,
+				};
+			};
+
+			it('should throw an UnprocessableEntityException', async () => {
+				const { requestBody, loggedInClient } = await setup();
+
+				const response: Response = await loggedInClient.post(`/force-migration`, requestBody);
+
+				expect(response.status).toEqual(HttpStatus.UNPROCESSABLE_ENTITY);
 			});
 		});
 

apps/server/src/modules/user-login-migration/controller/user-login-migration.controller.ts

@@ -235,10 +235,9 @@ export class UserLoginMigrationController {
 	@ApiCreatedResponse({ description: 'The user and their school were successfully migrated' })
 	@ApiUnprocessableEntityResponse({
 		description:
-			'There are multiple users with the email,' +
-			'or the user is not an administrator,' +
-			'or the school is already migrated,' +
-			'or the external user id is already assigned',
+			'There are multiple users with the email' +
+			'or the school had closed or finished the migration' +
+			'or the external school id does not match with the migrated school',
 	})
 	@ApiNotFoundResponse({ description: 'There is no user with the email' })
 	public async forceMigration(

apps/server/src/modules/user-login-migration/loggable/debug/index.ts

@@ -1,3 +1,4 @@
 export * from './school-migration-successful.loggable';
 export * from './user-migration-started.loggable';
 export * from './user-migration-successful.loggable';
+export * from './user-migration-correction-successful-loggable';