refactor(mfa): split stable from settleable leaves in one leafStates module

The reachability suite now checks the stable set, which keeps a leaf whose
routing invoke resolves through a later event, while the UI walk keeps
asserting only the settleable subset it can stop on. Both getters share one
traversal and one set of predicates instead of two near-identical files.

Author: dariusz-biela

tests/unit/components/MultifactorAuthentication/machine/graphTraversal/everyStateReachable.test.ts

@@ -1,19 +1,19 @@
 import {getDrivingJourneyPaths, getMfaShortestPaths} from 'tests/utils/mfa/flowPaths';
-import getSettleableLeafStates from 'tests/utils/mfa/settleableLeafStates';
+import {getStableLeafStates} from 'tests/utils/mfa/leafStates';
 import {matchesState} from 'xstate';
 import mfaMachine from '@components/MultifactorAuthentication/machine/mfaMachine';
 
 // Both suites in this file are generated by traversing the mfaMachine graph, so a state added to the
-// machine gets a test here automatically. Nothing renders in this file. `settleableLeafStates.ts`
-// defines which states count as settleable.
+// machine gets a test here automatically. Nothing renders in this file. `leafStates.ts` excludes
+// only transient leaves that XState resolves before emitting a snapshot.
 
 // Reachability is asserted on the unfiltered shortest paths, so it also covers routes the UI walk in
 // `viewMatchesMachine.test.tsx` cannot drive (a delayed transition, for example). A failure here means
 // the machine itself lost the state, not that the UI harness broke.
-describe('every settleable MFA state is reachable in the machine chart', () => {
+describe('every stable MFA state is reachable in the machine chart', () => {
     const reachableSnapshots = getMfaShortestPaths().map((path) => path.state);
 
-    it.each(getSettleableLeafStates(mfaMachine.root))('$description can be reached from the initial state', ({description}) => {
+    it.each(getStableLeafStates(mfaMachine.root))('$description can be reached from the initial state', ({description}) => {
         expect(reachableSnapshots.some((snapshot) => matchesState(description, snapshot.value))).toBe(true);
     });
 });

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

@@ -1,10 +1,10 @@
 import {act, fireEvent, screen} from '@testing-library/react-native';
 import {MFA_TEST_SCENARIO_NAME} from 'tests/utils/mfa/flowFixtures';
 import getWalkedPaths from 'tests/utils/mfa/flowPaths';
+import {getSettleableLeafStates} from 'tests/utils/mfa/leafStates';
 import renderMfaUi from 'tests/utils/mfa/realUi/harness';
 import {pendingModalClose, resetMfaUiMocks} from 'tests/utils/mfa/realUi/mocks';
 import type * as MfaRealUiMocks from 'tests/utils/mfa/realUi/mocks';
-import getSettleableLeafStates from 'tests/utils/mfa/settleableLeafStates';
 import waitForBatchedUpdatesWithAct from 'tests/utils/waitForBatchedUpdatesWithAct';
 import {matchesState} from 'xstate';
 import mfaMachine from '@components/MultifactorAuthentication/machine/mfaMachine';

tests/utils/mfa/flowPaths.ts

@@ -117,7 +117,7 @@ function getDrivingJourneyPaths() {
  * Returns the generated coverage paths plus the explicit driving journeys. The journeys are needed
  * because a shortest path can be empty, such as the path to the initial `closed` state, so the
  * generated paths alone would never drive the teardown. Paths with a delayed step are filtered out
- * because the UI walk cannot drive a timer. `everyStateReachable.test.ts` checks settleable-state
+ * because the UI walk cannot drive a timer. `everyStateReachable.test.ts` checks stable-state
  * reachability over the unfiltered graph, while the walk-coverage guard in
  * `viewMatchesMachine.test.tsx` catches a state that loses every UI-drivable route.
  *

tests/utils/mfa/leafStates.ts

@@ -0,0 +1,50 @@
+import type {AnyStateNode} from 'xstate';
+
+type LeafState = {description: string};
+
+function getLeafNodes(node: AnyStateNode): AnyStateNode[] {
+    const children = Object.values(node.states);
+    if (children.length > 0) {
+        return children.flatMap(getLeafNodes);
+    }
+    return [node];
+}
+
+function hasUnguardedAlways(node: AnyStateNode): boolean {
+    return node.always?.some((transition) => transition.guard === undefined) ?? false;
+}
+
+function hasRoutingInvoke(node: AnyStateNode): boolean {
+    return node.invoke.some((definition) => definition.onDone !== undefined || definition.onError !== undefined);
+}
+
+// The dot-path description doubles as a state-value key: `matchesState` splits it on `.` before comparing.
+function toLeafState(node: AnyStateNode): LeafState {
+    return {description: node.path.join('.')};
+}
+
+/**
+ * Returns leaf states that can exist as snapshots after an XState macrostep. An unguarded `always`
+ * transition is resolved in the same macrostep that enters the state, so graph paths cannot observe
+ * that leaf. A guarded `always` may keep the machine in place, and an invoked actor completes through
+ * a later event, so both remain part of machine reachability.
+ */
+function getStableLeafStates(node: AnyStateNode): LeafState[] {
+    return getLeafNodes(node)
+        .filter((leaf) => !hasUnguardedAlways(leaf))
+        .map(toLeafState);
+}
+
+/**
+ * Returns the stable leaf states that the UI walk can also stop on and assert. An invoked actor
+ * counts as auto-advancing once it registers `onDone` or `onError`, which is true for an actor that
+ * completes immediately (the mocked promise actors this harness expects) but not for one that stays
+ * pending. Revisit this predicate when the first real invoke state is added to the machine.
+ */
+function getSettleableLeafStates(node: AnyStateNode): LeafState[] {
+    return getLeafNodes(node)
+        .filter((leaf) => !hasUnguardedAlways(leaf) && !hasRoutingInvoke(leaf))
+        .map(toLeafState);
+}
+
+export {getStableLeafStates, getSettleableLeafStates};