refactor(mfa): unify the controlled actor mocks behind a factory

Author: dariusz-biela

tests/unit/components/MultifactorAuthentication/machine/graphTraversal/viewMatchesMachine.test.tsx

@@ -22,7 +22,7 @@ import getWalkedPaths, {
 } from 'tests/utils/mfa/flowPaths';
 import {getSettleableLeafStates} from 'tests/utils/mfa/leafStates';
 import renderMfaUi from 'tests/utils/mfa/realUi/harness';
-import {pendingModalClose, rejectSoftPromptAcceptanceRead, rejectValidateDevice, resetMfaUiMocks, resolveSoftPromptAcceptance, resolveValidateDevice} from 'tests/utils/mfa/realUi/mocks';
+import {pendingModalClose, readHasAcceptedSoftPromptControl, resetMfaUiMocks, validateDeviceControl} from 'tests/utils/mfa/realUi/mocks';
 import {translateLocal} from 'tests/utils/TestHelper';
 import waitForBatchedUpdatesWithAct from 'tests/utils/waitForBatchedUpdatesWithAct';
 import {matchesState} from 'xstate';
@@ -122,10 +122,10 @@ function createMfaEventExecutors(executeScenario: ExecuteScenario) {
             fireEvent.press(screen.getByTestId(TEST_ID.PROMPT_CONFIRM_BUTTON));
             await waitForBatchedUpdatesWithAct();
         },
-        [VALIDATE_DEVICE_DONE_EVENT_TYPE]: (step) => settleActor(() => resolveValidateDevice(step.event.output)),
-        [VALIDATE_DEVICE_ERROR_EVENT_TYPE]: () => settleActor(rejectValidateDevice),
-        [READ_HAS_ACCEPTED_SOFT_PROMPT_DONE_EVENT_TYPE]: (step) => settleActor(() => resolveSoftPromptAcceptance(step.event.output)),
-        [READ_HAS_ACCEPTED_SOFT_PROMPT_ERROR_EVENT_TYPE]: () => settleActor(rejectSoftPromptAcceptanceRead),
+        [VALIDATE_DEVICE_DONE_EVENT_TYPE]: (step) => settleActor(() => validateDeviceControl.resolve(step.event.output)),
+        [VALIDATE_DEVICE_ERROR_EVENT_TYPE]: () => settleActor(validateDeviceControl.reject),
+        [READ_HAS_ACCEPTED_SOFT_PROMPT_DONE_EVENT_TYPE]: (step) => settleActor(() => readHasAcceptedSoftPromptControl.resolve(step.event.output)),
+        [READ_HAS_ACCEPTED_SOFT_PROMPT_ERROR_EVENT_TYPE]: () => settleActor(readHasAcceptedSoftPromptControl.reject),
     } satisfies MfaEventExecutors & MfaActorEventExecutors;
 }
 /* eslint-enable @typescript-eslint/naming-convention */

tests/utils/mfa/realUi/mocks.ts

@@ -12,12 +12,8 @@ import {fromPromise} from 'xstate';
 
 type CapturedCallback = () => void;
 type NavigationTransitionOverrides = Pick<typeof Navigation, 'runAfterTransition' | 'runAfterUpcomingTransition'>;
-type PendingValidateDevice = {
-    resolve: (result: MFAResult) => void;
-    reject: (error: Error) => void;
-};
-type PendingReadHasAcceptedSoftPrompt = {
-    resolve: (accepted: boolean) => void;
+type PendingCall<TOutput> = {
+    resolve: (output: TOutput) => void;
     reject: (error: Error) => void;
 };
 
@@ -54,68 +50,52 @@ const biometricsMock: Pick<UseBiometricsReturn, 'serverKnownCredentialIDs' | 'ar
     areLocalCredentialsKnownToServer: () => Promise.resolve(false),
 };
 
-let pendingValidateDeviceCall: PendingValidateDevice | undefined;
-let pendingSoftPromptAcceptanceCall: PendingReadHasAcceptedSoftPrompt | undefined;
-
-function takePendingValidateDeviceCall(): PendingValidateDevice {
-    const pendingCall = pendingValidateDeviceCall;
-    pendingValidateDeviceCall = undefined;
-    if (!pendingCall) {
-        throw new Error('No pending validateDevice call is available.');
-    }
-    return pendingCall;
-}
-
-function resolveValidateDevice(result: MFAResult) {
-    takePendingValidateDeviceCall().resolve(result);
-}
-
-function rejectValidateDevice() {
-    takePendingValidateDeviceCall().reject(new Error('Mock validateDevice actor rejected for this path'));
-}
-
-function takePendingSoftPromptAcceptanceCall(): PendingReadHasAcceptedSoftPrompt {
-    const pendingCall = pendingSoftPromptAcceptanceCall;
-    pendingSoftPromptAcceptanceCall = undefined;
-    if (!pendingCall) {
-        throw new Error('No pending readHasAcceptedSoftPrompt call is available.');
+/**
+ * Builds a controlled deferred mock for one invoked machine actor. Each machine invocation parks a
+ * pending promise that the test settles later through `resolve` or `reject`, at the exact path step
+ * where the machine expects the actor outcome.
+ */
+function createControlledActor<TOutput, TInput>(actorID: string) {
+    let pendingCall: PendingCall<TOutput> | undefined;
+
+    function takePendingCall(): PendingCall<TOutput> {
+        const call = pendingCall;
+        pendingCall = undefined;
+        if (!call) {
+            throw new Error(`No pending ${actorID} call is available.`);
+        }
+        return call;
     }
-    return pendingCall;
-}
 
-function resolveSoftPromptAcceptance(accepted: boolean) {
-    takePendingSoftPromptAcceptanceCall().resolve(accepted);
+    return {
+        actor: fromPromise<TOutput, TInput>(
+            () =>
+                new Promise<TOutput>((resolve, reject) => {
+                    pendingCall = {resolve, reject};
+                }),
+        ),
+        resolve: (output: TOutput) => takePendingCall().resolve(output),
+        reject: () => takePendingCall().reject(new Error(`Mock ${actorID} actor rejected for this path`)),
+        reset: () => {
+            pendingCall = undefined;
+        },
+    };
 }
 
-function rejectSoftPromptAcceptanceRead() {
-    takePendingSoftPromptAcceptanceCall().reject(new Error('Mock readHasAcceptedSoftPrompt actor rejected for this path'));
-}
+const validateDeviceControl = createControlledActor<MFAResult, ValidateDeviceInput>('validateDevice');
+const readHasAcceptedSoftPromptControl = createControlledActor<boolean, ReadHasAcceptedSoftPromptInput>('readHasAcceptedSoftPrompt');
 
 function resetMfaUiMocks() {
     pendingModalClose.clear();
-    pendingValidateDeviceCall = undefined;
-    pendingSoftPromptAcceptanceCall = undefined;
+    validateDeviceControl.reset();
+    readHasAcceptedSoftPromptControl.reset();
 }
 
-const validateDeviceMock = fromPromise<MFAResult, ValidateDeviceInput>(
-    () =>
-        new Promise<MFAResult>((resolve, reject) => {
-            pendingValidateDeviceCall = {resolve, reject};
-        }),
-);
-
-const readHasAcceptedSoftPromptMock = fromPromise<boolean, ReadHasAcceptedSoftPromptInput>(
-    () =>
-        new Promise<boolean>((resolve, reject) => {
-            pendingSoftPromptAcceptanceCall = {resolve, reject};
-        }),
-);
-
 /** Replaces the machine's side-effect actors with controlled test implementations. */
 function mfaActorsMock() {
     const actors = {
-        validateDevice: validateDeviceMock,
-        readHasAcceptedSoftPrompt: readHasAcceptedSoftPromptMock,
+        validateDevice: validateDeviceControl.actor,
+        readHasAcceptedSoftPrompt: readHasAcceptedSoftPromptControl.actor,
     } satisfies ReturnType<typeof createActors>;
 
     return {
@@ -173,16 +153,4 @@ function navigationMock() {
     };
 }
 
-export {
-    pendingModalClose,
-    resolveValidateDevice,
-    rejectValidateDevice,
-    resolveSoftPromptAcceptance,
-    rejectSoftPromptAcceptanceRead,
-    resetMfaUiMocks,
-    mfaActorsMock,
-    biometricsHookMock,
-    renderHtmlMock,
-    syncHistoryMock,
-    navigationMock,
-};
+export {pendingModalClose, validateDeviceControl, readHasAcceptedSoftPromptControl, resetMfaUiMocks, mfaActorsMock, biometricsHookMock, renderHtmlMock, syncHistoryMock, navigationMock};