216 lines
7.8 KiB
Dart
216 lines
7.8 KiB
Dart
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/ui/transcript/chat_message_view.dart';
|
|
|
|
import 'chat_thread_fixtures.dart';
|
|
|
|
// Matches the normalized OpenCode V2 protocol: text and reasoning each start
|
|
// at ordinal zero but have distinct stable IDs (ChatDeltaPartID in Go).
|
|
JsonMap _delta(String kind, String text) => {
|
|
'session_id': 's',
|
|
'message_id': 'a',
|
|
'kind': kind,
|
|
'part': {'id': 'a#$kind#0', 'type': kind},
|
|
'delta': text,
|
|
};
|
|
|
|
Widget _host(Widget child, bool cupertino) => cupertino
|
|
? CupertinoApp(home: CupertinoPageScaffold(child: child))
|
|
: MaterialApp(
|
|
theme: ThemeData(platform: TargetPlatform.android),
|
|
home: Scaffold(body: child),
|
|
);
|
|
|
|
/// A streaming reasoning chip spins for as long as reasoning is the newest
|
|
/// part, so pumpAndSettle would never return; this lets a sheet finish its
|
|
/// entrance or exit instead.
|
|
Future<void> _settle(WidgetTester tester) async {
|
|
for (var frame = 0; frame < 8; frame++) {
|
|
await tester.pump(const Duration(milliseconds: 100));
|
|
}
|
|
}
|
|
|
|
final _sheet = find.byKey(const Key('chat-reasoning-sheet'));
|
|
|
|
Finder _inSheet(String text) =>
|
|
find.descendant(of: _sheet, matching: find.text(text));
|
|
|
|
Future<void> _dismiss(WidgetTester tester) async {
|
|
await tester.tapAt(const Offset(10, 10));
|
|
await _settle(tester);
|
|
expect(_sheet, findsNothing);
|
|
}
|
|
|
|
void main() {
|
|
for (final cupertino in [false, true]) {
|
|
final host = cupertino ? 'Cupertino' : 'Material';
|
|
|
|
testWidgets('reasoning arriving after text is a spinning chip ($host)', (
|
|
tester,
|
|
) async {
|
|
final gateway = FakeChatGateway();
|
|
addTearDown(gateway.close);
|
|
gateway.history = (_) async => chatPage(const []);
|
|
await tester.pumpWidget(
|
|
_host(
|
|
ChatThreadView(gateway: gateway, sessionId: 's', onBack: () {}),
|
|
cupertino,
|
|
),
|
|
);
|
|
await tester.pumpAndSettle();
|
|
gateway.emitEvent(_delta('text', 'Answer first'));
|
|
await tester.pumpAndSettle();
|
|
expect(find.text('Reasoning'), findsNothing);
|
|
|
|
gateway.emitEvent(_delta('reasoning', 'Only supplied reasoning'));
|
|
await _settle(tester);
|
|
// A chip in the footer like the tools chip, not an inline body.
|
|
expect(find.text('Only supplied reasoning'), findsNothing);
|
|
expect(find.text('Answer first'), findsOneWidget);
|
|
final chip = find.byKey(const Key('chat-reasoning-chip'));
|
|
final spinner = find.descendant(
|
|
of: chip,
|
|
matching: find.byType(
|
|
cupertino ? CupertinoActivityIndicator : CircularProgressIndicator,
|
|
),
|
|
);
|
|
expect(spinner, findsOneWidget);
|
|
expect(
|
|
find.bySemanticsLabel('Reasoning, expand for details'),
|
|
findsOneWidget,
|
|
);
|
|
|
|
await tester.tap(find.text('Reasoning'));
|
|
await _settle(tester);
|
|
expect(_inSheet('Only supplied reasoning'), findsOneWidget);
|
|
await _dismiss(tester);
|
|
|
|
// The step ends: the chip settles to its icon.
|
|
gateway.emitEvent(chatStepFrame('ended'));
|
|
await tester.pumpAndSettle();
|
|
expect(spinner, findsNothing);
|
|
expect(tester.takeException(), isNull);
|
|
});
|
|
|
|
testWidgets('an open reasoning sheet follows live deltas, paging and '
|
|
'resync ($host)', (tester) async {
|
|
final gateway = FakeChatGateway();
|
|
addTearDown(gateway.close);
|
|
gateway.history = (_) async =>
|
|
chatPage(const [], hasMore: true, cursor: 'old');
|
|
await tester.pumpWidget(
|
|
_host(
|
|
ChatThreadView(gateway: gateway, sessionId: 's', onBack: () {}),
|
|
cupertino,
|
|
),
|
|
);
|
|
await tester.pumpAndSettle();
|
|
|
|
gateway.emitEvent(_delta('reasoning', 'Provided thought'));
|
|
await _settle(tester);
|
|
final rowElement = tester.element(find.byType(ChatMessageView));
|
|
await tester.tap(find.text('Reasoning'));
|
|
await _settle(tester);
|
|
expect(_inSheet('Provided thought'), findsOneWidget);
|
|
|
|
// The open sheet repaints with each delta while the answer streams too;
|
|
// the row and its chip are the same elements throughout.
|
|
gateway.emitEvent(_delta('text', 'Answer'));
|
|
gateway.emitEvent(_delta('reasoning', ' continues'));
|
|
await _settle(tester);
|
|
expect(_inSheet('Provided thought continues'), findsOneWidget);
|
|
expect(find.text('Answer'), findsOneWidget);
|
|
expect(tester.element(find.byType(ChatMessageView)), same(rowElement));
|
|
gateway.emitEvent(_delta('reasoning', ' live'));
|
|
await _settle(tester);
|
|
expect(_inSheet('Provided thought continues live'), findsOneWidget);
|
|
await _dismiss(tester);
|
|
|
|
// A closed sheet draws nothing; reopening shows the newest text.
|
|
gateway.emitEvent(_delta('reasoning', ' while closed'));
|
|
gateway.emitEvent(_delta('text', ' continues'));
|
|
await tester.pumpAndSettle();
|
|
expect(find.textContaining('while closed'), findsNothing);
|
|
expect(find.text('Answer continues'), findsOneWidget);
|
|
await tester.tap(find.text('Reasoning'));
|
|
await tester.pumpAndSettle();
|
|
expect(
|
|
_inSheet('Provided thought continues live while closed'),
|
|
findsOneWidget,
|
|
);
|
|
await _dismiss(tester);
|
|
|
|
// Prepending another assistant message folds into the same turn without
|
|
// replacing the row; the chip counts both steps.
|
|
gateway.history = (_) async => chatPage([
|
|
chatMessage(
|
|
'older',
|
|
'assistant',
|
|
parts: [
|
|
{
|
|
'type': 'reasoning',
|
|
'id': 'older-r',
|
|
'text': 'Older provided thought',
|
|
},
|
|
],
|
|
),
|
|
]);
|
|
await tester.tap(find.text('Load older'));
|
|
await tester.pumpAndSettle();
|
|
expect(find.text('Reasoning · 2 steps'), findsOneWidget);
|
|
expect(tester.element(find.byType(ChatMessageView)), same(rowElement));
|
|
await tester.tap(find.text('Reasoning · 2 steps'));
|
|
await tester.pumpAndSettle();
|
|
expect(_inSheet('Older provided thought'), findsOneWidget);
|
|
expect(
|
|
_inSheet('Provided thought continues live while closed'),
|
|
findsOneWidget,
|
|
);
|
|
|
|
// A resync replaces the stored turn under the open sheet.
|
|
gateway.emitEvent(chatStepFrame('ended'));
|
|
gateway.history = (_) async => chatPage([
|
|
chatMessage(
|
|
'a',
|
|
'assistant',
|
|
parts: [
|
|
{
|
|
'type': 'reasoning',
|
|
'id': 'a#reasoning#0',
|
|
'text': 'Stored provided thought',
|
|
},
|
|
{'type': 'text', 'id': 'a#text#0', 'text': 'Stored answer'},
|
|
],
|
|
),
|
|
]);
|
|
gateway.emitEvent({'session_id': 's', 'kind': 'resync'});
|
|
await tester.pumpAndSettle();
|
|
expect(_inSheet('Stored provided thought'), findsOneWidget);
|
|
expect(find.textContaining('while closed'), findsNothing);
|
|
expect(find.text('Stored answer'), findsOneWidget);
|
|
expect(tester.element(find.byType(ChatMessageView)), same(rowElement));
|
|
await _dismiss(tester);
|
|
|
|
// A fresh history visit draws the chip closed; missing reasoning is
|
|
// never fabricated. Cupertino keeps only its native controls.
|
|
await tester.pumpWidget(const SizedBox.shrink());
|
|
await tester.pumpWidget(
|
|
_host(
|
|
ChatThreadView(gateway: gateway, sessionId: 's', onBack: () {}),
|
|
cupertino,
|
|
),
|
|
);
|
|
await tester.pumpAndSettle();
|
|
expect(find.text('Stored provided thought'), findsNothing);
|
|
await tester.tap(find.text('Reasoning'));
|
|
await tester.pumpAndSettle();
|
|
expect(_inSheet('Stored provided thought'), findsOneWidget);
|
|
if (cupertino) expect(find.byType(Material), findsNothing);
|
|
expect(tester.takeException(), isNull);
|
|
});
|
|
}
|
|
}
|