test(mfa): extract the shared actor setup into a flow-actors util

Author: dariusz-biela

tests/unit/components/MultifactorAuthentication/machine/outcomeGuard.test.ts

@@ -1,37 +1,18 @@
-import mfaMachine from '@components/MultifactorAuthentication/machine/mfaMachine';
-import type {MfaEvent} from '@components/MultifactorAuthentication/machine/types';
-
 import {createLocalMFAError} from '@libs/MultifactorAuthentication/shared/MFAResult';
 
 import CONST from '@src/CONST';
 
-import createInitEvent from 'tests/utils/mfa/flowFixtures';
-import {VALIDATE_DEVICE_DONE_EVENT_TYPE} from 'tests/utils/mfa/flowPaths';
-import {createActor} from 'xstate';
+import {createActorAtState, sendValidateDeviceDone} from 'tests/utils/mfa/flowActors';
 
 const MFA_STATE = CONST.MULTIFACTOR_AUTHENTICATION.MFA_STATE;
 
 describe('MFA outcome guard', () => {
     it('routes a successful actor result to failure when the context already contains an error', () => {
-        const initEvent = createInitEvent();
         const existingError = createLocalMFAError(CONST.MULTIFACTOR_AUTHENTICATION.REASON.LOCAL_ERRORS.UNHANDLED_EXCEPTION, 'Existing flow error');
-        const validatingDeviceSnapshot = mfaMachine.resolveState({
-            value: {[MFA_STATE.OPEN]: {[MFA_STATE.PREPARING]: MFA_STATE.VALIDATING_DEVICE}},
-            context: {
-                error: existingError,
-                scenarioName: initEvent.scenarioName,
-                scenario: initEvent.scenario,
-                payload: initEvent.payload,
-                softPromptApproved: false,
-                isCancelConfirmVisible: false,
-            },
-        });
-        const actor = createActor(mfaMachine, {snapshot: validatingDeviceSnapshot});
+        const actor = createActorAtState({[MFA_STATE.OPEN]: {[MFA_STATE.PREPARING]: MFA_STATE.VALIDATING_DEVICE}}, {error: existingError});
 
         actor.start();
-        // Framework actor events are not part of the application's MfaEvent union.
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-        actor.send({type: VALIDATE_DEVICE_DONE_EVENT_TYPE, output: {success: true}} as unknown as MfaEvent);
+        sendValidateDeviceDone(actor, {success: true});
 
         const result = actor.getSnapshot();
         expect(result.matches({[MFA_STATE.OPEN]: {[MFA_STATE.OUTCOME]: MFA_STATE.FAILURE}})).toBe(true);

tests/unit/components/MultifactorAuthentication/machine/softPromptTransition.test.ts

@@ -1,17 +1,12 @@
-import mfaMachine from '@components/MultifactorAuthentication/machine/mfaMachine';
-import type {MfaContext, MfaEvent} from '@components/MultifactorAuthentication/machine/types';
-
 import {getDeviceBiometricsOnyxKey} from '@libs/actions/MultifactorAuthentication';
 
 import CONST from '@src/CONST';
 import ONYXKEYS from '@src/ONYXKEYS';
 
 import Onyx from 'react-native-onyx';
 import getOnyxValue from 'tests/utils/getOnyxValue';
-import createInitEvent from 'tests/utils/mfa/flowFixtures';
-import {VALIDATE_DEVICE_DONE_EVENT_TYPE} from 'tests/utils/mfa/flowPaths';
+import {createActorAtState, sendValidateDeviceDone} from 'tests/utils/mfa/flowActors';
 import waitForBatchedUpdates from 'tests/utils/waitForBatchedUpdates';
-import {createActor} from 'xstate';
 
 const MFA_STATE = CONST.MULTIFACTOR_AUTHENTICATION.MFA_STATE;
 const TEST_ACCOUNT_ID = 12345;
@@ -20,51 +15,17 @@ const TEST_ACCOUNT_ID = 12345;
 // a wrong target adjusts those expectations and still passes. This suite pins the soft-prompt hops by
 // hand: eligible device -> soft prompt, and approval -> success outcome plus the persisted acceptance.
 
-function createCleanContext(): MfaContext {
-    const initEvent = createInitEvent();
-    return {
-        error: undefined,
-        scenarioName: initEvent.scenarioName,
-        scenario: initEvent.scenario,
-        payload: initEvent.payload,
-        softPromptApproved: false,
-        isCancelConfirmVisible: false,
-    };
-}
-
-function createAwaitingSoftPromptActor() {
-    const awaitingSoftPromptSnapshot = mfaMachine.resolveState({
-        value: {[MFA_STATE.OPEN]: {[MFA_STATE.PROMPT]: MFA_STATE.AWAITING_SOFT_PROMPT}},
-        context: createCleanContext(),
-    });
-    return createActor(mfaMachine, {snapshot: awaitingSoftPromptSnapshot});
-}
-
-function createValidatingDeviceActor() {
-    const validatingDeviceSnapshot = mfaMachine.resolveState({
-        value: {[MFA_STATE.OPEN]: {[MFA_STATE.PREPARING]: MFA_STATE.VALIDATING_DEVICE}},
-        context: createCleanContext(),
-    });
-    return createActor(mfaMachine, {snapshot: validatingDeviceSnapshot});
-}
-
-function settleEligibleDevice(actor: ReturnType<typeof createValidatingDeviceActor>) {
-    // Framework actor events are not part of the application's MfaEvent union.
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    actor.send({type: VALIDATE_DEVICE_DONE_EVENT_TYPE, output: {success: true}} as unknown as MfaEvent);
-}
-
 describe('MFA soft prompt', () => {
     afterEach(async () => {
         await Onyx.clear();
         await waitForBatchedUpdates();
     });
 
     it('moves an eligible device to the soft prompt without approving it', () => {
-        const actor = createValidatingDeviceActor();
+        const actor = createActorAtState({[MFA_STATE.OPEN]: {[MFA_STATE.PREPARING]: MFA_STATE.VALIDATING_DEVICE}});
 
         actor.start();
-        settleEligibleDevice(actor);
+        sendValidateDeviceDone(actor, {success: true});
 
         const result = actor.getSnapshot();
         expect(result.matches({[MFA_STATE.OPEN]: {[MFA_STATE.PROMPT]: MFA_STATE.AWAITING_SOFT_PROMPT}})).toBe(true);
@@ -79,10 +40,10 @@ describe('MFA soft prompt', () => {
         await Onyx.merge(ONYXKEYS.SESSION, {accountID: TEST_ACCOUNT_ID});
         await Onyx.merge(getDeviceBiometricsOnyxKey(TEST_ACCOUNT_ID), {hasAcceptedSoftPrompt: true});
         await waitForBatchedUpdates();
-        const actor = createValidatingDeviceActor();
+        const actor = createActorAtState({[MFA_STATE.OPEN]: {[MFA_STATE.PREPARING]: MFA_STATE.VALIDATING_DEVICE}});
 
         actor.start();
-        settleEligibleDevice(actor);
+        sendValidateDeviceDone(actor, {success: true});
 
         const result = actor.getSnapshot();
         expect(result.matches({[MFA_STATE.OPEN]: {[MFA_STATE.OUTCOME]: MFA_STATE.SUCCESS}})).toBe(true);
@@ -93,7 +54,7 @@ describe('MFA soft prompt', () => {
     });
 
     it('reaches the success outcome when the user approves the soft prompt', () => {
-        const actor = createAwaitingSoftPromptActor();
+        const actor = createActorAtState({[MFA_STATE.OPEN]: {[MFA_STATE.PROMPT]: MFA_STATE.AWAITING_SOFT_PROMPT}});
 
         actor.start();
         actor.send({type: 'SOFT_PROMPT_APPROVED'});
@@ -110,7 +71,7 @@ describe('MFA soft prompt', () => {
         // the session must settle before the event fires.
         await Onyx.merge(ONYXKEYS.SESSION, {accountID: TEST_ACCOUNT_ID});
         await waitForBatchedUpdates();
-        const actor = createAwaitingSoftPromptActor();
+        const actor = createActorAtState({[MFA_STATE.OPEN]: {[MFA_STATE.PROMPT]: MFA_STATE.AWAITING_SOFT_PROMPT}});
 
         actor.start();
         actor.send({type: 'SOFT_PROMPT_APPROVED'});

tests/utils/mfa/flowActors.ts

@@ -0,0 +1,49 @@
+import type createActors from '@components/MultifactorAuthentication/machine/mfaActors';
+import mfaMachine from '@components/MultifactorAuthentication/machine/mfaMachine';
+import type {MfaContext, MfaEvent} from '@components/MultifactorAuthentication/machine/types';
+
+import type {OutputFrom, StateValue} from 'xstate';
+
+import {createActor} from 'xstate';
+
+import createInitEvent from './flowFixtures';
+import {VALIDATE_DEVICE_DONE_EVENT_TYPE} from './flowPaths';
+
+type ValidateDeviceOutput = OutputFrom<ReturnType<typeof createActors>['validateDevice']>;
+
+/**
+ * Builds the context a flow carries right after INIT seeds it. Overrides express a spec's starting
+ * variation, such as a stored error.
+ */
+function createFlowContext(overrides: Partial<MfaContext> = {}): MfaContext {
+    const initEvent = createInitEvent();
+    return {
+        error: undefined,
+        scenarioName: initEvent.scenarioName,
+        scenario: initEvent.scenario,
+        payload: initEvent.payload,
+        softPromptApproved: false,
+        isCancelConfirmVisible: false,
+        ...overrides,
+    };
+}
+
+/**
+ * Creates an actor resolved to the given state value over a fresh post-INIT context, so a transition
+ * spec can drive a single hop without walking the whole flow first. The actor is not started.
+ */
+function createActorAtState(value: StateValue, contextOverrides?: Partial<MfaContext>) {
+    const snapshot = mfaMachine.resolveState({value, context: createFlowContext(contextOverrides)});
+    return createActor(mfaMachine, {snapshot});
+}
+
+/**
+ * Completes the invoked device-check actor by sending its done event carrying the given output.
+ */
+function sendValidateDeviceDone(actor: ReturnType<typeof createActorAtState>, output: ValidateDeviceOutput) {
+    // Framework actor events are not part of the application's MfaEvent union.
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    actor.send({type: VALIDATE_DEVICE_DONE_EVENT_TYPE, output} as unknown as MfaEvent);
+}
+
+export {createActorAtState, createFlowContext, sendValidateDeviceDone};