477 lines
14 KiB
Dart
477 lines
14 KiB
Dart
import 'dart:async';
|
|
|
|
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_permission_card.dart';
|
|
import 'package:pipelines_app/features/chat/conversation/chat_permission_card_model.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';
|
|
|
|
Widget materialHost(Widget child) => MaterialApp(
|
|
theme: ThemeData(platform: TargetPlatform.android),
|
|
home: Scaffold(body: child),
|
|
);
|
|
|
|
Widget scrollHost(Widget child) =>
|
|
materialHost(SingleChildScrollView(child: child));
|
|
|
|
Widget cupertinoHost(Widget child) => CupertinoApp(
|
|
theme: const CupertinoThemeData(brightness: Brightness.dark),
|
|
home: CupertinoPageScaffold(
|
|
child: SingleChildScrollView(
|
|
padding: const EdgeInsets.all(16),
|
|
child: child,
|
|
),
|
|
),
|
|
);
|
|
|
|
JsonMap permission({
|
|
String id = 'req-1',
|
|
String action = 'bash',
|
|
List<String> resources = const [
|
|
'command: rm -rf build',
|
|
'cwd: /workspace/demo',
|
|
],
|
|
String message = 'This deletes the build output.',
|
|
bool resolved = false,
|
|
String decision = '',
|
|
}) => {
|
|
'session_id': 's',
|
|
'request_id': id,
|
|
'action': action,
|
|
'resources': resources,
|
|
'message': message,
|
|
'source': {'type': 'tool'},
|
|
'resolved': resolved,
|
|
if (decision.isNotEmpty) 'decision': decision,
|
|
};
|
|
|
|
void main() {
|
|
test('recorded action, risk and options survive the card model', () {
|
|
final card = chatPermissionCard(permission(), '')!;
|
|
expect(card.headline, 'Approve bash');
|
|
expect(card.statusLine, chatApprovalStatusPending);
|
|
expect(card.risk, 'This deletes the build output.');
|
|
expect(card.resources, ['command: rm -rf build', 'cwd: /workspace/demo']);
|
|
expect(card.alwaysLabel, 'Always allow');
|
|
expect(card.actionable, isTrue);
|
|
expect(card.showRisk, isTrue);
|
|
});
|
|
|
|
test('resources keep their recorded indentation and order', () {
|
|
final card = chatPermissionCard(
|
|
permission(
|
|
resources: const [
|
|
' cd /workspace/demo',
|
|
'command: |\n echo hello',
|
|
' ',
|
|
],
|
|
),
|
|
'',
|
|
)!;
|
|
expect(card.resources, [
|
|
' cd /workspace/demo',
|
|
'command: |\n echo hello',
|
|
]);
|
|
expect(card.resourceText, ' cd /workspace/demo\ncommand: |\n echo hello');
|
|
});
|
|
|
|
test('risk falls back to the action and resources cap at six lines', () {
|
|
final card = chatPermissionCard(
|
|
permission(
|
|
message: '',
|
|
resources: const [
|
|
'one',
|
|
'two\nthree',
|
|
'four',
|
|
'five',
|
|
'six',
|
|
'seven',
|
|
'eight',
|
|
],
|
|
),
|
|
'',
|
|
)!;
|
|
expect(
|
|
card.risk,
|
|
'The agent is asking to run bash; review the request before allowing.',
|
|
);
|
|
expect(card.resourceText.split('\n'), hasLength(6));
|
|
expect(card.resourceText.endsWith('…'), isTrue);
|
|
expect(card.resources, hasLength(7));
|
|
});
|
|
|
|
test('a server resolution outranks a local answer and a blank decision is '
|
|
'stale', () {
|
|
final resolved = chatPermissionCard(
|
|
permission(
|
|
resolved: true,
|
|
decision: 'always',
|
|
message: 'Another client already allowed this.',
|
|
),
|
|
'once',
|
|
)!;
|
|
expect(resolved.state, ChatPermissionState.resolved);
|
|
expect(resolved.headline, 'Always allowed');
|
|
expect(resolved.statusLine, 'Another client already allowed this.');
|
|
expect(resolved.actionable, isFalse);
|
|
expect(resolved.showRisk, isFalse);
|
|
|
|
final stale = chatPermissionCard(
|
|
permission(resolved: true, message: ''),
|
|
'',
|
|
)!;
|
|
expect(stale.state, ChatPermissionState.stale);
|
|
expect(stale.headline, 'Already resolved');
|
|
expect(stale.statusLine, chatApprovalStatusResolved);
|
|
expect(stale.actionable, isFalse);
|
|
});
|
|
|
|
test('a rejection keeps the risk panel while answered', () {
|
|
final rejected = chatPermissionCard(permission(), 'reject')!;
|
|
expect(rejected.state, ChatPermissionState.answered);
|
|
expect(rejected.headline, 'Rejected');
|
|
expect(rejected.statusLine, chatApprovalStatusAnswered);
|
|
expect(rejected.showRisk, isTrue);
|
|
expect(rejected.actionable, isFalse);
|
|
});
|
|
|
|
test('one stable reply id per confirmed action', () {
|
|
expect(
|
|
chatPermissionReplyId('req-1', 'once'),
|
|
chatPermissionReplyId('req-1', 'once'),
|
|
);
|
|
expect(
|
|
chatPermissionReplyId('req-1', 'once'),
|
|
isNot(chatPermissionReplyId('req-1', 'always')),
|
|
);
|
|
final gate = ChatActionGate();
|
|
final id = chatPermissionReplyId('req-1', 'once');
|
|
expect(gate.start(id), isTrue);
|
|
expect(gate.start(id), isFalse);
|
|
gate.release(id);
|
|
expect(gate.start(id), isTrue);
|
|
});
|
|
|
|
testWidgets('a pending approval renders native Material controls', (
|
|
tester,
|
|
) async {
|
|
final decisions = <String>[];
|
|
final card = chatPermissionCard(permission(), '')!;
|
|
await tester.pumpWidget(
|
|
scrollHost(
|
|
ChatPermissionCard(
|
|
card: card,
|
|
onDecision: (value) async {
|
|
decisions.add(value);
|
|
},
|
|
),
|
|
),
|
|
);
|
|
expect(find.text('Approve bash'), findsOneWidget);
|
|
expect(find.text('Waiting for your response'), findsOneWidget);
|
|
expect(find.text('RISK REVIEW'), findsOneWidget);
|
|
expect(find.text('This deletes the build output.'), findsOneWidget);
|
|
expect(find.text('Allow once'), findsOneWidget);
|
|
expect(find.text('Always allow'), findsOneWidget);
|
|
expect(find.text('Reject'), findsOneWidget);
|
|
expect(find.text('Permission request · tool'), findsNothing);
|
|
|
|
await tester.tap(find.text('Allow once'));
|
|
await tester.pump();
|
|
expect(decisions, ['once']);
|
|
});
|
|
|
|
testWidgets('Show full request expands to every recorded resource line', (
|
|
tester,
|
|
) async {
|
|
final card = chatPermissionCard(
|
|
permission(
|
|
resources: const [
|
|
' one',
|
|
'two',
|
|
'three',
|
|
'four',
|
|
'five',
|
|
'six',
|
|
'seven',
|
|
],
|
|
),
|
|
'',
|
|
)!;
|
|
await tester.pumpWidget(
|
|
scrollHost(ChatPermissionCard(card: card, onDecision: (_) async {})),
|
|
);
|
|
expect(find.text(' one'), findsNothing);
|
|
await tester.tap(find.text('Show full request'));
|
|
await tester.pumpAndSettle();
|
|
expect(find.text(card.resources.join('\n')), findsOneWidget);
|
|
});
|
|
|
|
testWidgets('320px at 2x in dark Cupertino keeps the card native and '
|
|
'readable', (tester) async {
|
|
tester.view.physicalSize = const Size(640, 1400);
|
|
tester.view.devicePixelRatio = 2;
|
|
tester.platformDispatcher.textScaleFactorTestValue = 2;
|
|
tester.platformDispatcher.platformBrightnessTestValue = Brightness.dark;
|
|
addTearDown(tester.view.resetPhysicalSize);
|
|
addTearDown(tester.view.resetDevicePixelRatio);
|
|
addTearDown(tester.platformDispatcher.clearTextScaleFactorTestValue);
|
|
addTearDown(tester.platformDispatcher.clearPlatformBrightnessTestValue);
|
|
|
|
final card = chatPermissionCard(
|
|
permission(
|
|
action: 'a very long tool name that has to wrap at twice the text size',
|
|
resources: const [
|
|
'a long resource line that wraps instead of clipping any words at all',
|
|
],
|
|
),
|
|
'',
|
|
)!;
|
|
await tester.pumpWidget(
|
|
cupertinoHost(ChatPermissionCard(card: card, onDecision: (_) async {})),
|
|
);
|
|
expect(tester.takeException(), isNull);
|
|
expect(find.text('Allow once'), findsOneWidget);
|
|
expect(find.byType(Material), findsNothing);
|
|
});
|
|
|
|
testWidgets('a pushed chat_permission renders, sends the recorded reply, '
|
|
'and a second tap sends once', (tester) async {
|
|
final gateway = FakeChatGateway();
|
|
addTearDown(gateway.close);
|
|
gateway.history = (_) async => chatPage(const []);
|
|
final held = Completer<JsonMap>();
|
|
gateway.reply = (_) => held.future;
|
|
|
|
await tester.pumpWidget(
|
|
materialHost(
|
|
ChatThreadView(gateway: gateway, sessionId: 's', onBack: () {}),
|
|
),
|
|
);
|
|
await tester.pumpAndSettle();
|
|
gateway.emitRaw({
|
|
'type': 'chat_permission',
|
|
'chat_permission': permission(),
|
|
});
|
|
await tester.pumpAndSettle();
|
|
|
|
expect(find.text('Approve bash'), findsOneWidget);
|
|
await tester.tap(find.text('Allow once'));
|
|
await tester.tap(find.text('Allow once'));
|
|
await tester.pump();
|
|
|
|
final replies = gateway.calls.where((call) => call.type == 'chat_reply');
|
|
expect(replies, hasLength(1));
|
|
expect(replies.single.fields, {
|
|
'chat_reply': {
|
|
'session_id': 's',
|
|
'request_id': 'req-1',
|
|
'decision': 'once',
|
|
'client': 'Web',
|
|
},
|
|
});
|
|
expect(find.text('Allowed once'), findsOneWidget);
|
|
expect(find.text('Waiting for the agent to continue…'), findsOneWidget);
|
|
held.complete(const {});
|
|
await tester.pumpAndSettle();
|
|
});
|
|
|
|
testWidgets('a refused reply keeps the card pending and shows the server '
|
|
'reason', (tester) async {
|
|
final gateway = FakeChatGateway();
|
|
addTearDown(gateway.close);
|
|
gateway.history = (_) async => chatPage(const []);
|
|
gateway.reply = (_) async => throw StateError('request expired');
|
|
|
|
await tester.pumpWidget(
|
|
materialHost(
|
|
ChatThreadView(gateway: gateway, sessionId: 's', onBack: () {}),
|
|
),
|
|
);
|
|
await tester.pumpAndSettle();
|
|
gateway.emitRaw({
|
|
'type': 'chat_permission',
|
|
'chat_permission': permission(),
|
|
});
|
|
await tester.pumpAndSettle();
|
|
|
|
await tester.tap(find.text('Reject'));
|
|
await tester.pumpAndSettle();
|
|
|
|
expect(find.textContaining('request expired'), findsOneWidget);
|
|
expect(find.text('Approve bash'), findsOneWidget);
|
|
expect(find.text('Allow once'), findsOneWidget);
|
|
expect(find.text('Reject'), findsOneWidget);
|
|
});
|
|
|
|
testWidgets('a server resolution clears the controls and shows the recorded '
|
|
'decision', (tester) async {
|
|
final gateway = FakeChatGateway();
|
|
addTearDown(gateway.close);
|
|
gateway.history = (_) async => chatPage(const []);
|
|
|
|
await tester.pumpWidget(
|
|
materialHost(
|
|
ChatThreadView(gateway: gateway, sessionId: 's', onBack: () {}),
|
|
),
|
|
);
|
|
await tester.pumpAndSettle();
|
|
gateway.emitRaw({
|
|
'type': 'chat_permission',
|
|
'chat_permission': permission(),
|
|
});
|
|
await tester.pumpAndSettle();
|
|
expect(find.text('Allow once'), findsOneWidget);
|
|
|
|
gateway.emitRaw({
|
|
'type': 'chat_permission',
|
|
'chat_permission': permission(
|
|
resolved: true,
|
|
decision: 'once',
|
|
message: 'Another device allowed once.',
|
|
),
|
|
});
|
|
await tester.pumpAndSettle();
|
|
expect(find.text('Allowed once'), findsOneWidget);
|
|
expect(find.text('Another device allowed once.'), findsOneWidget);
|
|
expect(find.text('Allow once'), findsNothing);
|
|
});
|
|
|
|
testWidgets('a turn waiting on a pending card hides the running indicator '
|
|
'but keeps Stop', (tester) async {
|
|
final gateway = FakeChatGateway();
|
|
addTearDown(gateway.close);
|
|
gateway.history = (_) async => chatPage(const []);
|
|
|
|
await tester.pumpWidget(
|
|
materialHost(
|
|
ChatThreadView(gateway: gateway, sessionId: 's', onBack: () {}),
|
|
),
|
|
);
|
|
await tester.pumpAndSettle();
|
|
gateway.emitRaw({
|
|
'type': 'chat_permission',
|
|
'chat_permission': permission(),
|
|
});
|
|
gateway.emitEvent(chatStepFrame('running'));
|
|
await tester.pumpAndSettle();
|
|
|
|
expect(find.text('Approve bash'), findsOneWidget);
|
|
expect(find.byTooltip('Stop'), findsOneWidget);
|
|
|
|
gateway.emitRaw({
|
|
'type': 'chat_permission',
|
|
'chat_permission': permission(resolved: true, decision: 'once'),
|
|
});
|
|
await tester.pumpAndSettle();
|
|
|
|
// No filler line while the turn runs; Stop is the running signal.
|
|
expect(find.byKey(const Key('chat-running')), findsNothing);
|
|
expect(find.byTooltip('Stop'), findsOneWidget);
|
|
});
|
|
|
|
testWidgets('consecutive Material cards stay separate surfaces', (
|
|
tester,
|
|
) async {
|
|
final gateway = FakeChatGateway();
|
|
addTearDown(gateway.close);
|
|
gateway.history = (_) async => chatPage(const []);
|
|
|
|
await tester.pumpWidget(
|
|
materialHost(
|
|
ChatThreadView(gateway: gateway, sessionId: 's', onBack: () {}),
|
|
),
|
|
);
|
|
await tester.pumpAndSettle();
|
|
gateway.emitRaw({
|
|
'type': 'chat_permission',
|
|
'chat_permission': permission(id: 'req-1'),
|
|
});
|
|
gateway.emitRaw({
|
|
'type': 'chat_permission',
|
|
'chat_permission': permission(id: 'req-2', action: 'python'),
|
|
});
|
|
await tester.pumpAndSettle();
|
|
|
|
final first = tester.getRect(
|
|
find
|
|
.descendant(
|
|
of: find.byType(Card).at(0),
|
|
matching: find.byType(Material),
|
|
)
|
|
.first,
|
|
);
|
|
final second = tester.getRect(
|
|
find
|
|
.descendant(
|
|
of: find.byType(Card).at(1),
|
|
matching: find.byType(Material),
|
|
)
|
|
.first,
|
|
);
|
|
expect(second.top - first.bottom, greaterThanOrEqualTo(12));
|
|
});
|
|
|
|
testWidgets(
|
|
'a Cupertino card lines up with the message bubbles',
|
|
(tester) async {
|
|
final gateway = FakeChatGateway();
|
|
addTearDown(gateway.close);
|
|
gateway.history = (_) async => chatPage([
|
|
chatMessage(
|
|
'u1',
|
|
'user',
|
|
parts: [
|
|
{'type': 'text', 'text': 'Show me the card'},
|
|
],
|
|
),
|
|
]);
|
|
await tester.pumpWidget(
|
|
CupertinoApp(
|
|
home: CupertinoPageScaffold(
|
|
child: ChatThreadView(
|
|
gateway: gateway,
|
|
sessionId: 's',
|
|
onBack: () {},
|
|
),
|
|
),
|
|
),
|
|
);
|
|
await tester.pumpAndSettle();
|
|
gateway.emitRaw({
|
|
'type': 'chat_permission',
|
|
'chat_permission': permission(),
|
|
});
|
|
await tester.pumpAndSettle();
|
|
|
|
final bubble = tester.getRect(
|
|
find.ancestor(
|
|
of: find.text('Show me the card'),
|
|
matching: find.byType(ChatMessageView),
|
|
),
|
|
);
|
|
// The card's own box includes the section margin, so measure its body.
|
|
final body = tester.getRect(
|
|
find
|
|
.descendant(
|
|
of: find.byType(ChatPermissionCard),
|
|
matching: find.byWidgetPredicate(
|
|
(widget) =>
|
|
widget is Padding &&
|
|
widget.padding == const EdgeInsets.all(16),
|
|
),
|
|
)
|
|
.first,
|
|
);
|
|
expect(body.left, bubble.left);
|
|
expect(body.right, bubble.right);
|
|
},
|
|
variant: TargetPlatformVariant.only(TargetPlatform.iOS),
|
|
);
|
|
}
|