test(mfa): drop transition coverage and inline the walked-state guard

The transition suite mostly guarded the path generator against itself, at
snapshot granularity that multiplies with every context field, so it goes
away together with its private transitionCoverage module. The cheap guard
that every settleable state occurs in a UI-walked path stays, moved next to
the walk it covers, because everyStateReachable checks the unfiltered graph
and testConfig only proves an assertion exists, not that it ever runs.

Author: dariusz-biela

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

@@ -17,8 +17,8 @@ import SCREENS from '@src/SCREENS';
 // navigator, drives each machine event as a real gesture, and asserts the UI markers of the reached
 // state at every step of every generated path. A state or event added to the machine appears in the
 // walked paths automatically, and the type checks and guard suites then demand the hand-written
-// pieces it needs, such as an executor or a UI assertion. The machine-only suites
-// live in `everyStateReachable.test.ts` and the coverage guards in `coverageStaysComplete.test.ts`.
+// pieces it needs, such as an executor or a UI assertion. The machine-only suites live in
+// `everyStateReachable.test.ts`, and the guard suites below check that the walk and `testConfig` stay complete.
 
 // This mock forces a wide layout so the navigator renders the backdrop used as the mounted marker.
 jest.mock('@hooks/useResponsiveLayout');
@@ -141,6 +141,18 @@ describe('the real MFA modal matches the machine at every step of every generate
     }
 });
 
+// Every settleable leaf must occur in a path that the walk above drives. `everyStateReachable.test.ts`
+// checks the unfiltered graph, so only this guard catches a state whose every route needs a step the
+// walk cannot drive, such as a delayed transition. Paths removed as prefixes of longer paths do not
+// reduce state coverage because `path.test` asserts every step.
+describe('every settleable MFA state is reached by the UI walk', () => {
+    const walkedStateValues = walkedPaths.flatMap((path) => path.steps.map((step) => step.state.value));
+
+    it.each(getSettleableLeafStates(mfaMachine.root))('$description is reached through the real UI', ({description}) => {
+        expect(walkedStateValues.some((reached) => matchesState(description, reached))).toBe(true);
+    });
+});
+
 // TestModel runs only the state assertions whose keys match the reached state, so if no key matches a
 // state, the test passes without checking it. These guards fail in that case.
 //

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

@@ -1,6 +1,5 @@
 import type {SnapshotFrom} from 'xstate';
 import {matchesState} from 'xstate';
-import type {StatePath} from 'xstate/graph';
 import {getShortestPaths, TestModel} from 'xstate/graph';
 import mfaMachine from '@components/MultifactorAuthentication/machine/mfaMachine';
 import type {MfaEvent} from '@components/MultifactorAuthentication/machine/types';
@@ -65,7 +64,6 @@ function hasMfaEventFixtures(type: string): type is MfaEvent['type'] {
 const DELAYED_EVENT_PREFIX = 'xstate.after';
 
 type MfaSnapshot = SnapshotFrom<typeof mfaMachine>;
-type MfaStatePath = StatePath<MfaSnapshot, MfaEvent>;
 
 /**
  * A path is UI-drivable when the walk can produce every step. A delayed transition would need real
@@ -119,8 +117,8 @@ 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 walk cannot drive a timer, and the reachability guards catch a state that loses every
- * drivable route.
+ * because the walk cannot drive a timer, and the walk-coverage guard in `viewMatchesMachine.test.tsx`
+ * catches a state that loses every drivable route.
  *
  * `path.test` skips a step whose event has no executor, which keeps framework steps such as
  * `xstate.init` harmless while the executor table still forces an executor for every application event.
@@ -132,5 +130,4 @@ function getWalkedPaths() {
 }
 
 export default getWalkedPaths;
-export {DELAYED_EVENT_PREFIX, getDrivingJourneyPaths, getMfaShortestPaths, getTraversalEvents};
-export type {MfaStatePath};
+export {getDrivingJourneyPaths, getMfaShortestPaths};