From 151d99fbb639ba2ef4d0d2af2edda528ff4b07be Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Sun, 8 Nov 2026 01:04:00 +0000 Subject: [PATCH] Persist exact tab locations including Settings under Pipelines --- app/lib/application/app_router.dart | 10 + app/lib/application/pipelines_app.dart | 98 +++++-- app/lib/application/tab_location_routes.dart | 17 ++ app/lib/application/tab_locations.dart | 77 ++++++ app/lib/application/tab_locations_store.dart | 83 ++++++ app/lib/shell/adaptive_shell.dart | 11 +- app/notes/persistent-tab-locations.md | 39 +++ app/test/application/app_router_test.dart | 16 ++ .../tab_location_navigation_test.dart | 202 ++++++++++++++ app/test/application/tab_locations_test.dart | 250 ++++++++++++++++++ 10 files changed, 778 insertions(+), 25 deletions(-) create mode 100644 app/lib/application/tab_location_routes.dart create mode 100644 app/lib/application/tab_locations.dart create mode 100644 app/lib/application/tab_locations_store.dart create mode 100644 app/notes/persistent-tab-locations.md create mode 100644 app/test/application/tab_location_navigation_test.dart create mode 100644 app/test/application/tab_locations_test.dart diff --git a/app/lib/application/app_router.dart b/app/lib/application/app_router.dart index f7fec32d..d9e2f23e 100644 --- a/app/lib/application/app_router.dart +++ b/app/lib/application/app_router.dart @@ -200,12 +200,14 @@ class AppRouterDelegate extends RouterDelegate with ChangeNotifier { @override Future setInitialRoutePath(AppRoute configuration) async { + _rememberParent(configuration); _route = configuration; } @override Future setNewRoutePath(AppRoute configuration) async { if (configuration == _route) return; + _rememberParent(configuration); _route = configuration; notifyListeners(); } @@ -217,10 +219,18 @@ class AppRouterDelegate extends RouterDelegate with ChangeNotifier { Future popRoute() async => await _navigatorKey.currentState?.maybePop() ?? false; + void _rememberParent(AppRoute route) { + if (route.kind == AppRouteKind.templates || + route.kind == AppRouteKind.schedules) { + _templatesReturn = AppRoute.settings; + } + } + /// Records a user move; the Router turns the new configuration into a /// history entry (or a replacement when it already matches the location). void goTo(AppRoute route) { if (route == _route) return; + _rememberParent(route); _route = route; notifyListeners(); } diff --git a/app/lib/application/pipelines_app.dart b/app/lib/application/pipelines_app.dart index a5463d10..cbda6a00 100644 --- a/app/lib/application/pipelines_app.dart +++ b/app/lib/application/pipelines_app.dart @@ -40,6 +40,8 @@ import 'schedules_destination.dart'; import 'search_destination.dart'; import 'server_endpoint.dart'; import 'templates_destination.dart'; +import 'tab_locations.dart'; +import 'tab_locations_store.dart'; /// The application's return-to-foreground policy for the shared socket. /// @@ -76,8 +78,10 @@ class PipelinesApp extends StatefulWidget { this.androidFeedReader = fetchLatestUpdate, this.androidInstaller = downloadAndInstall, this.webRefresher = refreshWebPage, + this.tabLocationsStore, }); + final TabLocationsStore? tabLocationsStore; final ServerEndpoint server; final PipelinesClient? client; final bool? cupertino; @@ -219,6 +223,19 @@ class _PipelinesAppState extends State // a dropped or unknown query is canonicalised away. final location = routeLocation(_provider.value.uri); final initial = AppRoute.parse(location); + final nativeDefault = + widget.routeInformationProvider == null && + !kIsWeb && + const [ + '', + '/', + ].contains(WidgetsBinding.instance.platformDispatcher.defaultRouteName); + final restoreTab = !widget.resetRoute && (location == '/' || nativeDefault); + _tabLocations = TabLocations( + widget.tabLocationsStore ?? + SharedPreferencesTabLocationsStore(scope: _navigationScope), + ); + _tabLocations.record(initial, visited: !restoreTab); if (location != initial.path) { _provider.routerReportsNewRouteInformation( RouteInformation(uri: Uri.parse(initial.path)), @@ -248,7 +265,9 @@ class _PipelinesAppState extends State ); _delegate.addListener(_routeChanged); // Seed retained destinations for deep links as well as later navigation. - _routeChanged(); + _rememberChatRoute(initial); + _rememberBodyRoute(_delegate.shellRoute); + unawaited(_restoreTabLocations(restoreTab)); _chatQuestionNotices = ChatQuestionNotices( gateway: _session.gateway, canNotify: () => _notifications.canNotify, @@ -344,6 +363,7 @@ class _PipelinesAppState extends State @override void dispose() { + _tabLocations.dispose(); WidgetsBinding.instance.removeObserver(this); _deliveryHandoff?.dispose(); _session.removeListener(_attentionSessionChanged); @@ -502,21 +522,49 @@ 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. - /// The last route each tab showed, so switching tabs returns to where the - /// operator left it; tapping the open tab again goes to its root. - final Map _tabRoutes = {}; + /// The last location within each tab, including Settings under Pipelines. + /// Explicit Back is separate from tab selection and same-tab retaps. + String get _navigationScope => + widget.serverId ?? widget.server.uri?.toString() ?? ''; + + late final TabLocations _tabLocations; + Map get _tabRoutes => _tabLocations.routes; + // A Settings visit owns the Pipelines tab's return location, but must not + // clear the still-mounted Pipelines body's selection or editor underneath. + final _bodyRoutes = {}; + + void _rememberBodyRoute(AppRoute route) { + _bodyRoutes[_destinationOf(route.kind)] = route; + } + + Future _restoreTabLocations(bool restoreActive) async { + final revision = _tabLocations.revision; + final restored = await _tabLocations.restore(restoreActive: restoreActive); + if (!mounted) return; + // The Router first consumes its boot URL. Apply saved navigation afterward, + // and never jump over a user move that happened while preferences loaded. + WidgetsBinding.instance.addPostFrameCallback((_) { + if (!mounted) return; + if (restored != null && revision == _tabLocations.revision) { + _delegate.goTo(restored); + } else { + setState(() {}); + } + }); + WidgetsBinding.instance.ensureVisualUpdate(); + } + + void _rememberChatRoute(AppRoute route) { + if (route.kind == AppRouteKind.chat && route.chatSessionId != null) { + _chatWorkspaceRoute = route; + } + } + AppRoute? _chatWorkspaceRoute; Set? _availableChatSessionIds; void _selectDestination(AppDestination destination) { - final current = _destinationOf(_delegate.shellRoute.kind); + final current = tabForRoute(_delegate.route); final last = _tabRoutes[destination]; if (destination == AppDestination.chat && current == destination) { final reopened = chatRouteForRetap( @@ -529,17 +577,14 @@ class _PipelinesAppState extends State _delegate.goTo(reopened ?? _routeOf(destination)); return; } - _delegate.goTo( - destination == current || last == null ? _routeOf(destination) : last, - ); + _delegate.goTo(last ?? _routeOf(destination)); } void _routeChanged() { - final shown = _delegate.shellRoute; - _tabRoutes[_destinationOf(shown.kind)] = shown; - if (shown.kind == AppRouteKind.chat && shown.chatSessionId != null) { - _chatWorkspaceRoute = shown; - } + final shown = _delegate.route; + _tabLocations.record(shown); + _rememberBodyRoute(_delegate.shellRoute); + _rememberChatRoute(shown); final pending = _pendingRunSearch; if (!mounted || pending == null) return; final route = _delegate.shellRoute; @@ -603,10 +648,14 @@ class _PipelinesAppState extends State Widget _shellFor(AppRoute route, int attentionCount) { // Each tab is built from the route it last showed, so switching tabs keeps // an open run, pipeline or chat instead of resetting it. - AppRoute tab(AppDestination destination) => - _destinationOf(route.kind) == destination - ? route - : _tabRoutes[destination] ?? _routeOf(destination); + AppRoute tab(AppDestination destination) { + if (_destinationOf(route.kind) == destination) return route; + final saved = _tabRoutes[destination]; + return saved != null && _destinationOf(saved.kind) == destination + ? saved + : _bodyRoutes[destination] ?? _routeOf(destination); + } + final pipelinesRoute = tab(AppDestination.pipelines); final runsRoute = tab(AppDestination.runs); final chatRoute = tab(AppDestination.chat); @@ -615,6 +664,7 @@ class _PipelinesAppState extends State cupertino: _cupertino, destination: _destinationOf(route.kind), onDestinationSelected: _selectDestination, + onClosePage: () => _delegate.goTo(AppRoute.pipelines), destinationBodies: { AppDestination.pipelines: (_) => PipelinesDestination( session: _session, diff --git a/app/lib/application/tab_location_routes.dart b/app/lib/application/tab_location_routes.dart new file mode 100644 index 00000000..59a3e867 --- /dev/null +++ b/app/lib/application/tab_location_routes.dart @@ -0,0 +1,17 @@ +import '../shell/destination.dart'; +import 'app_route.dart'; + +/// Settings and its pages occupy the Pipelines tab, not an independent tab. +AppDestination tabForRoute(AppRoute route) => switch (route.kind) { + AppRouteKind.pipelines || + AppRouteKind.settings || + AppRouteKind.templates || + AppRouteKind.schedules => AppDestination.pipelines, + AppRouteKind.runs => AppDestination.runs, + AppRouteKind.chat => AppDestination.chat, + AppRouteKind.search => AppDestination.search, +}; + +/// Remembers navigation without retaining modal actions such as run decisions. +AppRoute durableTabRoute(AppRoute route) => + route.decide ? AppRoute.run(route.runId!) : route; diff --git a/app/lib/application/tab_locations.dart b/app/lib/application/tab_locations.dart new file mode 100644 index 00000000..bdc1ed91 --- /dev/null +++ b/app/lib/application/tab_locations.dart @@ -0,0 +1,77 @@ +import 'dart:async'; + +import '../shell/destination.dart'; +import 'app_route.dart'; +import 'tab_locations_store.dart'; +import 'tab_location_routes.dart'; + +export 'tab_location_routes.dart'; + +class TabLocations { + TabLocations(this.store); + final TabLocationsStore store; + final routes = {}; + final _touched = {}; + AppDestination active = AppDestination.pipelines; + int revision = 0; + bool _loaded = false; + bool _disposed = false; + bool persistenceFailed = false; + Future _writes = Future.value(); + + void record(AppRoute route, {bool visited = true}) { + if (_disposed) return; + active = tabForRoute(route); + routes[active] = route; + if (visited) { + _touched.add(active); + revision++; + } + if (_loaded) _save(); + } + + /// Slow storage never overwrites navigation made while it was loading. + Future restore({required bool restoreActive}) async { + TabLocationsSnapshot saved; + try { + saved = await store.load(); + } catch (_) { + // Keep in-memory navigation, but never overwrite unread stored history. + persistenceFailed = true; + return null; + } + if (_disposed) return null; + for (final entry in saved.routes.entries) { + if (!_touched.contains(entry.key)) routes[entry.key] = entry.value; + } + AppRoute? restored; + if (restoreActive && _touched.isEmpty) { + active = saved.active; + restored = routes[active]; + } + _loaded = true; + _save(); + return restored; + } + + void _save() { + final snapshot = TabLocationsSnapshot( + active: active, + routes: { + for (final entry in routes.entries) + entry.key: durableTabRoute(entry.value), + }, + ); + _writes = _writes.then((_) async { + try { + persistenceFailed = !await store.save(snapshot); + } catch (_) { + persistenceFailed = true; + } + }); + } + + void dispose() => _disposed = true; + + Future get settled => _writes; +} diff --git a/app/lib/application/tab_locations_store.dart b/app/lib/application/tab_locations_store.dart new file mode 100644 index 00000000..cfe02e62 --- /dev/null +++ b/app/lib/application/tab_locations_store.dart @@ -0,0 +1,83 @@ +import 'dart:convert'; + +import 'package:shared_preferences/shared_preferences.dart'; + +import '../core/servers/server_scope.dart'; +import '../shell/destination.dart'; +import 'app_route.dart'; +import 'tab_location_routes.dart'; + +class TabLocationsSnapshot { + const TabLocationsSnapshot({ + this.active = AppDestination.pipelines, + this.routes = const {}, + }); + final AppDestination active; + final Map routes; + + Map toJson() => { + 'version': 1, + 'active': active.name, + 'routes': { + for (final entry in routes.entries) entry.key.name: entry.value.path, + }, + }; + + static TabLocationsSnapshot decode(String? encoded) { + if (encoded == null) return const TabLocationsSnapshot(); + try { + final data = jsonDecode(encoded); + if (data is! Map || data['version'] != 1 || data['routes'] is! Map) { + return const TabLocationsSnapshot(); + } + final routes = {}; + for (final entry in (data['routes'] as Map).entries) { + final tab = shellTabDestinations + .where((tab) => tab.name == entry.key) + .firstOrNull; + final path = entry.value; + if (tab == null || path is! String || !path.startsWith('/')) continue; + final route = AppRoute.parse(path); + if (route.path != path || tabForRoute(route) != tab) continue; + routes[tab] = durableTabRoute(route); + } + final active = + shellTabDestinations + .where((tab) => tab.name == data['active']) + .firstOrNull ?? + AppDestination.pipelines; + return TabLocationsSnapshot(active: active, routes: routes); + } on FormatException { + return const TabLocationsSnapshot(); + } + } +} + +abstract interface class TabLocationsStore { + Future load(); + Future save(TabLocationsSnapshot value); +} + +class SharedPreferencesTabLocationsStore implements TabLocationsStore { + const SharedPreferencesTabLocationsStore({required this.scope}); + final String scope; + String get key => scopedServerKey('pipelines.next.tabLocations.v1', scope); + + @override + Future load() async { + // Throw on an unreadable store: the controller then preserves stored data + // rather than mistaking it for absent history and writing a partial map. + final preferences = await SharedPreferences.getInstance(); + return TabLocationsSnapshot.decode(preferences.getString(key)); + } + + @override + Future save(TabLocationsSnapshot value) async { + try { + final preferences = await SharedPreferences.getInstance(); + return await preferences.setString(key, jsonEncode(value.toJson())); + } catch (_) { + return false; + } + } +} diff --git a/app/lib/shell/adaptive_shell.dart b/app/lib/shell/adaptive_shell.dart index fa08a590..45b2d4c6 100644 --- a/app/lib/shell/adaptive_shell.dart +++ b/app/lib/shell/adaptive_shell.dart @@ -21,6 +21,7 @@ class AdaptiveShell extends StatefulWidget { this.cupertino = false, this.destination, this.onDestinationSelected, + this.onClosePage, this.onSearch, this.attentionCount = 0, this.listPaneWidthStore = const SharedPreferencesListPaneWidthStore(), @@ -36,6 +37,7 @@ class AdaptiveShell extends StatefulWidget { /// selection, which preserves the plain-shell tests and native composition. final AppDestination? destination; final ValueChanged? onDestinationSelected; + final VoidCallback? onClosePage; /// Opens the transient Search page. Null hides the action, so the plain /// shell tests and compositions without routing keep their tab set only. @@ -265,7 +267,14 @@ class _AdaptiveShellState extends State { } /// Leaves a page destination (Settings) for the tab it belongs to. - void _closePage() => _select(shellTabFor(_selected)); + void _closePage() { + final close = widget.onClosePage; + if (close != null) { + close(); + } else { + _select(shellTabFor(_selected)); + } + } /// The system Back the shell handles: it closes a page, or else returns to /// the previous tab unless the open item's own pane closes a page first. diff --git a/app/notes/persistent-tab-locations.md b/app/notes/persistent-tab-locations.md new file mode 100644 index 00000000..c386dc5c --- /dev/null +++ b/app/notes/persistent-tab-locations.md @@ -0,0 +1,39 @@ +# Persistent tab locations + +Settings, Templates and Schedules belong to the Pipelines tab. Selecting another +main tab and returning restores that tab's last canonical route, including +Settings. Same-tab selection preserves the current location; explicit Back +still exits Settings. The existing Chats retap-to-workspace behavior remains. + +The owning tab's return route is separate from each mounted body's runtime +route, so visiting Settings does not clear a hidden Pipelines detail/editor. +Settings State stays mounted when switching tabs. Restored Templates/Schedules +always retain Settings as their parent. + +A scoped SharedPreferences snapshot records per-tab routes and the last active +tab. Logical server identity is the scope; an endpoint is used only when there +is no identity. Ordinary `/` / native-default launches can restore the active +location; explicit launch URLs, including `/pipelines`, take priority. Pipeline +versions/stages, run visits/filters and chat IDs survive canonical serialization; +run decision actions are omitted from durable storage. + +Storage loading never saves a partial default map. User-touched slots win over +a slow load, untouched slots merge, and writes serialize so the final move wins. +Unreadable history remains untouched, write failures do not poison subsequent +saves, and disposing the app cancels late read-back persistence. Navigation +stays responsive throughout. + +Focused acceptance: 40 tests passed across tab locations, full-app navigation, +router, Settings Back and existing Chats retap (`/tmp/memwatch/out.A1UrLy`). +The subsequent disposal regression and navigation cases passed (16 cases, +`/tmp/memwatch/out.eUiZcl`), bringing distinct covered cases to 41. +Analyzer clean (`flutter-analyze.Klkp0D`). Full-app tests cover both native hosts, +exact Pipelines → Settings → Chat → Pipelines restoration with identical +Settings State, explicit Back, preserved hidden Pipelines selection, actual app +recreation via SharedPreferences, explicit URL priority and delayed load races. + +This change persists route locations; arbitrary dialogs, unsaved editor content +and scroll offsets are not serialized by this store. Their existing mounted +state remains intact within a session. Settings inner-topic persistence is a +separate companion change. Manager-owned integrated browser capture/build and +publication are still required; this lane did not deploy or restart anything. diff --git a/app/test/application/app_router_test.dart b/app/test/application/app_router_test.dart index cf75e59b..ca92f80a 100644 --- a/app/test/application/app_router_test.dart +++ b/app/test/application/app_router_test.dart @@ -36,6 +36,22 @@ Future pumpRouter( } void main() { + test( + 'restoring Settings subpages from another tab preserves their parent', + () async { + final router = delegate(AppRoute.chat); + addTearDown(router.dispose); + router.goTo(AppRoute.template('release')); + expect(router.shellRoute, AppRoute.settings); + router.closeTemplates(); + expect(router.route, AppRoute.settings); + router.goTo(AppRoute.chat); + await router.setNewRoutePath(AppRoute.schedules); + expect(router.shellRoute, AppRoute.settings); + router.closeSchedules(); + expect(router.route, AppRoute.settings); + }, + ); TestWidgetsFlutterBinding.ensureInitialized(); test('with nothing pushed the router leaves Back to the platform', () async { for (final route in [ diff --git a/app/test/application/tab_location_navigation_test.dart b/app/test/application/tab_location_navigation_test.dart new file mode 100644 index 00000000..8cb7cb77 --- /dev/null +++ b/app/test/application/tab_location_navigation_test.dart @@ -0,0 +1,202 @@ +import 'dart:async'; + +import 'package:flutter/material.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:shared_preferences/shared_preferences.dart'; +import 'package:pipelines_app/application/app_route.dart'; +import 'package:pipelines_app/application/pipelines_app.dart'; +import 'package:pipelines_app/application/tab_locations_store.dart'; +import 'package:pipelines_app/core/transport/pipelines_client.dart'; +import 'package:pipelines_app/features/settings/settings_screen.dart'; +import 'package:pipelines_app/features/pipelines/screen.dart'; +import 'package:pipelines_app/shell/destination.dart'; + +import '../bar_action.dart'; +import '../core/transport/pipelines_client_test.dart' show FakeChannel; +import '../features/pipelines/fixtures.dart'; +import 'pipelines_app_test.dart' show webServer; +import 'pipelines_replies.dart'; +import 'tab_locations_test.dart' show MemoryTabLocationsStore; + +Future<({PlatformRouteInformationProvider provider, FakeChannel channel})> +mount( + WidgetTester tester, { + String route = '/pipelines', + bool cupertino = false, + TabLocationsStore? store, +}) async { + tester.view.physicalSize = const Size(560, 1000); + tester.view.devicePixelRatio = 1; + addTearDown(tester.view.reset); + final channel = FakeChannel()..readyCompleter.complete(); + final client = PipelinesClient(channelFactory: (_) => channel); + final provider = PlatformRouteInformationProvider( + initialRouteInformation: RouteInformation(uri: Uri.parse(route)), + ); + addTearDown(provider.dispose); + addTearDown(client.dispose); + await tester.pumpWidget( + PipelinesApp( + server: webServer(), + client: client, + cupertino: cupertino, + serverId: 'navigation-test', + routeInformationProvider: provider, + tabLocationsStore: store, + ), + ); + await tester.pump(); + await tester.pump(const Duration(milliseconds: 500)); + return (provider: provider, channel: channel); +} + +Future tab(WidgetTester tester, String name) async { + await tester.tap(find.byKey(ValueKey('shell.destination.$name'))); + await tester.pump(); + await tester.pump(const Duration(milliseconds: 500)); +} + +void main() { + setUp(() => SharedPreferences.setMockInitialValues({})); + for (final cupertino in [false, true]) { + testWidgets( + 'Settings is retained inside Pipelines across tab switches ($cupertino)', + (tester) async { + final app = await mount(tester, cupertino: cupertino); + await replyPipelines(tester, app.channel, PipelineFixture()); + await tester.pumpAndSettle(); + await tapBarAction( + tester, + find.byKey(const Key('pipelines-open-settings')), + 'Settings', + ); + await tester.pumpAndSettle(); + expect(app.provider.value.uri.path, '/settings'); + final settingsState = tester.state(find.byType(SettingsScreen)); + await tab(tester, 'chat'); + expect(app.provider.value.uri.path, '/chat'); + await tab(tester, 'pipelines'); + expect(app.provider.value.uri.path, '/settings'); + expect(tester.state(find.byType(SettingsScreen)), same(settingsState)); + await tab(tester, 'pipelines'); + expect( + app.provider.value.uri.path, + '/settings', + reason: 'tab retap is not Back', + ); + await tester.tap(find.byKey(const ValueKey('shell.back'))); + await tester.pump(); + await tester.pump(const Duration(milliseconds: 500)); + expect( + app.provider.value.uri.path, + '/pipelines', + reason: 'explicit Back still exits Settings', + ); + expect(tester.takeException(), isNull); + }, + ); + } + testWidgets( + 'per-tab locations survive app recreation; an explicit deep link wins', + (tester) async { + final first = await mount(tester, route: '/settings'); + await tester.pumpAndSettle(); + expect(first.provider.value.uri.path, '/settings'); + await tester.pumpWidget(const SizedBox.shrink()); + await tester.pump(); + final restored = await mount(tester, route: '/'); + await tester.pumpAndSettle(); + expect(restored.provider.value.uri.path, '/settings'); + expect(find.byType(SettingsScreen), findsOneWidget); + await tester.pumpWidget(const SizedBox.shrink()); + await tester.pump(); + final linked = await mount(tester, route: '/runs/8/stage/plan?visit=2'); + expect( + linked.provider.value.uri.toString(), + '/runs/8/stage/plan?visit=2', + ); + await tab(tester, 'chat'); + await tab(tester, 'runs'); + expect( + linked.provider.value.uri.toString(), + '/runs/8/stage/plan?visit=2', + ); + await tab(tester, 'pipelines'); + expect(linked.provider.value.uri.path, '/settings'); + expect(tester.takeException(), isNull); + }, + ); + testWidgets( + 'a delayed read merges locations without redirecting a user move', + (tester) async { + final store = MemoryTabLocationsStore()..read = Completer(); + final app = await mount(tester, route: '/', store: store); + await tab(tester, 'chat'); + expect(store.writes, isEmpty); + store.read!.complete( + const TabLocationsSnapshot( + active: AppDestination.pipelines, + routes: {AppDestination.pipelines: AppRoute.settings}, + ), + ); + await tester.pump(); + await tester.pump(const Duration(milliseconds: 500)); + expect(app.provider.value.uri.path, '/chat'); + await tab(tester, 'pipelines'); + expect(app.provider.value.uri.path, '/settings'); + expect(tester.takeException(), isNull); + }, + ); + testWidgets('an explicit root URL does not restore a different active tab', ( + tester, + ) async { + final store = MemoryTabLocationsStore() + ..value = TabLocationsSnapshot( + active: AppDestination.runs, + routes: { + AppDestination.runs: AppRoute.run(9), + AppDestination.pipelines: AppRoute.settings, + }, + ); + final app = await mount(tester, route: '/pipelines', store: store); + expect(app.provider.value.uri.path, '/pipelines'); + await tab(tester, 'runs'); + expect(app.provider.value.uri.path, '/runs/9'); + await tab(tester, 'pipelines'); + expect(app.provider.value.uri.path, '/pipelines'); + expect(tester.takeException(), isNull); + }); + testWidgets('Settings does not clear the mounted Pipelines detail', ( + tester, + ) async { + final app = await mount(tester); + tester.view.physicalSize = const Size(1100, 1000); + await tester.pump(); + final fixture = PipelineFixture(); + await replyPipelines(tester, app.channel, fixture); + await tester.pumpAndSettle(); + await tester.tap(find.byKey(const Key('pipeline-row-1'))); + await tester.pump(); + await replyPipelineDetail(tester, app.channel, fixture); + await tester.pumpAndSettle(); + expect(app.provider.value.uri.path, '/pipelines/1'); + final before = tester.widget(find.byType(PipelinesScreen)); + expect(before.initialPipelineId, 1); + final pipelineState = tester.state(find.byType(PipelinesScreen)); + await tapBarAction( + tester, + find.byKey(const Key('pipelines-open-settings')), + 'Settings', + ); + await tester.pumpAndSettle(); + expect(app.provider.value.uri.path, '/settings'); + final hidden = find.byType(PipelinesScreen, skipOffstage: false); + expect(tester.widget(hidden).initialPipelineId, 1); + expect(tester.state(hidden), same(pipelineState)); + await tab(tester, 'chat'); + await tab(tester, 'pipelines'); + expect(app.provider.value.uri.path, '/settings'); + expect(tester.widget(hidden).initialPipelineId, 1); + expect(tester.takeException(), isNull); + }); +} diff --git a/app/test/application/tab_locations_test.dart b/app/test/application/tab_locations_test.dart new file mode 100644 index 00000000..bda7dfb1 --- /dev/null +++ b/app/test/application/tab_locations_test.dart @@ -0,0 +1,250 @@ +import 'dart:async'; +import 'dart:convert'; + +import 'package:flutter_test/flutter_test.dart'; +import 'package:shared_preferences/shared_preferences.dart'; +import 'package:pipelines_app/application/app_route.dart'; +import 'package:pipelines_app/application/tab_locations.dart'; +import 'package:pipelines_app/application/tab_locations_store.dart'; +import 'package:pipelines_app/shell/destination.dart'; + +class MemoryTabLocationsStore implements TabLocationsStore { + TabLocationsSnapshot value = const TabLocationsSnapshot(); + Completer? read; + final writes = []; + Completer? write; + @override + Future load() async => + read == null ? value : read!.future; + @override + Future save(TabLocationsSnapshot snapshot) async { + writes.add(snapshot); + if (write case final pending?) { + write = null; + await pending.future; + } + value = snapshot; + return true; + } +} + +class UnreadableTabLocationsStore extends MemoryTabLocationsStore { + @override + Future load() async => throw StateError('unavailable'); +} + +class FailingTabLocationsStore extends MemoryTabLocationsStore { + bool fails = true; + @override + Future save(TabLocationsSnapshot snapshot) async { + if (fails) { + fails = false; + throw StateError('temporary write failure'); + } + return super.save(snapshot); + } +} + +void main() { + TestWidgetsFlutterBinding.ensureInitialized(); + test('Settings and nested pages retain Pipelines ownership', () async { + final store = MemoryTabLocationsStore(); + final tabs = TabLocations(store); + tabs.record(AppRoute.settings); + tabs.record(AppRoute.chat); + await tabs.restore(restoreActive: false); + await tabs.settled; + expect(tabs.routes[AppDestination.pipelines], AppRoute.settings); + expect(tabs.routes[AppDestination.chat], AppRoute.chat); + expect(store.value.routes[AppDestination.pipelines], AppRoute.settings); + tabs.record(AppRoute.template('release')); + await tabs.settled; + expect( + store.value.routes[AppDestination.pipelines], + AppRoute.template('release'), + ); + }); + test('canonical details survive serialization, decisions do not replay', () { + final snapshot = TabLocationsSnapshot.decode( + jsonEncode({ + 'version': 1, + 'active': 'runs', + 'routes': { + 'pipelines': '/pipelines/7/3/stage/build', + 'runs': '/runs/8/stage/review?visit=2', + 'chat': '/chat/session-2', + 'search': '/search', + }, + }), + ); + expect( + snapshot.routes[AppDestination.runs], + AppRoute.run.stage(8, 'review', visit: 2), + ); + expect( + snapshot.routes[AppDestination.pipelines], + AppRoute.pipelineStage(7, 'build', version: 3), + ); + expect( + TabLocationsSnapshot.decode( + jsonEncode({ + 'version': 1, + 'routes': {'runs': '/runs/8?action=decide'}, + }), + ).routes[AppDestination.runs], + AppRoute.run(8), + ); + }); + test('malformed, cross-owner and external stored routes are ignored', () { + for (final value in ['no json', '[]', '{"version":2,"routes":{}}']) { + expect(TabLocationsSnapshot.decode(value).routes, isEmpty); + } + final saved = TabLocationsSnapshot.decode( + jsonEncode({ + 'version': 1, + 'routes': { + 'runs': '/settings', + 'pipelines': 'https://example.com/settings', + 'chat': '/chat/invalid/id', + 'settings': '/settings', + 'search': '/unknown', + }, + }), + ); + expect(saved.routes, isEmpty); + }); + test( + 'delayed restore merges untouched tabs but never overwrites user navigation', + () async { + final store = MemoryTabLocationsStore()..read = Completer(); + final tabs = TabLocations(store) + ..record(AppRoute.pipelines, visited: false); + final restoring = tabs.restore(restoreActive: true); + tabs.record(AppRoute.run(12)); + expect( + store.writes, + isEmpty, + reason: 'never erase storage before reading it', + ); + store.read!.complete( + TabLocationsSnapshot( + active: AppDestination.pipelines, + routes: { + AppDestination.pipelines: AppRoute.settings, + AppDestination.runs: AppRoute.run(5), + }, + ), + ); + expect(await restoring, isNull); + await tabs.settled; + expect(tabs.routes[AppDestination.runs], AppRoute.run(12)); + expect(tabs.routes[AppDestination.pipelines], AppRoute.settings); + expect(store.value.active, AppDestination.runs); + }, + ); + test( + 'ordinary boot restores active location; explicit boot wins its slot', + () async { + final store = MemoryTabLocationsStore() + ..value = const TabLocationsSnapshot( + active: AppDestination.pipelines, + routes: {AppDestination.pipelines: AppRoute.settings}, + ); + final ordinary = TabLocations(store) + ..record(AppRoute.pipelines, visited: false); + expect(await ordinary.restore(restoreActive: true), AppRoute.settings); + await ordinary.settled; + final explicit = TabLocations(store) + ..record(AppRoute.pipeline(3, version: 2)); + expect(await explicit.restore(restoreActive: false), isNull); + expect( + explicit.routes[AppDestination.pipelines], + AppRoute.pipeline(3, version: 2), + ); + await explicit.settled; + }, + ); + test( + 'writes serialize and last move wins even with a slow first write', + () async { + final first = Completer(); + final store = MemoryTabLocationsStore()..write = first; + final tabs = TabLocations(store)..record(AppRoute.settings); + await tabs.restore(restoreActive: false); + await Future.delayed(Duration.zero); + tabs.record(AppRoute.chat); + tabs.record(AppRoute.run(9)); + expect(store.writes, hasLength(1)); + first.complete(true); + await tabs.settled; + expect(store.value.active, AppDestination.runs); + expect(store.value.routes[AppDestination.pipelines], AppRoute.settings); + expect(store.value.routes[AppDestination.runs], AppRoute.run(9)); + }, + ); + test( + 'SharedPreferences survives recreation and isolates logical servers', + () async { + SharedPreferences.setMockInitialValues({}); + const a = SharedPreferencesTabLocationsStore(scope: 'server-a'); + const b = SharedPreferencesTabLocationsStore(scope: 'server-b'); + expect( + await a.save( + const TabLocationsSnapshot( + routes: {AppDestination.pipelines: AppRoute.settings}, + ), + ), + isTrue, + ); + expect( + (await const SharedPreferencesTabLocationsStore( + scope: 'server-a', + ).load()).routes[AppDestination.pipelines], + AppRoute.settings, + ); + expect((await b.load()).routes, isEmpty); + }, + ); + test( + 'unreadable history is never replaced by a partial new snapshot', + () async { + final store = UnreadableTabLocationsStore(); + final tabs = TabLocations(store)..record(AppRoute.settings); + expect(await tabs.restore(restoreActive: false), isNull); + tabs.record(AppRoute.chat); + await tabs.settled; + expect(tabs.persistenceFailed, isTrue); + expect(store.writes, isEmpty); + expect(tabs.routes[AppDestination.pipelines], AppRoute.settings); + }, + ); + test('a failed write does not prevent a later navigation save', () async { + final store = FailingTabLocationsStore(); + final tabs = TabLocations(store)..record(AppRoute.settings); + await tabs.restore(restoreActive: false); + await tabs.settled; + expect(tabs.persistenceFailed, isTrue); + tabs.record(AppRoute.chat); + await tabs.settled; + expect(tabs.persistenceFailed, isFalse); + expect(store.value.active, AppDestination.chat); + }); + test( + 'a disposed app never writes a late storage read back over newer history', + () async { + final store = MemoryTabLocationsStore()..read = Completer(); + final tabs = TabLocations(store) + ..record(AppRoute.pipelines, visited: false); + final restoring = tabs.restore(restoreActive: true); + tabs.dispose(); + store.read!.complete( + const TabLocationsSnapshot( + routes: {AppDestination.pipelines: AppRoute.settings}, + ), + ); + expect(await restoring, isNull); + await tabs.settled; + expect(store.writes, isEmpty); + }, + ); +}