diff --git a/app/PARITY.md b/app/PARITY.md index 09ff7002..77fb6823 100644 --- a/app/PARITY.md +++ b/app/PARITY.md @@ -51,7 +51,7 @@ or scratch servers only, never real operator sessions/runs/workflows. | Chat commands/notices/scroll | Preview: dismissible local notices with reconnect clearing | slash palette/actions, unknown-command send-as-message, saved scroll/follow intent | | Saved schedule list | Preview: Settings row, /schedules route, read-only list; a row opens the owning pipeline detail (Summary by default) | authenticated smoke | | Schedule editor | Preview: pipeline Summary creates/edits/pauses/deletes with the lossless draft and revision guard; conflict keeps the draft and shows the server words | Schedule-this-run seeding | -| Search | Preview: exact target model and navigation to pipeline, pinned version, run and recorded stage; field/artifact hits select the recorded Summary section/visit; unresolvable hits stay read-only | authenticated smoke | +| Search | Preview: exact target model and navigation to pipeline, pinned version, run and recorded stage; field/artifact hits select the recorded Summary section/visit (artifact hits follow web S2/Android and open the recorded visit, where the current browser source opens the artifact externally); a retired field or unknown visit selects the plain Summary; unresolvable hits stay read-only | authenticated smoke; rendered capture of the field/artifact selection | | Needs you | Preview: runs-list bell/count, native sheet, dismiss/clear persistence, live fold, transition notifications, Settings permission tile | authenticated preview smoke | | Notifications | Preview: Settings permission tile over live platform state, transition-only dedupe, tap opens the run | background question notices; permission/browser smoke only in fixtures | | Mobile replacement build | Scaffold only | Android build at end; all source portable to iOS, isolated IDs; device/OS behavior clearly separate | diff --git a/app/lib/application/app_router.dart b/app/lib/application/app_router.dart index a99d08df..18899cc1 100644 --- a/app/lib/application/app_router.dart +++ b/app/lib/application/app_router.dart @@ -97,6 +97,15 @@ class AppRouterDelegate extends RouterDelegate with ChangeNotifier { /// The saved-schedule list page, opened above Settings. bool get schedulesOpen => _route.kind == AppRouteKind.schedules; + /// The route the shell renders underneath the transient Search, Templates + /// and Schedules pages. Those pages keep the shell mounted, so the route the + /// operator last opened there is still the shell's own destination. + AppRoute get shellRoute => searchOpen + ? _searchReturn + : templatesOpen || schedulesOpen + ? _templatesReturn + : _route; + @override AppRoute get currentConfiguration => _route; diff --git a/app/lib/application/pipelines_app.dart b/app/lib/application/pipelines_app.dart index 36f7426b..c53ebba6 100644 --- a/app/lib/application/pipelines_app.dart +++ b/app/lib/application/pipelines_app.dart @@ -69,7 +69,8 @@ class _PipelinesAppState extends State { /// One run detail request from Search, delivered through the shell so the /// mounted run detail can resolve it once the named run's steps have loaded. /// A field or artifact hit names no addressable URL of its own, so the request - /// is not route state; it is consumed and cleared after it is applied. + /// is not route state; it is cleared after the detail applies it or when the + /// shell leaves that run, so an abandoned hit never replays later. RunSearchSelection? _pendingRunSearch; /// One notification capability for the app: the Runs attention surface @@ -113,6 +114,7 @@ class _PipelinesAppState extends State { schedulesBuilder: _buildSchedules, builder: _buildShell, ); + _delegate.addListener(_routeChanged); _config = RouterConfig( routeInformationParser: const AppRouteParser(), routerDelegate: _delegate, @@ -124,6 +126,7 @@ class _PipelinesAppState extends State { @override void dispose() { _notifications.dispose(); + _delegate.removeListener(_routeChanged); _delegate.dispose(); if (_ownsProvider) { (_provider as PlatformRouteInformationProvider).dispose(); @@ -198,6 +201,21 @@ class _PipelinesAppState extends State { setState(() => _pendingRunSearch = null); } + /// Drops a pending request once the shell leaves the run it names. + /// + /// The mounted detail is the only consumer, and it exists only after the run's + /// detail has loaded. Backing out while that read is still pending, or leaving + /// a failed detail, would otherwise keep the request for the next unrelated + /// visit to the same run. Search/Templates/Schedules pages above the run keep + /// it, because the shell route underneath them still names that run. + void _routeChanged() { + final pending = _pendingRunSearch; + if (!mounted || pending == null) return; + final route = _delegate.shellRoute; + if (route.kind == AppRouteKind.runs && route.runId == pending.runId) return; + setState(() => _pendingRunSearch = null); + } + /// The Templates page above Settings. Closing it restores the same Settings /// screen instance, so an edited field or an open connection state survives. Widget _buildSchedules(BuildContext context) => SchedulesDestination( diff --git a/app/lib/features/runs/ui/run_detail_tabs.dart b/app/lib/features/runs/ui/run_detail_tabs.dart index 829f8331..c7a1627e 100644 --- a/app/lib/features/runs/ui/run_detail_tabs.dart +++ b/app/lib/features/runs/ui/run_detail_tabs.dart @@ -173,12 +173,12 @@ class _RunDetailTabsState extends State { } } - /// Selects the recorded visit a search result names, without presenting any - /// visit the run did not record. + /// Selects the Summary section or recorded visit a search result names. /// - /// The request is applied once per loaded run. A visit the run did not record, - /// an unknown field or a bare run hit resolves to nothing, which leaves the - /// plain run detail; either way the request is consumed so it never replays. + /// The request is applied once per loaded run and is consumed afterwards. A + /// retired or unknown field still selects the plain Summary, exactly as the + /// browser's `searchFieldTab` does, and a visit the run did not record falls + /// back to the plain Summary, so no stale hit leaves an unrelated pane open. void _applySearchSelection() { final scope = RunSearchSelectionScope.maybeOf(context); final selection = scope?.selection; @@ -190,8 +190,7 @@ class _RunDetailTabsState extends State { final id = widget.run['id']; if (id is! num || id.toInt() != selection.runId) return; _appliedSearchSelection = selection; - final resolved = resolveRunSearchSelection(selection, widget.run); - if (resolved != null) _selectSearchTarget(resolved); + _selectSearchTarget(resolveRunSearchSelection(selection, widget.run)); final consumed = scope.onConsumed; WidgetsBinding.instance.addPostFrameCallback((_) { if (mounted) consumed(); @@ -199,25 +198,25 @@ class _RunDetailTabsState extends State { } void _selectSearchTarget(RunSearchTarget target) { - if (target.section case final section?) { - _tab = RunDetailTab.summary; - _selectedStage = null; - _selectedVisit = null; - switch (section) { - case 'input': - _inputSection.expand(); - case 'output': - _outputSection.expand(); - } - return; + switch (target) { + case RunSummaryTarget(:final section): + _tab = RunDetailTab.summary; + _selectedStage = null; + _selectedVisit = null; + switch (section) { + case RunSummarySection.input: + _inputSection.expand(); + case RunSummarySection.output: + _outputSection.expand(); + case null: + break; + } + case RunVisitTarget(:final stageKey, :final timelineIndex): + if (detailVisitStepAt(widget.run, timelineIndex) == null) return; + _selectedStage = stageKey; + _selectedVisit = timelineIndex; + _tab = RunDetailTab.timeline; } - final stageKey = target.stageKey; - final index = target.timelineIndex; - if (stageKey == null || index == null) return; - if (detailVisitStepAt(widget.run, index) == null) return; - _selectedStage = stageKey; - _selectedVisit = index; - _tab = RunDetailTab.timeline; } /// Selects the stage's latest recorded visit. An unvisited stage has none, diff --git a/app/lib/features/runs/ui/run_search_selection.dart b/app/lib/features/runs/ui/run_search_selection.dart index a4cfda2c..ccb8bb5a 100644 --- a/app/lib/features/runs/ui/run_search_selection.dart +++ b/app/lib/features/runs/ui/run_search_selection.dart @@ -32,61 +32,66 @@ class RunSearchSelection { int get hashCode => Object.hash(runId, sequence, field); } +/// The collapsible Summary section a text hit names. +enum RunSummarySection { input, output } + /// What a resolved search request selects in the loaded run detail. -/// -/// A [section] names one collapsible Summary section; [stageKey] and -/// [timelineIndex] name one recorded visit, using the same row index the -/// Timeline and the Graph selection use. -@immutable -class RunSearchTarget { - const RunSearchTarget.section(this.section) - : stageKey = null, - timelineIndex = null; - - const RunSearchTarget.visit({ - required this.stageKey, - required this.timelineIndex, - }) : section = null; - - final String? section; - final String? stageKey; - final int? timelineIndex; +sealed class RunSearchTarget { + const RunSearchTarget(); } -/// Resolves [selection] against the loaded [run], or null when the run recorded -/// nothing the request names. +/// The run Summary, optionally with the matched field's section expanded. +final class RunSummaryTarget extends RunSearchTarget { + const RunSummaryTarget({this.section}); + + /// The section a text hit matched, or null for the plain Summary. + final RunSummarySection? section; +} + +/// One recorded visit: [stageKey] plus the detail row index the Timeline and +/// the Graph selection also use. +final class RunVisitTarget extends RunSearchTarget { + const RunVisitTarget({required this.stageKey, required this.timelineIndex}); + + final String stageKey; + final int timelineIndex; +} + +/// Resolves [selection] against the loaded [run] into the detail state to show. /// -/// A text hit selects the Summary section holding the matched field, mirroring -/// the browser's `searchFieldTab`: a retired or unknown field resolves to the -/// plain Summary instead of guessing a section. A visit hit selects the step -/// with the recorded sequence and its own row in the Timeline; a sequence the -/// run did not record resolves to nothing. Either null leaves the plain run -/// detail in place. -RunSearchTarget? resolveRunSearchSelection( +/// A text hit always selects the Summary, using the browser's `searchFieldTab` +/// mapping: `input` and `output` expand that section, while a retired or +/// unknown field leaves the plain Summary instead of guessing a section. A +/// visit hit selects the step with the recorded sequence; a sequence the run did +/// not record falls back to the plain Summary, as the browser does, so a stale +/// hit never leaves an unrelated visit pane open. +RunSearchTarget resolveRunSearchSelection( RunSearchSelection selection, JsonMap run, ) { final field = selection.field?.trim() ?? ''; if (field.isNotEmpty) { - return switch (field) { - 'input' => const RunSearchTarget.section('input'), - 'output' => const RunSearchTarget.section('output'), - _ => null, - }; + return RunSummaryTarget( + section: switch (field) { + 'input' => RunSummarySection.input, + 'output' => RunSummarySection.output, + _ => null, + }, + ); } final sequence = selection.sequence; - if (sequence == null || sequence <= 0) return null; - - final steps = detailRunSteps(run); - for (var index = 0; index < steps.length; index++) { - if (_sequence(steps[index]) != sequence) continue; - final stage = '${steps[index]['stage'] ?? ''}'.trim(); - if (stage.isEmpty) return null; - // The row index is the Timeline's own index, the identity the visit pane - // reads back through detailVisitStepAt, so no ordinal is guessed here. - return RunSearchTarget.visit(stageKey: stage, timelineIndex: index); + if (sequence != null && sequence > 0) { + final steps = detailRunSteps(run); + for (var index = 0; index < steps.length; index++) { + if (_sequence(steps[index]) != sequence) continue; + final stage = '${steps[index]['stage'] ?? ''}'.trim(); + if (stage.isEmpty) break; + // The row index is the Timeline's own index, the identity the visit pane + // reads back through detailVisitStepAt, so no ordinal is guessed here. + return RunVisitTarget(stageKey: stage, timelineIndex: index); + } } - return null; + return const RunSummaryTarget(); } int? _sequence(JsonMap step) { diff --git a/app/test/application/search_wiring_test.dart b/app/test/application/search_wiring_test.dart index 20dfabb3..86de29eb 100644 --- a/app/test/application/search_wiring_test.dart +++ b/app/test/application/search_wiring_test.dart @@ -73,6 +73,66 @@ Future replyRunList(WidgetTester tester, FakeChannel channel) => reply( }, ); +Future replyRun7List(WidgetTester tester, FakeChannel channel) => reply( + tester, + channel, + 'list_runs', + body: { + 'type': 'runs', + 'runs': [ + {'id': 7, 'title': 'Run 7', 'status': 'succeeded'}, + ], + }, +); + +/// Opens Search, sends `report` and answers with the artifact hit for run 7. +Future searchArtifactHit( + WidgetTester tester, + FakeChannel channel, { + int index = 0, +}) async { + await tester.tap(find.byKey(const ValueKey('shell.search'))); + await tester.pump(); + await tester.pump(const Duration(milliseconds: 600)); + await tester.pump(const Duration(milliseconds: 100)); + await tester.enterText(find.byKey(const ValueKey('search.field')), 'report'); + await tester.pump(const Duration(milliseconds: 300)); + final request = await waitForRequest(tester, channel, 'search', index: index); + channel.incoming.add( + jsonEncode({ + 'id': request['id'], + 'type': 'search_results', + 'search_results': { + 'query': 'report', + 'kind': '', + 'results': [artifactHit()], + 'truncated': false, + 'scanned_steps': 2, + 'scanned_bytes': 64, + 'cap': 50, + 'scan_bound_bytes': 1 << 20, + }, + }), + ); + await tester.pump(); + await tester.pump(); +} + +/// Selects the artifact hit, leaving run 7's `get_run` request unanswered. +Future openArtifactHit( + WidgetTester tester, + FakeChannel channel, { + int index = 0, +}) async { + await searchArtifactHit(tester, channel, index: index); + await tester.tap( + find.byKey(const ValueKey('search.result./artifacts/7/2/report.txt')), + ); + await tester.pump(); + await tester.pump(const Duration(milliseconds: 400)); + await tester.pump(const Duration(milliseconds: 400)); +} + Future replyRunDetail( WidgetTester tester, FakeChannel channel, @@ -151,6 +211,18 @@ JsonMap fieldHit() => { }, }; +JsonMap retiredFieldHit() => { + 'kind': 'field', + 'target': 'run:7:5:evidence', + 'matched_field': 'evidence', + 'field': { + 'run_id': 7, + 'sequence': 5, + 'field': 'evidence', + 'snippet': 'retired', + }, +}; + JsonMap runHit(int id) => { 'kind': 'run', 'target': 'run:$id', @@ -424,8 +496,28 @@ void main() { expect(find.byKey(const Key('run-visit-pane')), findsOneWidget); expect(find.text('build ยท visit 2'), findsOneWidget); - // A field hit opens the same run at the Summary section holding the match. - await sendSearch(query: 'release', index: 1, hit: fieldHit()); + // A retired field hit replaces that open visit with the plain Summary. + await sendSearch(query: 'retired', index: 1, hit: retiredFieldHit()); + await tester.tap( + find.byKey(const ValueKey('search.result.run:7:5:evidence')), + ); + await tester.pump(); + await tester.pump(const Duration(milliseconds: 400)); + await tester.pump(const Duration(milliseconds: 400)); + + expect(provider.value.uri.path, '/runs/7'); + expect(find.byType(SearchScreen), findsNothing); + expect(find.byKey(const Key('run-visit-pane')), findsNothing); + expect( + find.byKey(const Key('run-detail-tab-body-summary')), + findsOneWidget, + ); + expect(find.textContaining('"prompt": "ship it"'), findsNothing); + expect(find.textContaining('"result": "ok"'), findsNothing); + + // A current field hit opens the same run at the Summary section holding the + // match, leaving the other section collapsed. + await sendSearch(query: 'release', index: 2, hit: fieldHit()); await tester.tap( find.byKey(const ValueKey('search.result.run:7:5:output')), ); @@ -437,6 +529,7 @@ void main() { expect(find.byType(SearchScreen), findsNothing); expect(find.byKey(const Key('run-visit-pane')), findsNothing); expect(find.textContaining('"result": "ok"'), findsOneWidget); + expect(find.textContaining('"prompt": "ship it"'), findsNothing); await tester.pumpWidget(const SizedBox.shrink()); await tester.pump(); @@ -515,6 +608,113 @@ void main() { await tester.pump(); }); + testWidgets('an abandoned selection does not replay on run reopen', ( + tester, + ) async { + tester.view.physicalSize = const Size(900, 1000); + tester.view.devicePixelRatio = 1; + addTearDown(tester.view.resetPhysicalSize); + addTearDown(tester.view.resetDevicePixelRatio); + + final channel = FakeChannel()..readyCompleter.complete(); + final client = PipelinesClient(channelFactory: (_) => channel); + final provider = PlatformRouteInformationProvider( + initialRouteInformation: RouteInformation(uri: Uri.parse('/runs')), + ); + addTearDown(provider.dispose); + + await pumpApp( + tester, + channel: channel, + client: client, + provider: provider, + cupertino: false, + ); + await replyRun7List(tester, channel); + + // The hit navigates to run 7, but its detail is never loaded: the operator + // leaves from the loading placeholder instead. + await openArtifactHit(tester, channel); + expect(provider.value.uri.path, '/runs/7'); + expect(find.text('Back to list'), findsOneWidget); + await tester.tap(find.text('Back to list')); + await tester.pump(); + await tester.pump(); + expect(provider.value.uri.path, '/runs'); + + // The abandoned read's late reply is ignored; the request queue is free for + // the ordinary reopen. + await replyRunDetailFor(tester, channel, searchSelectionDetail(), index: 0); + await tester.pump(); + + // Reopening the same run is an ordinary visit: no search named this visit. + await tester.tap(find.text('Run 7')); + await tester.pump(); + await tester.pump(const Duration(milliseconds: 100)); + await replyRunDetailFor(tester, channel, searchSelectionDetail(), index: 1); + await tester.pumpAndSettle(); + + expect(find.byKey(const Key('run-visit-pane')), findsNothing); + expect( + find.byKey(const Key('run-detail-tab-body-summary')), + findsOneWidget, + ); + expect(find.textContaining('"result": "ok"'), findsNothing); + + await tester.pumpWidget(const SizedBox.shrink()); + await tester.pump(); + }); + + testWidgets('a consumed selection does not replay on run reopen', ( + tester, + ) async { + tester.view.physicalSize = const Size(900, 1000); + tester.view.devicePixelRatio = 1; + addTearDown(tester.view.resetPhysicalSize); + addTearDown(tester.view.resetDevicePixelRatio); + + final channel = FakeChannel()..readyCompleter.complete(); + final client = PipelinesClient(channelFactory: (_) => channel); + final provider = PlatformRouteInformationProvider( + initialRouteInformation: RouteInformation(uri: Uri.parse('/runs')), + ); + addTearDown(provider.dispose); + + await pumpApp( + tester, + channel: channel, + client: client, + provider: provider, + cupertino: false, + ); + await replyRun7List(tester, channel); + + await openArtifactHit(tester, channel); + await replyRunDetailFor(tester, channel, searchSelectionDetail(), index: 0); + await tester.pumpAndSettle(); + expect(find.byKey(const Key('run-visit-pane')), findsOneWidget); + + await tester.tap(find.text('Back to list')); + await tester.pump(); + await tester.pump(); + expect(provider.value.uri.path, '/runs'); + + await tester.tap(find.text('Run 7')); + await tester.pump(); + await tester.pump(const Duration(milliseconds: 100)); + await replyRunDetailFor(tester, channel, searchSelectionDetail(), index: 1); + await tester.pumpAndSettle(); + + expect(find.byKey(const Key('run-visit-pane')), findsNothing); + expect( + find.byKey(const Key('run-detail-tab-body-summary')), + findsOneWidget, + ); + + await tester.pumpWidget(const SizedBox.shrink()); + await tester.pump(); + }); + testWidgets('Cupertino uses its native bar action and Back', (tester) async { tester.view.physicalSize = const Size(390, 844); tester.view.devicePixelRatio = 1; @@ -627,6 +827,8 @@ void main() { router.openSearch(); expect(router.route, AppRoute.search); expect(router.searchOpen, isTrue); + // Search is a page above the shell; the open run stays under it. + expect(router.shellRoute, AppRoute.run(3)); expect(await router.popRoute(), isTrue); expect(router.route, AppRoute.run(3)); diff --git a/app/test/features/runs/ui/run_search_selection_test.dart b/app/test/features/runs/ui/run_search_selection_test.dart index 09a6d76d..188955b6 100644 --- a/app/test/features/runs/ui/run_search_selection_test.dart +++ b/app/test/features/runs/ui/run_search_selection_test.dart @@ -40,7 +40,9 @@ JsonMap searchSelectionRun() => { ], }; -Future pumpSelection( +/// Pumps one mounted detail under a mutable search scope, returning the notifier +/// that applies a later request to the same detail state. +Future> pumpLiveSelection( WidgetTester tester, RunDetailTestPlatform platform, RunSearchSelection selection, { @@ -53,15 +55,20 @@ Future pumpSelection( final controller = RunsController(RunsRepository(gateway)); addTearDown(controller.dispose); await controller.select(77); + final pending = ValueNotifier(selection); + addTearDown(pending.dispose); final page = MediaQuery( data: MediaQueryData.fromView(tester.view), - child: RunSearchSelectionScope( - selection: selection, - onConsumed: onConsumed ?? () {}, - child: RunDetailView( - controller: controller, - gateway: gateway, - onBack: () {}, + child: ValueListenableBuilder( + valueListenable: pending, + builder: (context, current, _) => RunSearchSelectionScope( + selection: current, + onConsumed: onConsumed ?? () {}, + child: RunDetailView( + controller: controller, + gateway: gateway, + onBack: () {}, + ), ), ), ); @@ -74,6 +81,23 @@ Future pumpSelection( ), ); await tester.pumpAndSettle(); + return pending; +} + +Future pumpSelection( + WidgetTester tester, + RunDetailTestPlatform platform, + RunSearchSelection selection, { + VoidCallback? onConsumed, +}) async { + await pumpLiveSelection(tester, platform, selection, onConsumed: onConsumed); +} + +/// The browser's `searchFieldTab` mapping, independent of whether a detail is +/// mounted: every text hit names a Summary, expanding only a current section. +void _expectSummarySection(RunSearchTarget target, RunSummarySection? section) { + expect(target, isA()); + expect((target as RunSummaryTarget).section, section); } void main() { @@ -108,38 +132,41 @@ void main() { ); }); - testWidgets('an input field hit expands the Summary input section', ( - tester, - ) async { - await pumpSelection( - tester, - RunDetailTestPlatform.material, - const RunSearchSelection(runId: 77, sequence: 5, field: 'input'), - ); - - expect( - find.byKey(const Key('run-detail-tab-body-summary')), - findsOneWidget, - ); - expect(find.textContaining('"prompt": "ship it"'), findsOneWidget); - }); - for (final platform in RunDetailTestPlatform.values) { - testWidgets('${platform.name} output field expands the Summary section', ( + testWidgets('${platform.name} input field expands only the input section', ( tester, ) async { await pumpSelection( tester, platform, - const RunSearchSelection(runId: 77, sequence: 5, field: 'output'), + const RunSearchSelection(runId: 77, sequence: 5, field: 'input'), ); expect( find.byKey(const Key('run-detail-tab-body-summary')), findsOneWidget, ); - expect(find.textContaining('"result": "ok"'), findsOneWidget); + expect(find.textContaining('"prompt": "ship it"'), findsOneWidget); + expect(find.textContaining('"result": "ok"'), findsNothing); }); + + testWidgets( + '${platform.name} output field expands only the output section', + (tester) async { + await pumpSelection( + tester, + platform, + const RunSearchSelection(runId: 77, sequence: 5, field: 'output'), + ); + + expect( + find.byKey(const Key('run-detail-tab-body-summary')), + findsOneWidget, + ); + expect(find.textContaining('"result": "ok"'), findsOneWidget); + expect(find.textContaining('"prompt": "ship it"'), findsNothing); + }, + ); } testWidgets('a retired field opens the plain Summary', (tester) async { @@ -157,6 +184,35 @@ void main() { expect(find.textContaining('"result": "ok"'), findsNothing); }); + for (final platform in RunDetailTestPlatform.values) { + testWidgets( + '${platform.name} retired field replaces an open visit with Summary', + (tester) async { + final pending = await pumpLiveSelection( + tester, + platform, + const RunSearchSelection(runId: 77, sequence: 2), + ); + expect(find.byKey(const Key('run-visit-pane')), findsOneWidget); + + pending.value = const RunSearchSelection( + runId: 77, + sequence: 5, + field: 'evidence', + ); + await tester.pumpAndSettle(); + + expect(find.byKey(const Key('run-visit-pane')), findsNothing); + expect( + find.byKey(const Key('run-detail-tab-body-summary')), + findsOneWidget, + ); + expect(find.textContaining('"prompt": "ship it"'), findsNothing); + expect(find.textContaining('"result": "ok"'), findsNothing); + }, + ); + } + testWidgets('the search request is consumed once it has been applied', ( tester, ) async { @@ -171,4 +227,56 @@ void main() { expect(find.byKey(const Key('run-visit-pane')), findsOneWidget); expect(consumed, 1); }); + + group('resolveRunSearchSelection', () { + test('input and output name their Summary section', () { + _expectSummarySection( + resolveRunSearchSelection( + const RunSearchSelection(runId: 77, field: 'input'), + searchSelectionRun(), + ), + RunSummarySection.input, + ); + _expectSummarySection( + resolveRunSearchSelection( + const RunSearchSelection(runId: 77, field: 'output'), + searchSelectionRun(), + ), + RunSummarySection.output, + ); + }); + + test('a retired or unknown field still names the plain Summary', () { + for (final field in ['evidence', 'transcript', 'unknown']) { + _expectSummarySection( + resolveRunSearchSelection( + RunSearchSelection(runId: 77, field: field), + searchSelectionRun(), + ), + null, + ); + } + }); + + test('a recorded sequence names its own detail row', () { + final target = resolveRunSearchSelection( + const RunSearchSelection(runId: 77, sequence: 2), + searchSelectionRun(), + ); + + expect(target, isA()); + expect((target as RunVisitTarget).stageKey, 'build'); + expect(target.timelineIndex, 1); + }); + + test('an unrecorded sequence falls back to the plain Summary', () { + _expectSummarySection( + resolveRunSearchSelection( + const RunSearchSelection(runId: 77, sequence: 99), + searchSelectionRun(), + ), + null, + ); + }); + }); }