feat(DTFS2-6892): update tfm ui to save token

libs/common/src/schemas/tfm/handle-sso-redirect-form-request.schema.test.ts

@@ -0,0 +1,37 @@
+import { aValidTfmSessionUser, withSchemaValidationTests } from '../../test-helpers/schemas';
+import { HANDLE_SSO_REDIRECT_FORM_RESPONSE_SCHEMA } from './handle-sso-redirect-form-response.schema';
+
+describe('HANDLE_SSO_REDIRECT_FORM_RESPONSE_SCHEMA', () => {
+  withSchemaValidationTests({
+    schema: HANDLE_SSO_REDIRECT_FORM_RESPONSE_SCHEMA,
+    aValidPayload,
+    testCases: [
+      {
+        parameterPath: 'user',
+        type: 'TFM_SESSION_USER_SCHEMA',
+        options: {
+          overrideGetTestObjectWithUpdatedField: (newValue: unknown) => ({ ...aValidPayload(), user: newValue }),
+        },
+      },
+      {
+        parameterPath: 'token',
+        type: 'string',
+      },
+      {
+        parameterPath: 'expires',
+        type: 'string',
+      },
+      {
+        parameterPath: 'successRedirect',
+        type: 'string',
+        options: {
+          isOptional: true,
+        },
+      },
+    ],
+  });
+
+  function aValidPayload() {
+    return { user: aValidTfmSessionUser(), token: 'a-token', expires: 'a-date', successRedirect: 'a-redirect' };
+  }
+});

libs/common/src/schemas/tfm/handle-sso-redirect-form-response.schema.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { TFM_SESSION_USER_SCHEMA } from './tfm-session-user.schema';
+
+export const HANDLE_SSO_REDIRECT_FORM_RESPONSE_SCHEMA = z.object({
+  user: TFM_SESSION_USER_SCHEMA,
+  token: z.string(),
+  expires: z.string(),
+  successRedirect: z.string().optional(),
+});

libs/common/src/schemas/tfm/index.ts

@@ -7,3 +7,4 @@ export * from './upsert-tfm-user-request.schema';
 export * from './tfm-team.schema';
 export * from './tfm-user.schema';
 export * from './tfm-session-user.schema';
+export * from './handle-sso-redirect-form-response.schema';

libs/common/src/schemas/tfm/tfm-session-user.schema.test.ts

@@ -0,0 +1,10 @@
+import { withTfmSessionUserSchemaTests } from '../../test-helpers/schemas';
+import { TFM_SESSION_USER_SCHEMA } from './tfm-session-user.schema';
+
+describe('TFM_SESSION_USER_SCHEMA', () => {
+  withTfmSessionUserSchemaTests({
+    schema: TFM_SESSION_USER_SCHEMA,
+    getTestObjectWithUpdatedParameter: (newValue: unknown) => newValue,
+    getUpdatedParameterFromParsedTestObject: (data) => data,
+  });
+});

libs/common/src/test-helpers/mock-builders/mock-builder.mock.builder.ts

@@ -6,13 +6,16 @@ type Mocked<T> = {
 };
 
 /**
- * Base class for class test data builders. Pass in default values for the class
- * instance so that you can build an instance with those values and override
- * them as needed.
+ * Base class for class test data and class builders.
+ *
+ * Pass in default values for the instance so that you can build an instance with
+ * those values and override them as needed.
  *
  * @example
+ * Overriding the defaults of a type:
  * ```ts
- * // Basic builder
+ * // user.mock.builder.ts
+ * // Basic builder for a type
  * export class UserMockBuilder extends BaseMockBuilder<User> {
  *   constructor() {
  *     super({
@@ -24,52 +27,61 @@ type Mocked<T> = {
  *     })
  *   }
  * }
+ * 
+ * // a-test-file.test.ts
+ * // Usage in a test where we just need a valid class instance
+ * const user = new UserMockBuilder().build()
+ * 
+ * // another-test-file.test.ts
+ * // Usage in a test where a field needs to have a specific value
+ * const user = new UserMockBuilder()
+ *   .with({ email: 'new.email@ukef.gov.uk' })
+ *   .build()
  * ```
+
  *
  * @example
+ * Overriding the defaults of a class:
  * ```ts
- * // With custom static factory methods to initialise the builder
- * export class UserMockBuilder extends BaseMockBuilder<User> {
- *   constructor(defaultInstance?: User) {
+ * export class LoginServiceMockBuilder extends BaseMockBuilder<LoginService> {
+ *   constructor() {
  *     super({
- *       defaultInstance: defaultInstance ?? {
- *         id: '72f9ca55-943a-401d-a04c-0a9e03ac7f18',
- *         name: 'Joe Bloggs',
- *         email: 'joe.bloggs@ukef.gov.uk',
+ *       defaultInstance: {
+ *         getAuthCodeUrl: jest.fn(async () => {
+ *           return Promise.resolve({
+ *             authCodeUrl: 'a-auth-code-url',
+ *             authCodeUrlRequest: {} as AuthorizationCodeRequest,
+ *           });
+ *         }),
  *       },
- *     })
- *   }
- *
- *   public static fromEntity(entity: UserEntity): UserMockBuilder {
- *     return new UserMockBuilder({
- *       id: entity.id,
- *       name: entity.name,
- *       email: entity.email,
- *     })
+ *     });
  *   }
  * }
  * ```
- *
- * @example
- * ```ts
- * // Usage in a test where we just need a valid class instance
- * const user = new UserMockBuilder().build()
- * ```
- *
- * @example
+ * 
+ * Keeping existing implimentations of a class:
  * ```ts
- * // Usage in a test where a field needs to have a specific value
- * const user = new UserMockBuilder()
- *   .with({ email: 'new.email@ukef.gov.uk' })
- *   .build()
+ * export class UserServiceMockBuilder extends BaseMockBuilder<UserService> {
+ *  constructor() {
+ *    const userService = new UserService(); // This can be used as a way to inherit methods we do not wish to mock the implimentation for
+ *    super({
+ *      defaultInstance: {
+ *        transformEntraIdUserToUpsertTfmUserRequest(entraIdUser: EntraIdUser): UpsertTfmUserRequest {
+ *          return userService.transformEntraIdUserToUpsertTfmUserRequest(entraIdUser);
+ *        },
+ *        saveUserLoginInformation({ userId, sessionIdentifier, auditDetails }: saveUserLoginInformationParams): Promise<void> {
+ *          return Promise.resolve();
+ *        },
+ *      },
+ *    });
+ *  }
  * ```
  */
 export abstract class BaseMockBuilder<TClass extends object> {
-  private readonly defaults: Partial<Mocked<TClass>>;
   private readonly instance: Mocked<TClass> = {} as Mocked<TClass>;
 
-  protected constructor(config: { defaultInstance: Partial<Mocked<TClass>> }) {
-    this.defaults = config.defaultInstance;
+  protected constructor(config: { defaultInstance: Mocked<TClass> }) {
+    this.with(config.defaultInstance);
   }
 
   /**
@@ -90,10 +102,6 @@ export abstract class BaseMockBuilder<TClass extends object> {
     return this;
   }
 
-  public withDefaults(): BaseMockBuilder<TClass> {
-    return this.with(this.defaults);
-  }
-
   /**
    * Build the class instance after setting any fields
    */

libs/common/src/test-helpers/mock-data/get-auth-code-url-response.mock.ts

@@ -0,0 +1,7 @@
+import { GetAuthCodeUrlResponse } from '../../types';
+import { anAuthorisationCodeRequest } from './authorisation-code-request.mock';
+
+export const aGetAuthCodeUrlResponse = (): GetAuthCodeUrlResponse => ({
+  authCodeUrl: 'a-auth-code-url',
+  authCodeUrlRequest: anAuthorisationCodeRequest(),
+});

libs/common/src/test-helpers/mock-data/index.ts

@@ -15,9 +15,9 @@ export * from './upsert-tfm-user-request';
 export * from './record-correction-mock';
 export * from './entra-id-auth-code-redirect-response-body';
 export * from './fee-record-correction-request-transient-form-data.entity.mock-builder';
-export * from './get-auth-code-url-response';
 export * from './get-auth-code-url-params';
 export * from './fee-record-correction-transient-form-data.entity.mock-builder';
+export * from './get-auth-code-url-response.mock';
 export * from './fee-record-correction-request-review-response-body-mock';
 export * from './record-correction-values';
 export * from './record-correction-log-details.mock';

libs/common/src/test-helpers/schemas/schema-tests/index.ts

@@ -3,5 +3,6 @@
  * ie these schemas represent a whole object, not a single field
  */
 export * from './with-entra-id-user-schema.tests';
+export * from './with-tfm-session-user-schema.tests';
 export * from './with-upsert-tfm-user-request.schema.tests';
 export * from './with-audit-database-record-schema.tests';

libs/common/src/test-helpers/schemas/schema-tests/with-tfm-session-user-schema.tests.ts

@@ -0,0 +1,114 @@
+import { ZodSchema } from 'zod';
+import { ObjectId } from 'mongodb';
+import { TEAM_IDS } from '../../../constants';
+import { withSchemaValidationTests } from '../with-schema-validation.tests';
+import { withDefaultOptionsTests } from '../primitive-types-tests';
+import { WithSchemaTestParams } from '../types/with-schema-test.type';
+
+export const withTfmSessionUserSchemaTests = <Schema extends ZodSchema>({
+  schema,
+  options = {},
+  getTestObjectWithUpdatedParameter,
+  getUpdatedParameterFromParsedTestObject,
+}: WithSchemaTestParams<Schema>) => {
+  describe('with TFM_SESSION_USER_SCHEMA tests', () => {
+    withDefaultOptionsTests({
+      schema,
+      options,
+      getTestObjectWithUpdatedParameter,
+      getUpdatedParameterFromParsedTestObject,
+    });
+
+    withSchemaValidationTests({
+      schema,
+      aValidPayload,
+      testCases: [
+        {
+          parameterPath: '_id',
+          type: 'OBJECT_ID_STRING_SCHEMA',
+          options: {
+            overrideGetTestObjectWithUpdatedField: (newValue) => getTestObjectWithUpdatedParameter({ ...aValidPayload(), _id: newValue }),
+          },
+        },
+        {
+          parameterPath: 'username',
+          type: 'string',
+          options: {
+            overrideGetTestObjectWithUpdatedField: (newValue) => getTestObjectWithUpdatedParameter({ ...aValidPayload(), username: newValue }),
+          },
+        },
+        {
+          parameterPath: 'email',
+          type: 'string',
+          options: {
+            overrideGetTestObjectWithUpdatedField: (newValue) => getTestObjectWithUpdatedParameter({ ...aValidPayload(), email: newValue }),
+          },
+        },
+        {
+          parameterPath: 'timezone',
+          type: 'string',
+          options: {
+            overrideGetTestObjectWithUpdatedField: (newValue) => getTestObjectWithUpdatedParameter({ ...aValidPayload(), timezone: newValue }),
+          },
+        },
+        {
+          parameterPath: 'firstName',
+          type: 'string',
+          options: {
+            overrideGetTestObjectWithUpdatedField: (newValue) => getTestObjectWithUpdatedParameter({ ...aValidPayload(), firstName: newValue }),
+          },
+        },
+        {
+          parameterPath: 'lastName',
+          type: 'string',
+          options: {
+            overrideGetTestObjectWithUpdatedField: (newValue) => getTestObjectWithUpdatedParameter({ ...aValidPayload(), lastName: newValue }),
+          },
+        },
+        {
+          parameterPath: 'status',
+          type: 'string',
+          options: {
+            overrideGetTestObjectWithUpdatedField: (newValue) => getTestObjectWithUpdatedParameter({ ...aValidPayload(), status: newValue }),
+          },
+        },
+        {
+          parameterPath: 'lastLogin',
+          type: 'UNIX_TIMESTAMP_MILLISECONDS_SCHEMA',
+          options: {
+            isOptional: true,
+            overrideGetTestObjectWithUpdatedField: (newValue) => getTestObjectWithUpdatedParameter({ ...aValidPayload(), lastLogin: newValue }),
+          },
+        },
+        {
+          parameterPath: 'teams',
+          type: 'Array',
+          options: {
+            arrayTypeTestCase: {
+              type: 'TfmTeamSchema',
+            },
+            overrideGetTestObjectWithUpdatedField: (newValue) => getTestObjectWithUpdatedParameter({ ...aValidPayload(), teams: newValue }),
+          },
+        },
+      ],
+    });
+
+    function aValidPayload() {
+      return aValidTfmSessionUser();
+    }
+  });
+};
+
+export function aValidTfmSessionUser() {
+  return {
+    _id: new ObjectId().toString(),
+    username: 'test-user',
+    email: 'test-user@ukexportfinance.gov.uk',
+    teams: [TEAM_IDS.PIM],
+    timezone: 'Europe/London',
+    firstName: 'FirstName',
+    lastName: 'LastName',
+    status: 'active',
+    lastLogin: 1234567890123,
+  };
+}

libs/common/src/test-helpers/schemas/test-cases/test-case.ts

@@ -18,4 +18,5 @@ export type TestCase =
   | TestCaseWithType<'OBJECT_ID_SCHEMA'>
   | TestCaseWithType<'OBJECT_ID_STRING_SCHEMA'>
   | TestCaseWithType<'OBJECT_ID_OR_OBJECT_ID_STRING_SCHEMA'>
-  | TestCaseWithType<'AUDIT_DATABASE_RECORD_SCHEMA'>;
+  | TestCaseWithType<'AUDIT_DATABASE_RECORD_SCHEMA'>
+  | TestCaseWithType<'TFM_SESSION_USER_SCHEMA'>;

libs/common/src/test-helpers/schemas/tests/with-tests-for-testcase.ts

@@ -11,7 +11,12 @@ import {
   withObjectIdOrObjectIdStringSchemaTests,
 } from '../custom-types-tests';
 import { withStringTests, withNumberTests, withBooleanTests, withArrayTests } from '../primitive-types-tests';
-import { withAuditDatabaseRecordSchemaTests, withEntraIdUserSchemaTests, withUpsertTfmUserRequestSchemaTests } from '../schema-tests';
+import {
+  withAuditDatabaseRecordSchemaTests,
+  withEntraIdUserSchemaTests,
+  withTfmSessionUserSchemaTests,
+  withUpsertTfmUserRequestSchemaTests,
+} from '../schema-tests';
 import { withIsoDateTimeStampToDateSchemaTests } from '../transformation-tests';
 import { WithTestsForTestCaseProps } from '../types/with-tests-for-test-case';
 
@@ -177,6 +182,15 @@ export const withTestsForTestcase = <Schema extends ZodSchema>(props: WithTestsF
       });
       break;
 
+    case 'TFM_SESSION_USER_SCHEMA':
+      withTfmSessionUserSchemaTests({
+        schema,
+        options,
+        getTestObjectWithUpdatedParameter,
+        getUpdatedParameterFromParsedTestObject,
+      });
+      break;
+
     default:
       throw Error(`There are no existing test cases for the type ${type}`);
   }

libs/common/src/types/tfm/handle-sso-redirect-form.ts

@@ -1,23 +1,19 @@
 import { AuthorizationUrlRequest } from '@azure/msal-node';
 import { Response } from 'express';
+import z from 'zod';
 import { EntraIdAuthCodeRedirectResponseBody } from './entra-id';
-import { TfmSessionUser } from './tfm-session-user';
 import { AuditDetails } from '../audit-details';
 import { CustomExpressRequest } from '../express-custom-request';
 import { ApiErrorResponseBody } from '../api-error-response-body';
+import { HANDLE_SSO_REDIRECT_FORM_RESPONSE_SCHEMA } from '../../schemas/tfm/handle-sso-redirect-form-response.schema';
 
 export type HandleSsoRedirectFormRequest = {
   authCodeResponse: EntraIdAuthCodeRedirectResponseBody;
   originalAuthCodeUrlRequest: AuthorizationUrlRequest;
   auditDetails: AuditDetails<'system'>;
 };
 
-export type HandleSsoRedirectFormResponse = {
-  user: TfmSessionUser;
-  token: string;
-  expires: string;
-  successRedirect?: string;
-};
+export type HandleSsoRedirectFormResponse = z.infer<typeof HANDLE_SSO_REDIRECT_FORM_RESPONSE_SCHEMA>;
 
 export type HandleSsoRedirectFormUiRequest = CustomExpressRequest<{ reqBody: EntraIdAuthCodeRedirectResponseBody }>;