From 133df9301d556bab3e5d57523a109a3e35a85200 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Thu, 22 Oct 2026 15:34:48 +0100 Subject: [PATCH] feat(app): select a search hit's recorded run section or visit --- app/PARITY.md | 2 +- app/lib/application/pipelines_app.dart | 90 +++++-- .../runs/ui/run_detail_tab_bodies.dart | 10 + app/lib/features/runs/ui/run_detail_tabs.dart | 76 ++++++ .../runs/ui/run_search_selection.dart | 121 +++++++++ app/test/application/search_wiring_test.dart | 230 ++++++++++++++++++ .../runs/ui/run_search_selection_test.dart | 174 +++++++++++++ 7 files changed, 676 insertions(+), 27 deletions(-) create mode 100644 app/lib/features/runs/ui/run_search_selection.dart create mode 100644 app/test/features/runs/ui/run_search_selection_test.dart diff --git a/app/PARITY.md b/app/PARITY.md index 82a80c56..09ff7002 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; unresolvable hits stay read-only | field/artifact hits open the run (their pane selection is a later slice) | +| 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 | | 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/pipelines_app.dart b/app/lib/application/pipelines_app.dart index 321be5a9..36f7426b 100644 --- a/app/lib/application/pipelines_app.dart +++ b/app/lib/application/pipelines_app.dart @@ -10,6 +10,7 @@ import '../shell/adaptive_shell.dart'; import '../shell/destination.dart'; import '../features/attention/notify/notification_controller.dart'; import '../features/attention/notify/notification_store.dart'; +import '../features/runs/ui/run_search_selection.dart'; import '../features/search/domain/search_target.dart'; import '../features/settings/settings_screen.dart'; import 'app.dart'; @@ -65,6 +66,12 @@ class _PipelinesAppState extends State { /// list once; the run itself is then opened from its route. int _runsRefresh = 0; + /// 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. + RunSearchSelection? _pendingRunSearch; + /// One notification capability for the app: the Runs attention surface /// publishes live transitions and Settings renders the same permission. late final NotificationController _notifications = NotificationController( @@ -145,25 +152,50 @@ class _PipelinesAppState extends State { /// Open a result through the exact identity the hit records. An unresolvable /// hit navigates nowhere: the screen already presents it read-only rather than /// guessing a destination. + /// + /// A field or artifact hit has no URL of its own: both open the run and leave + /// a resolved-once request for the mounted detail, which selects the recorded + /// Summary section or visit as soon as that run's steps are available. A + /// sequence or field the run did not record leaves the plain detail. void _openSearchResult(JsonMap hit) { final resolved = searchTargetFor(hit); if (resolved is! ResolvedSearchTarget) return; - final route = switch (resolved.target) { - SearchPipelineTarget(:final pipelineId) => AppRoute.pipeline(pipelineId), - SearchVersionTarget(:final pipelineId, :final version) => - AppRoute.pipeline(pipelineId, version: version), - SearchRunTarget(:final runId) => AppRoute.run(runId), - SearchStepTarget(:final runId, :final stage, :final visit) => - stage == null + AppRoute? route; + RunSearchSelection? selection; + switch (resolved.target) { + case SearchPipelineTarget(:final pipelineId): + route = AppRoute.pipeline(pipelineId); + case SearchVersionTarget(:final pipelineId, :final version): + route = AppRoute.pipeline(pipelineId, version: version); + case SearchRunTarget(:final runId): + route = AppRoute.run(runId); + case SearchStepTarget(:final runId, :final stage, :final visit): + route = stage == null ? AppRoute.run(runId) - : AppRoute.run.stage(runId, stage, visit: visit), - // A field or artifact names a visit inside the run; the run detail owns - // that pane, so open the run rather than inventing a stage route. - SearchFieldTarget(:final runId) => AppRoute.run(runId), - SearchArtifactTarget(:final runId) => - runId == null ? null : AppRoute.run(runId), - }; - if (route != null) _delegate.goTo(route); + : AppRoute.run.stage(runId, stage, visit: visit); + case SearchFieldTarget(:final runId, :final sequence, :final field): + selection = RunSearchSelection( + runId: runId, + sequence: sequence, + field: field, + ); + route = AppRoute.run(runId); + case SearchArtifactTarget(:final runId, :final sequence): + if (runId != null) { + selection = RunSearchSelection(runId: runId, sequence: sequence); + route = AppRoute.run(runId); + } + } + if (route == null) return; + setState(() => _pendingRunSearch = selection); + _delegate.goTo(route); + } + + /// The mounted run detail applied the pending request; reopening the same run + /// later starts from its plain detail and never replays the search selection. + void _runSearchConsumed() { + if (!mounted || _pendingRunSearch == null) return; + setState(() => _pendingRunSearch = null); } /// The Templates page above Settings. Closing it restores the same Settings @@ -217,17 +249,23 @@ class _PipelinesAppState extends State { initialVersion: route.version, initialStageKey: route.stageKey, ), - AppDestination.runs: (_) => RunsDestination( - session: _session, - server: widget.server, - initialRunId: route.runId, - initialStageKey: route.stageKey, - initialVisit: route.visit, - initialDecide: route.decide, - listRefreshToken: _runsRefresh, - notifications: _notifications, - onRunSelected: (id) => _delegate.goTo(AppRoute.run(id)), - onBack: () => _delegate.goTo(AppRoute.runs), + // The one place a field or artifact hit's selection can be resolved: the + // run detail owns the recorded visit and Summary section. + AppDestination.runs: (_) => RunSearchSelectionScope( + selection: _pendingRunSearch, + onConsumed: _runSearchConsumed, + child: RunsDestination( + session: _session, + server: widget.server, + initialRunId: route.runId, + initialStageKey: route.stageKey, + initialVisit: route.visit, + initialDecide: route.decide, + listRefreshToken: _runsRefresh, + notifications: _notifications, + onRunSelected: (id) => _delegate.goTo(AppRoute.run(id)), + onBack: () => _delegate.goTo(AppRoute.runs), + ), ), AppDestination.chat: (_) => ChatDestination( session: _session, diff --git a/app/lib/features/runs/ui/run_detail_tab_bodies.dart b/app/lib/features/runs/ui/run_detail_tab_bodies.dart index 333c5b96..0b0ebfb3 100644 --- a/app/lib/features/runs/ui/run_detail_tab_bodies.dart +++ b/app/lib/features/runs/ui/run_detail_tab_bodies.dart @@ -21,6 +21,8 @@ Widget runDetailSummaryTab({ required bool copying, required String? copyStatus, required VoidCallback onCopy, + ExpansibleController? inputController, + ExpansibleController? outputController, }) { final rows = detailSummaryRows(run); final identity = detailSummaryIdentity(run); @@ -55,6 +57,7 @@ Widget runDetailSummaryTab({ title: 'Input', value: run['input'], empty: visitEmptyInput, + controller: inputController, ), _cupertinoFieldSection( context, @@ -62,6 +65,7 @@ Widget runDetailSummaryTab({ title: 'Output', value: run['output'], empty: visitEmptyOutput, + controller: outputController, ), ], ); @@ -96,6 +100,7 @@ Widget runDetailSummaryTab({ title: 'Input', value: run['input'], empty: visitEmptyInput, + controller: inputController, ), _materialFieldSection( context, @@ -103,6 +108,7 @@ Widget runDetailSummaryTab({ title: 'Output', value: run['output'], empty: visitEmptyOutput, + controller: outputController, ), ], ); @@ -196,9 +202,11 @@ Widget _materialFieldSection( required String title, required dynamic value, required String empty, + ExpansibleController? controller, }) { return ExpansionTile( key: ValueKey(key), + controller: controller, title: Text(title), expandedCrossAxisAlignment: CrossAxisAlignment.start, childrenPadding: const EdgeInsetsDirectional.fromSTEB(16, 0, 16, 16), @@ -314,12 +322,14 @@ Widget _cupertinoFieldSection( required String title, required dynamic value, required String empty, + ExpansibleController? controller, }) { return CupertinoListSection.insetGrouped( key: ValueKey(key), children: [ CupertinoExpansionTile( title: Text(title), + controller: controller, child: Padding( padding: const EdgeInsetsDirectional.fromSTEB(16, 0, 16, 16), child: Align( diff --git a/app/lib/features/runs/ui/run_detail_tabs.dart b/app/lib/features/runs/ui/run_detail_tabs.dart index 65ca3c4e..829f8331 100644 --- a/app/lib/features/runs/ui/run_detail_tabs.dart +++ b/app/lib/features/runs/ui/run_detail_tabs.dart @@ -11,6 +11,7 @@ import 'run_detail_tab_strip.dart'; import 'run_detail_timeline.dart'; import 'run_detail_visit.dart'; import 'run_detail_visit_facts.dart'; +import 'run_search_selection.dart'; /// The least height the selected tab keeps for its own content. /// @@ -81,12 +82,36 @@ class _RunDetailTabsState extends State { String? _selectedStage; int? _selectedVisit; + /// The Summary's collapsible Input and Output sections. A search text hit + /// expands the one its recorded field names, exactly as the browser opens the + /// matching Summary section. The detail owns them so the tab body stays a + /// presentation widget. + final _inputSection = ExpansibleController(); + final _outputSection = ExpansibleController(); + + /// The search request last applied by this detail, so a rebuild of the same + /// request never reopens a pane the operator closed in the meantime. + RunSearchSelection? _appliedSearchSelection; + @override void initState() { super.initState(); _applyInitialVisit(); } + @override + void didChangeDependencies() { + super.didChangeDependencies(); + _applySearchSelection(); + } + + @override + void dispose() { + _inputSection.dispose(); + _outputSection.dispose(); + super.dispose(); + } + @override void didUpdateWidget(covariant RunDetailTabs oldWidget) { super.didUpdateWidget(oldWidget); @@ -100,6 +125,8 @@ class _RunDetailTabsState extends State { _tab = RunDetailTab.summary; _selectedStage = null; _selectedVisit = null; + _inputSection.collapse(); + _outputSection.collapse(); _applyInitialVisit(); } else if (!sameTarget) { // A route that names another stage or visit is applied to the same run. @@ -146,6 +173,53 @@ class _RunDetailTabsState extends State { } } + /// Selects the recorded visit a search result names, without presenting any + /// visit the run did not record. + /// + /// 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. + void _applySearchSelection() { + final scope = RunSearchSelectionScope.maybeOf(context); + final selection = scope?.selection; + if (scope == null || selection == null) { + _appliedSearchSelection = null; + return; + } + if (selection == _appliedSearchSelection) return; + 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); + final consumed = scope.onConsumed; + WidgetsBinding.instance.addPostFrameCallback((_) { + if (mounted) consumed(); + }); + } + + 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; + } + 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, /// so the detail stays where it is rather than fabricating a visit. void _openStage(String stageKey) { @@ -214,6 +288,8 @@ class _RunDetailTabsState extends State { copying: widget.copying, copyStatus: widget.copyStatus, onCopy: widget.onCopy, + inputController: _inputSection, + outputController: _outputSection, ); case RunDetailTab.graph: return RunGraphView( diff --git a/app/lib/features/runs/ui/run_search_selection.dart b/app/lib/features/runs/ui/run_search_selection.dart new file mode 100644 index 00000000..a4cfda2c --- /dev/null +++ b/app/lib/features/runs/ui/run_search_selection.dart @@ -0,0 +1,121 @@ +import 'package:flutter/widgets.dart'; + +import '../../../core/api_gateway.dart'; +import 'run_detail_visit_facts.dart'; + +/// A search hit's requested selection inside one run's detail. +/// +/// A recorded hit names only the run's own recorded [sequence] and, for a text +/// hit, the [field] it matched; the stage and timeline position are resolved +/// against the loaded detail, exactly as the browser client does. A request is +/// consumed once, so reopening the run later never replays it. +@immutable +class RunSearchSelection { + const RunSearchSelection({required this.runId, this.sequence, this.field}); + + final int runId; + + /// The server's recorded visit number, or null when the hit names no visit. + final int? sequence; + + /// The matched step field (`input`, `output`, …), or null for a visit hit. + final String? field; + + @override + bool operator ==(Object other) => + other is RunSearchSelection && + other.runId == runId && + other.sequence == sequence && + other.field == field; + + @override + int get hashCode => Object.hash(runId, sequence, field); +} + +/// 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; +} + +/// Resolves [selection] against the loaded [run], or null when the run recorded +/// nothing the request names. +/// +/// 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( + 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, + }; + } + 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); + } + return null; +} + +int? _sequence(JsonMap step) { + final value = step['sequence']; + final number = value is num ? value.toInt() : int.tryParse('${value ?? ''}'); + return number != null && number > 0 ? number : null; +} + +/// Carries the shell's one pending search request to the mounted run detail. +/// +/// The composition mounts it around the shell; [RunDetailTabs] reads it and +/// reports [onConsumed] once the request has been applied, so a later visit to +/// the same run starts plain. Keeping the request here means a field or artifact +/// hit needs no invented URL: the browser has no route for either selection. +class RunSearchSelectionScope extends InheritedWidget { + const RunSearchSelectionScope({ + super.key, + required this.selection, + required this.onConsumed, + required super.child, + }); + + final RunSearchSelection? selection; + final VoidCallback onConsumed; + + static RunSearchSelectionScope? maybeOf(BuildContext context) => + context.dependOnInheritedWidgetOfExactType(); + + @override + bool updateShouldNotify(RunSearchSelectionScope oldWidget) => + oldWidget.selection != selection || oldWidget.onConsumed != onConsumed; +} diff --git a/app/test/application/search_wiring_test.dart b/app/test/application/search_wiring_test.dart index 005b1479..20dfabb3 100644 --- a/app/test/application/search_wiring_test.dart +++ b/app/test/application/search_wiring_test.dart @@ -89,6 +89,68 @@ Future replyRunDetail( }, ); +Future replyRunDetailFor( + WidgetTester tester, + FakeChannel channel, + JsonMap detail, { + int index = 0, +}) => reply( + tester, + channel, + 'get_run', + index: index, + body: {'type': 'run', 'run_detail': detail}, +); + +/// A run whose recorded sequences are the search target's identity: a plan +/// visit 5 and a build visit 2, with run-level input and output sections. +JsonMap searchSelectionDetail() => { + 'id': 7, + 'title': 'Run 7', + 'status': 'succeeded', + 'input': {'prompt': 'ship it'}, + 'output': {'result': 'ok'}, + 'steps': [ + { + 'stage': 'plan', + 'sequence': 5, + 'status': 'completed', + 'outcome': 'success', + }, + { + 'stage': 'build', + 'sequence': 2, + 'status': 'completed', + 'outcome': 'success', + }, + ], +}; + +JsonMap artifactHit() => { + 'kind': 'artifact', + 'target': '/artifacts/7/2/report.txt', + 'artifact': { + 'run_id': 7, + 'sequence': 2, + 'name': 'report.txt', + 'content_type': 'text/plain', + 'size_bytes': 12, + 'url': '/artifacts/7/2/report.txt', + }, +}; + +JsonMap fieldHit() => { + 'kind': 'field', + 'target': 'run:7:5:output', + 'matched_field': 'output', + 'field': { + 'run_id': 7, + 'sequence': 5, + 'field': 'output', + 'snippet': 'release', + }, +}; + JsonMap runHit(int id) => { 'kind': 'run', 'target': 'run:$id', @@ -285,6 +347,174 @@ void main() { await tester.pump(); }); + testWidgets('field and artifact hits select their run detail selection', ( + 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/7')), + ); + addTearDown(provider.dispose); + + await pumpApp( + tester, + channel: channel, + client: client, + provider: provider, + cupertino: false, + ); + await replyRunList(tester, channel); + await replyRunDetailFor(tester, channel, searchSelectionDetail()); + expect(find.text('Run 7'), findsWidgets); + + Future sendSearch({ + required String query, + required int index, + required JsonMap hit, + }) 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')), query); + 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': query, + 'kind': '', + 'results': [hit], + 'truncated': false, + 'scanned_steps': 2, + 'scanned_bytes': 64, + 'cap': 50, + 'scan_bound_bytes': 1 << 20, + }, + }), + ); + await tester.pump(); + await tester.pump(); + } + + // An artifact hit opens the run and selects the visit that recorded it. + await sendSearch(query: 'report', index: 0, hit: artifactHit()); + 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)); + + expect(provider.value.uri.path, '/runs/7'); + expect(find.byType(SearchScreen), findsNothing); + 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()); + await tester.tap( + find.byKey(const ValueKey('search.result.run:7:5:output')), + ); + 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.textContaining('"result": "ok"'), findsOneWidget); + + await tester.pumpWidget(const SizedBox.shrink()); + await tester.pump(); + }); + + testWidgets('an artifact hit selects its visit after the run detail loads', ( + 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 replyRunList(tester, channel); + + 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'); + 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(); + + 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)); + expect(provider.value.uri.path, '/runs/7'); + + // The run detail is still loading when the request arrives; the selection + // is applied by the detail that mounts from this reply. + await replyRunDetailFor(tester, channel, searchSelectionDetail(), index: 0); + await tester.pumpAndSettle(); + + expect(find.byKey(const Key('run-visit-pane')), findsOneWidget); + expect(find.text('build · visit 2'), 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; diff --git a/app/test/features/runs/ui/run_search_selection_test.dart b/app/test/features/runs/ui/run_search_selection_test.dart new file mode 100644 index 00000000..09a6d76d --- /dev/null +++ b/app/test/features/runs/ui/run_search_selection_test.dart @@ -0,0 +1,174 @@ +import 'package:flutter/cupertino.dart'; +import 'package:flutter/material.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:pipelines_app/core/api_gateway.dart'; +import 'package:pipelines_app/features/runs/data/runs_repository.dart'; +import 'package:pipelines_app/features/runs/ui/run_detail_view.dart'; +import 'package:pipelines_app/features/runs/ui/run_search_selection.dart'; +import 'package:pipelines_app/features/runs/ui/runs_controller.dart'; + +import 'run_detail_graph_support.dart'; + +/// plan visits 5 and 1 around one build visit 2: the server's sequence is not +/// the step's row index, so resolution must read the recorded sequence. +JsonMap searchSelectionRun() => { + 'id': 77, + 'title': 'Search selection run', + 'name': 'release', + 'status': 'succeeded', + 'input': {'prompt': 'ship it'}, + 'output': {'result': 'ok'}, + 'steps': [ + { + 'stage': 'plan', + 'sequence': 5, + 'status': 'completed', + 'outcome': 'success', + }, + { + 'stage': 'build', + 'sequence': 2, + 'status': 'completed', + 'outcome': 'success', + }, + { + 'stage': 'plan', + 'sequence': 1, + 'status': 'completed', + 'outcome': 'success', + }, + ], +}; + +Future pumpSelection( + WidgetTester tester, + RunDetailTestPlatform platform, + RunSearchSelection selection, { + VoidCallback? onConsumed, +}) async { + tester.view.physicalSize = const Size(900, 1000); + tester.view.devicePixelRatio = 1; + addTearDown(tester.view.reset); + final gateway = RunDetailFakeGateway(searchSelectionRun()); + final controller = RunsController(RunsRepository(gateway)); + addTearDown(controller.dispose); + await controller.select(77); + final page = MediaQuery( + data: MediaQueryData.fromView(tester.view), + child: RunSearchSelectionScope( + selection: selection, + onConsumed: onConsumed ?? () {}, + child: RunDetailView( + controller: controller, + gateway: gateway, + onBack: () {}, + ), + ), + ); + await tester.pumpWidget(const SizedBox.shrink()); + await tester.pumpWidget( + platform == RunDetailTestPlatform.material + ? MaterialApp(home: Scaffold(body: page)) + : CupertinoApp( + home: CupertinoPageScaffold(child: SafeArea(child: page)), + ), + ); + await tester.pumpAndSettle(); +} + +void main() { + for (final platform in RunDetailTestPlatform.values) { + testWidgets('${platform.name} artifact hit opens its recorded visit', ( + tester, + ) async { + await pumpSelection( + tester, + platform, + const RunSearchSelection(runId: 77, sequence: 2), + ); + + expect(find.byKey(const Key('run-visit-pane')), findsOneWidget); + expect(find.text('build · visit 2'), findsOneWidget); + }); + } + + testWidgets('an unknown artifact sequence opens the plain run', ( + tester, + ) async { + await pumpSelection( + tester, + RunDetailTestPlatform.material, + const RunSearchSelection(runId: 77, sequence: 99), + ); + + expect(find.byKey(const Key('run-visit-pane')), findsNothing); + expect( + find.byKey(const Key('run-detail-tab-body-summary')), + findsOneWidget, + ); + }); + + 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', ( + 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); + }); + } + + testWidgets('a retired field opens the plain Summary', (tester) async { + await pumpSelection( + tester, + RunDetailTestPlatform.material, + const RunSearchSelection(runId: 77, sequence: 5, field: 'evidence'), + ); + + 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 { + var consumed = 0; + await pumpSelection( + tester, + RunDetailTestPlatform.material, + const RunSearchSelection(runId: 77, sequence: 2), + onConsumed: () => consumed++, + ); + + expect(find.byKey(const Key('run-visit-pane')), findsOneWidget); + expect(consumed, 1); + }); +}