import 'dart:convert'; import 'package:flutter/cupertino.dart'; import 'package:flutter/material.dart'; import 'package:flutter_test/flutter_test.dart'; import 'package:pipelines_app/application/pipelines_app.dart'; import 'package:pipelines_app/application/server_endpoint.dart'; import 'package:pipelines_app/core/transport/pipelines_client.dart'; import 'package:pipelines_app/features/chat/conversation/chat_thread_view.dart'; import 'package:pipelines_app/features/chat/ui/sessions/chat_sessions_screen.dart'; import '../core/transport/pipelines_client_test.dart' show FakeChannel; ServerEndpoint webServer() => ServerEndpoint.resolve( base: Uri.parse('http://127.0.0.1:8096/'), web: true, ); Map? requestOf( FakeChannel channel, String type, { int index = 0, }) => channel.outgoing .map((frame) => jsonDecode(frame as String) as Map) .where((frame) => frame['type'] == type) .skip(index) .firstOrNull; Future> waitForRequest( WidgetTester tester, FakeChannel channel, String type, { int index = 0, }) async { for (var attempt = 0; attempt < 80; attempt++) { final request = requestOf(channel, type, index: index); if (request != null) return request; await tester.pump(const Duration(milliseconds: 5)); } fail('Timed out waiting for $type #$index'); } Future replySessions( WidgetTester tester, FakeChannel channel, { int index = 0, }) async { final request = await waitForRequest( tester, channel, 'chat_sessions', index: index, ); channel.incoming.add( jsonEncode({ 'id': request['id'], 'type': 'chat_sessions', 'chat_sessions': [ {'id': 's1', 'title': 'Wire chat', 'directory': '/workspace/demo'}, ], }), ); await tester.pump(); } Future replySubscribe( WidgetTester tester, FakeChannel channel, { int index = 0, }) async { final request = await waitForRequest( tester, channel, 'chat_subscribe', index: index, ); channel.incoming.add( jsonEncode({'id': request['id'], 'type': 'chat_subscribe'}), ); await tester.pump(); await tester.pump(); } /// The mounted thread also reads the session's running background tasks. The /// client serializes requests, so this snapshot is answered (no running task) /// before the history page behind it can leave the queue. Future replyShells( WidgetTester tester, FakeChannel channel, { int index = 0, }) async { final request = await waitForRequest( tester, channel, 'chat_shells', index: index, ); channel.incoming.add( jsonEncode({ 'id': request['id'], 'type': 'chat_shells', 'chat_shells': const [], }), ); await tester.pump(); } Future replyHistory( WidgetTester tester, FakeChannel channel, { int index = 0, String text = 'The stored reply stays readable.', bool shells = true, }) async { if (shells) await replyShells(tester, channel, index: index); final request = await waitForRequest( tester, channel, 'chat_messages', index: index, ); channel.incoming.add( jsonEncode({ 'id': request['id'], 'type': 'chat_history', 'chat_history': { 'messages': [ { 'id': 'u1', 'role': 'user', 'parts': [ {'type': 'text', 'text': 'Open this chat from its route.'}, ], }, { 'id': 'a1', 'role': 'assistant', 'parts': [ {'type': 'text', 'text': text}, {'type': 'reasoning', 'text': 'Kept behind a native disclosure.'}, {'type': 'tool', 'name': 'shell'}, ], }, ], 'next_cursor': '', 'has_more': false, }, }), ); await tester.pump(); await tester.pump(); } void main() { for (final cupertino in [false, true]) { testWidgets( 'a /chat/s1 deep link renders that thread and Back returns to /chat ($cupertino)', (tester) async { tester.view.physicalSize = const Size(900, 900); tester.view.devicePixelRatio = 1; addTearDown(tester.view.resetPhysicalSize); addTearDown(tester.view.resetDevicePixelRatio); if (cupertino) { tester.platformDispatcher.platformBrightnessTestValue = Brightness.dark; addTearDown( tester.platformDispatcher.clearPlatformBrightnessTestValue, ); } final channel = FakeChannel()..readyCompleter.complete(); final client = PipelinesClient(channelFactory: (_) => channel); final provider = PlatformRouteInformationProvider( initialRouteInformation: RouteInformation(uri: Uri.parse('/chat/s1')), ); addTearDown(provider.dispose); await tester.pumpWidget( PipelinesApp( server: webServer(), client: client, cupertino: cupertino, routeInformationProvider: provider, ), ); await tester.pump(); await replySessions(tester, channel); await replySubscribe(tester, channel); await replyHistory(tester, channel); expect(provider.value.uri.path, '/chat/s1'); expect(find.byType(ChatThreadView), findsOneWidget); // The exact route names the session; the request carries the same id. expect(requestOf(channel, 'chat_subscribe')!['chat_subscribe'], { 'session_id': 's1', }); expect(requestOf(channel, 'chat_messages')!['chat_query'], { 'session_id': 's1', 'limit': 200, 'cursor': '', }); expect(find.text('The stored reply stays readable.'), findsOneWidget); expect(find.text('Reasoning'), findsOneWidget); expect(find.text('1 tool'), findsOneWidget); expect(find.text('Kept behind a native disclosure.'), findsNothing); // One shell bar only: the embedded list/thread adds no second one. if (cupertino) { expect(find.byType(CupertinoNavigationBar), findsOneWidget); expect(find.byType(AppBar), findsNothing); } else { expect(find.byType(AppBar), findsOneWidget); expect(find.byType(CupertinoNavigationBar), findsNothing); } // A live frame updates the held thread. channel.incoming.add( jsonEncode({ 'type': 'chat_event', 'chat_event': { 'session_id': 's1', 'message_id': 'a1', 'kind': 'text', 'part': {'id': 'p2', 'type': 'text'}, 'delta': 'A live line arrived.', }, }), ); await tester.pump(); await tester.pump(); expect(find.text('A live line arrived.'), findsOneWidget); // The open chat takes over the app bar: one Back there, and no // second header row under it. expect(find.byKey(const Key('chat-thread-header')), findsNothing); await tester.tap(find.byKey(const ValueKey('shell.back'))); await tester.pump(); // The bar hands back to the list on the next frame. await tester.pump(); expect(provider.value.uri.path, '/chat'); expect(find.byType(ChatThreadView), findsNothing); expect(find.byType(ChatSessionsScreen), findsOneWidget); expect(find.text('Wire chat'), findsOneWidget); // Browser Forward re-opens the same session through its route. await provider.didPushRouteInformation( RouteInformation(uri: Uri.parse('/chat/s1')), ); await tester.pump(); expect(provider.value.uri.path, '/chat/s1'); await replySubscribe(tester, channel, index: 1); await replyHistory( tester, channel, index: 1, text: 'Reopened from the route.', ); expect(find.text('Reopened from the route.'), findsOneWidget); await tester.pumpWidget(const SizedBox.shrink()); await tester.pump(); }, ); } }