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/chat/conversation/chat_thread_view.dart'; import 'package:pipelines_app/features/chat/domain/chat_notice.dart'; import 'package:pipelines_app/features/chat/domain/chat_transcript.dart'; import 'chat_thread_fixtures.dart'; Widget host(Widget child) => MaterialApp( theme: ThemeData(platform: TargetPlatform.android), home: Scaffold(body: child), ); Widget cupertinoHost(Widget child) => CupertinoApp( theme: const CupertinoThemeData(brightness: Brightness.dark), home: CupertinoPageScaffold(child: child), ); JsonMap compactionTurn( String messageId, String id, [ String state = 'running', ]) => chatMessage( messageId, 'assistant', parts: [ {'type': 'compaction', 'kind': 'compaction', 'id': id, 'status': state}, ], ); JsonMap runningCompaction(String id) => compactionTurn('a1', id); const compactionDismissKey = ValueKey('chat-notice-dismiss-compaction'); void main() { test('each recorded condition keeps its own exact wording', () { final notices = chatNotices( historyError: 'Bad state: Connection closed', liveError: 'Exception: live watch refused', messages: [runningCompaction('c1')], ); expect(notices, hasLength(3)); expect(notices[0].kind, ChatNoticeKind.connectionRefused); expect(notices[0].text, 'Chat history unavailable\nConnection closed'); expect(notices[1].kind, ChatNoticeKind.liveFailure); expect(notices[1].text, 'Live updates unavailable\nlive watch refused'); // The phase words are the web's own (`turnPhaseLabel`). expect(notices[2].kind, ChatNoticeKind.compaction); expect(notices[2].text, 'Compacting context…'); expect(notices[2].detail, isEmpty); expect( [for (final kind in ChatNoticeKind.values) chatNoticeDismissLabel(kind)], [ 'Dismiss connection notice', 'Dismiss live updates notice', 'Dismiss compaction notice', 'Dismiss command notice', ], ); // A later compaction has its own recorded condition. final next = chatNotices(messages: [runningCompaction('c2')]).single; expect(next.condition, isNot(notices[2].condition)); }); test('a dismissal hides one condition until that condition changes', () { final dismissals = ChatNoticeDismissals(); final first = chatNotices(liveError: 'first refusal').single; expect(dismissals.visible([first]), [first]); dismissals.dismiss(first); expect(dismissals.visible([first]), isEmpty); // The same recorded condition stays hidden. expect( dismissals.visible(chatNotices(liveError: 'first refusal')), isEmpty, ); // A different recorded reason is a new notice. final second = dismissals .visible(chatNotices(liveError: 'second refusal')) .single; expect(second.text, 'Live updates unavailable\nsecond refusal'); // A condition that disappears and comes back is recorded afresh. expect(dismissals.visible(const []), isEmpty); expect( dismissals.visible(chatNotices(liveError: 'first refusal')).single.text, 'Live updates unavailable\nfirst refusal', ); }); test('a reconnect forgets every earlier dismissal', () { final dismissals = ChatNoticeDismissals(); final notice = chatNotices(historyError: 'Connection closed').single; dismissals.dismiss(notice); expect(dismissals.visible([notice]), isEmpty); dismissals.clear(); expect(dismissals.visible([notice]), [notice]); }); test('an unchanged transcript invents no notice', () { expect(chatNotices(), isEmpty); expect(chatNotices(messages: const []), isEmpty); expect( chatNotices( messages: [ chatMessage( 'a1', 'assistant', parts: [ {'type': 'text', 'text': 'Just an answer.'}, {'type': 'reasoning', 'text': 'Thinking.'}, { 'type': 'tool', 'state': {'status': 'completed'}, }, ], ), ], ), isEmpty, ); // A compaction that already ended is recorded history, not a live notice. expect( chatNotices( messages: [ chatMessage( 'a1', 'assistant', parts: [ { 'type': 'compaction', 'kind': 'compaction', 'id': 'c1', 'status': 'completed', }, ], ), ], ), isEmpty, ); }); test('a later terminal record supersedes an earlier running compaction', () { final messages = [ compactionTurn('a1', 'c1'), compactionTurn('a2', 'c2', 'completed'), ]; expect(chatRunningCompaction(messages), isNull); expect(chatNotices(messages: messages), isEmpty); // The line itself is still the recorded activity: the compaction ended. expect(transcriptRows(messages).single['state'], 'completed'); expect( chatNoticeActivityCondition(transcriptRows(messages).single), isNull, ); }); test('each running compaction row carries its own notice condition', () { final rows = transcriptRows([ compactionTurn('a1', 'c1'), chatMessage('u1', 'user', parts: const []), compactionTurn('a2', 'c2'), ]); final conditions = [ for (final row in rows) if (row['kind'] == 'activity') chatNoticeActivityCondition(row), ]; expect(conditions, ['compaction\nc1', 'compaction\nc2']); // The transcript's newest running compaction is the one it reports. expect( chatNotices( messages: [ compactionTurn('a1', 'c1'), chatMessage('u1', 'user', parts: const []), compactionTurn('a2', 'c2'), ], ).single.condition, 'compaction\nc2', ); }); testWidgets('the live failure notice has a native dismiss that hides it', ( tester, ) async { final gateway = FakeChatGateway(); addTearDown(gateway.close); gateway.subscribe = () async => throw StateError('live watch refused'); gateway.history = (_) async => chatPage(const []); await tester.pumpWidget( host(ChatThreadView(gateway: gateway, sessionId: 's', onBack: () {})), ); await tester.pumpAndSettle(); expect(find.byKey(const Key('chat-live-error')), findsOneWidget); expect(find.textContaining('live watch refused'), findsOneWidget); await tester.tap( find.byKey(const ValueKey('chat-notice-dismiss-liveFailure')), ); await tester.pump(); expect(find.byKey(const Key('chat-live-error')), findsNothing); expect(find.textContaining('live watch refused'), findsNothing); // A later transcript frame changes no condition, so it stays hidden. gateway.emitEvent(chatTextFrame('An answer.')); await tester.pumpAndSettle(); expect(find.byKey(const Key('chat-live-error')), findsNothing); }); testWidgets('a reconnect clears the stale notice and its dismissal', ( tester, ) async { final gateway = FakeChatGateway(); addTearDown(gateway.close); gateway.subscribe = () async => throw StateError('live watch refused'); gateway.history = (_) async => chatPage(const []); await tester.pumpWidget( host(ChatThreadView(gateway: gateway, sessionId: 's', onBack: () {})), ); await tester.pumpAndSettle(); await tester.tap( find.byKey(const ValueKey('chat-notice-dismiss-liveFailure')), ); await tester.pump(); expect(find.byKey(const Key('chat-live-error')), findsNothing); // The socket comes back and the watch is accepted: the recorded condition // is gone, so the old notice cannot linger. gateway.subscribe = () async => const {}; await tester.pumpWidget( host( ChatThreadView( gateway: gateway, sessionId: 's', onBack: () {}, syncToken: 1, ), ), ); // The pre-gap notice is stale as soon as the socket is replaced. await tester.pump(); expect(find.byKey(const Key('chat-live-error')), findsNothing); await tester.pumpAndSettle(); expect(find.byKey(const Key('chat-live-error')), findsNothing); // A failure recorded after the reconnect is shown again: the old dismissal // did not survive the gap, even though the words repeat. gateway.subscribe = () async => throw StateError('live watch refused'); await tester.pumpWidget( host( ChatThreadView( gateway: gateway, sessionId: 's', onBack: () {}, syncToken: 2, ), ), ); await tester.pumpAndSettle(); expect(find.byKey(const Key('chat-live-error')), findsOneWidget); expect(find.textContaining('live watch refused'), findsOneWidget); }); testWidgets('a reconnect hides a stale running compaction until fresh state', ( tester, ) async { final gateway = FakeChatGateway(); addTearDown(gateway.close); gateway.history = (_) async => chatPage([runningCompaction('c1')]); await tester.pumpWidget( host(ChatThreadView(gateway: gateway, sessionId: 's', onBack: () {})), ); await tester.pumpAndSettle(); expect(find.text('Compacting context…'), findsOneWidget); await tester.tap(find.byKey(compactionDismissKey)); await tester.pump(); expect(find.text('Compacting context…'), findsNothing); // The socket is replaced and the repair's history read has not answered: // the pre-gap running state is stale, and the earlier dismissal does not // make it visible again. gateway.history = null; await tester.pumpWidget( host( ChatThreadView( gateway: gateway, sessionId: 's', onBack: () {}, syncToken: 1, ), ), ); await tester.pump(); expect(find.text('Compacting context…'), findsNothing); expect(find.byKey(compactionDismissKey), findsNothing); // The repair reports the same compaction still running: the fresh record // shows again with its dismiss control; the gap cleared the old dismissal. gateway.historyRequests.last.complete(chatPage([runningCompaction('c1')])); await tester.pumpAndSettle(); expect(find.text('Compacting context…'), findsOneWidget); expect(find.byKey(compactionDismissKey), findsOneWidget); }); testWidgets('a refused repair keeps the pre-gap compaction hidden', ( tester, ) async { final gateway = FakeChatGateway(); addTearDown(gateway.close); gateway.history = (_) async => chatPage([runningCompaction('c1')]); await tester.pumpWidget( host(ChatThreadView(gateway: gateway, sessionId: 's', onBack: () {})), ); await tester.pumpAndSettle(); await tester.tap(find.byKey(compactionDismissKey)); await tester.pump(); expect(find.text('Compacting context…'), findsNothing); gateway.history = (_) async => throw StateError('history refused'); await tester.pumpWidget( host( ChatThreadView( gateway: gateway, sessionId: 's', onBack: () {}, syncToken: 1, ), ), ); await tester.pumpAndSettle(); // The refused repair is a fresh failure notice; the held transcript's // running compaction is not painted again as if it were current. expect(find.byKey(const Key('chat-history-error')), findsOneWidget); expect(find.textContaining('history refused'), findsOneWidget); expect(find.text('Compacting context…'), findsNothing); expect(find.byKey(compactionDismissKey), findsNothing); }); testWidgets('dismissing one running compaction leaves the other line alone', ( tester, ) async { final gateway = FakeChatGateway(); addTearDown(gateway.close); gateway.history = (_) async => chatPage([ compactionTurn('a1', 'c1'), chatMessage('u1', 'user', parts: const []), compactionTurn('a2', 'c2'), ]); await tester.pumpWidget( host(ChatThreadView(gateway: gateway, sessionId: 's', onBack: () {})), ); await tester.pumpAndSettle(); expect(find.text('Compacting context…'), findsNWidgets(2)); // Only the transcript's newest running compaction is the reported notice. expect(find.byKey(compactionDismissKey), findsOneWidget); await tester.tap(find.byKey(compactionDismissKey)); await tester.pump(); // c2's line is hidden; the separately recorded c1 line keeps its words. expect(find.text('Compacting context…'), findsOneWidget); expect(find.byKey(compactionDismissKey), findsNothing); }); testWidgets('a running compaction notice is native, dismissed and exact', ( tester, ) async { final gateway = FakeChatGateway(); addTearDown(gateway.close); gateway.history = (_) async => chatPage([runningCompaction('c1')]); await tester.pumpWidget( cupertinoHost( ChatThreadView(gateway: gateway, sessionId: 's', onBack: () {}), ), ); await tester.pumpAndSettle(); expect(find.byKey(const Key('chat-compaction-notice')), findsNothing); expect(find.text('Compacting context…'), findsOneWidget); expect(find.byType(Material), findsNothing); expect(find.bySemanticsLabel('Dismiss compaction notice'), findsOneWidget); await tester.tap( find.byKey(const ValueKey('chat-notice-dismiss-compaction')), ); await tester.pump(); expect(find.text('Compacting context…'), findsNothing); }); }