Merge branch 'main' into flutter/chat-messages

This commit is contained in:
2026-10-21 20:44:02 +01:00
41 changed files with 3618 additions and 222 deletions
@@ -0,0 +1,154 @@
import 'dart:async';
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/core/api_gateway.dart';
import 'package:pipelines_app/features/chat/conversation/chat_thread_controller.dart';
import 'chat_thread_fixtures.dart';
void main() {
late FakeChatGateway gateway;
late ChatThreadController controller;
setUp(() {
gateway = FakeChatGateway();
controller = ChatThreadController(gateway, 's');
});
tearDown(() {
controller.dispose();
gateway.close();
});
test(
'subscribes the exact session, then reads newest history with all data',
() async {
final unknown = chatMessage(
'a',
'assistant',
parts: [
{
'type': 'future_part',
'id': 'p1',
'payload': {'nested': true},
'unknown_field': 7,
},
],
)..['future_message_field'] = 'keep';
gateway.history = (_) async =>
chatPage([unknown], cursor: 'opaque/next?x=1', hasMore: true);
await controller.load();
expect(gateway.calls.map((call) => call.type), [
'chat_subscribe',
'chat_messages',
]);
expect(gateway.calls.first.fields, {
'chat_subscribe': {'session_id': 's'},
});
expect(gateway.calls.last.fields['chat_query'], {
'session_id': 's',
'limit': 200,
'cursor': '',
});
expect(controller.loaded, isTrue);
expect(controller.loading, isFalse);
expect(controller.error, isNull);
expect(controller.running, isFalse);
expect(controller.hasMore, isTrue);
expect(controller.cursor, 'opaque/next?x=1');
expect(controller.messages.single, unknown);
expect(controller.messages.single['future_message_field'], 'keep');
},
);
test(
'loadOlder passes the opaque cursor back and prepends the page',
() async {
gateway.history = (_) async => chatPage(
[chatMessage('b', 'user')],
cursor: 'older-1',
hasMore: true,
);
await controller.load();
final olderReply = Completer<JsonMap>();
gateway.history = (_) => olderReply.future;
final loadingStates = <bool>[];
controller.addListener(() => loadingStates.add(controller.loading));
final older = controller.loadOlder();
expect(gateway.calls.last.fields['chat_query'], {
'session_id': 's',
'limit': 200,
'cursor': 'older-1',
});
expect(controller.loading, isTrue);
expect(loadingStates, [true]);
olderReply.complete(
chatPage(
[chatMessage('a', 'assistant')],
cursor: 'last',
hasMore: false,
),
);
await older;
expect(controller.messages.map((item) => item['id']), ['a', 'b']);
expect(controller.cursor, 'last');
expect(controller.hasMore, isFalse);
expect(controller.loading, isFalse);
},
);
test(
'a superseded history reply never replaces the newer transcript',
() async {
final first = Completer<JsonMap>();
final second = Completer<JsonMap>();
var request = 0;
gateway.history = (_) => request++ == 0 ? first.future : second.future;
final stale = controller.load();
await pumpEventQueue();
final current = controller.load();
await pumpEventQueue();
second.complete(chatPage([chatMessage('new', 'user')]));
await current;
expect(controller.messages.single['id'], 'new');
first.complete(chatPage([chatMessage('old', 'user')]));
await stale;
expect(controller.messages.single['id'], 'new');
expect(controller.loaded, isTrue);
expect(controller.loading, isFalse);
},
);
test(
'a failed history read reports the error, never an empty success',
() async {
gateway.history = (_) => Future.error(StateError('history unavailable'));
await controller.load();
expect(controller.error, contains('history unavailable'));
expect(controller.error, isNot(''));
expect(controller.messages, isEmpty);
expect(controller.loading, isFalse);
expect(controller.loaded, isTrue);
},
);
test('a refused subscribe leaves history usable', () async {
gateway.subscribe = () => Future.error(StateError('not live'));
gateway.history = (_) async => chatPage([chatMessage('a', 'user')]);
await controller.load();
expect(controller.messages.single['id'], 'a');
expect(controller.error, isNull);
expect(controller.loaded, isTrue);
});
}
@@ -0,0 +1,73 @@
import 'dart:async';
import 'package:pipelines_app/core/api_gateway.dart';
/// A fake gateway whose subscribe/history replies the test controls.
class FakeChatGateway implements ApiGateway {
final calls = <({String type, JsonMap fields})>[];
final historyRequests = <Completer<JsonMap>>[];
final _frames = StreamController<JsonMap>.broadcast();
Future<JsonMap> Function(JsonMap fields)? history;
Future<JsonMap> Function()? subscribe;
void Function()? onSubscribe;
@override
Future<JsonMap> call(String type, [JsonMap fields = const {}]) async {
calls.add((type: type, fields: fields));
switch (type) {
case 'chat_subscribe':
onSubscribe?.call();
return subscribe == null ? <String, dynamic>{} : subscribe!();
case 'chat_messages':
final completer = Completer<JsonMap>();
historyRequests.add(completer);
if (history != null) return history!(fields);
return completer.future;
}
return <String, dynamic>{};
}
@override
Stream<JsonMap> get frames => _frames.stream;
void emitEvent(JsonMap body) {
_frames.add({'type': 'chat_event', 'chat_event': body});
}
void emitRaw(JsonMap envelope) => _frames.add(envelope);
void close() => _frames.close();
}
JsonMap chatPage(
List<JsonMap> messages, {
String cursor = '',
bool hasMore = false,
}) => {
'chat_history': {
'messages': messages,
'next_cursor': cursor,
'has_more': hasMore,
},
};
JsonMap chatMessage(String id, String role, {List<JsonMap> parts = const []}) =>
{'id': id, 'role': role, 'parts': parts};
JsonMap chatTextFrame(
String text, {
String session = 's',
String messageId = 'a',
}) => {
'session_id': session,
'message_id': messageId,
'kind': 'text',
'part': {'id': 'p', 'type': 'text'},
'delta': text,
};
JsonMap chatStepFrame(String status, {String session = 's'}) => {
'session_id': session,
'kind': 'step',
'step': {'status': status, 'turn_id': 'turn', 'intermediate': false},
};
@@ -0,0 +1,188 @@
import 'dart:async';
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/core/api_gateway.dart';
import 'package:pipelines_app/features/chat/conversation/chat_thread_controller.dart';
import 'chat_thread_fixtures.dart';
void main() {
late FakeChatGateway gateway;
late ChatThreadController controller;
setUp(() {
gateway = FakeChatGateway();
controller = ChatThreadController(gateway, 's');
});
tearDown(() {
controller.dispose();
gateway.close();
});
test('folds own session frames only and keeps live turn activity', () async {
gateway.history = (_) async => chatPage([
chatMessage(
'a',
'assistant',
parts: [
{'type': 'reasoning', 'id': 'r', 'text': 'held'},
],
),
]);
await controller.load();
var notifications = 0;
controller.addListener(() => notifications++);
gateway.emitEvent(chatTextFrame('foreign', session: 'other'));
gateway.emitEvent(chatTextFrame('nodata')..remove('session_id'));
gateway.emitRaw({'type': 'run_event', 'session_id': 's'});
await pumpEventQueue();
expect(notifications, 0);
expect(controller.messages.single['parts'], [
{'type': 'reasoning', 'id': 'r', 'text': 'held'},
]);
expect(controller.running, isFalse);
gateway.emitEvent(chatTextFrame('one'));
gateway.emitEvent(chatTextFrame(' two'));
await pumpEventQueue();
expect(controller.running, isTrue);
expect(controller.messages.single['parts'], [
{'type': 'reasoning', 'id': 'r', 'text': 'held'},
{'type': 'text', 'id': 'p', 'text': 'one two'},
]);
gateway.emitEvent(chatStepFrame('ended'));
await pumpEventQueue();
expect(controller.running, isFalse);
expect(notifications, greaterThan(0));
});
test(
'resync re-subscribes, settles the held turn, and replaces it with the page',
() async {
gateway.history = (_) async => chatPage(
[
chatMessage('stale-user', 'user'),
chatMessage('stale-assistant', 'assistant'),
],
cursor: 'stale-cursor',
hasMore: true,
);
await controller.load();
gateway.emitEvent(chatTextFrame('still running'));
await pumpEventQueue();
expect(controller.running, isTrue);
gateway.onSubscribe = () {
// Settled before the re-attach, then replay proves the fresh turn.
expect(controller.running, isFalse);
gateway.emitEvent(chatStepFrame('started'));
};
gateway.history = (_) async => chatPage(
[
chatMessage('fresh-user', 'user'),
chatMessage('fresh-assistant', 'assistant'),
],
cursor: 'fresh-cursor',
hasMore: false,
);
await controller.resync();
await pumpEventQueue();
expect(
gateway.calls.where((call) => call.type == 'chat_subscribe').length,
2,
);
expect(
gateway.calls.where((call) => call.type == 'chat_messages').length,
2,
);
expect(gateway.calls.last.fields['chat_query'], {
'session_id': 's',
'limit': 200,
'cursor': '',
});
expect(controller.messages.map((item) => item['id']), [
'fresh-user',
'fresh-assistant',
]);
expect(controller.cursor, 'fresh-cursor');
expect(controller.hasMore, isFalse);
expect(controller.running, isTrue);
expect(controller.error, isNull);
},
);
test(
'a failed resync keeps replayed activity and reports the error',
() async {
var attempt = 0;
gateway.history = (_) async {
attempt++;
if (attempt == 1) return chatPage([chatMessage('held', 'user')]);
throw StateError('resync unavailable');
};
await controller.load();
gateway.onSubscribe = () {
gateway.emitEvent(chatStepFrame('started'));
};
await controller.resync();
await pumpEventQueue();
expect(controller.messages.single['id'], 'held');
expect(controller.running, isTrue);
expect(controller.error, contains('resync unavailable'));
expect(controller.loading, isFalse);
},
);
test(
'a resync frame reattaches and replaces the new authoritative page',
() async {
var attempt = 0;
gateway.history = (_) async => attempt++ == 0
? chatPage([chatMessage('held', 'user')], hasMore: true)
: chatPage([chatMessage('fresh', 'assistant')]);
await controller.load();
gateway.emitEvent({'session_id': 's', 'kind': 'resync'});
await pumpEventQueue();
expect(
gateway.calls.where((call) => call.type == 'chat_subscribe').length,
2,
);
expect(controller.messages.single['id'], 'fresh');
expect(controller.hasMore, isFalse);
},
);
test(
'disposal ignores a late reply and never invents an unsubscribe',
() async {
final pending = Completer<JsonMap>();
gateway.history = (_) => pending.future;
var notifications = 0;
controller.addListener(() => notifications++);
final load = controller.load();
await pumpEventQueue();
final before = notifications;
controller.dispose();
pending.complete(chatPage([chatMessage('late', 'user')]));
await load;
expect(notifications, before);
expect(
gateway.calls.where((call) => call.type == 'chat_unsubscribe'),
isEmpty,
);
// Keep tearDown's dispose idempotent.
controller = ChatThreadController(gateway, 's');
},
);
}
@@ -0,0 +1,27 @@
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/features/chat/conversation/chat_thread_controller.dart';
import 'chat_thread_fixtures.dart';
void main() {
test('readable history never hides a refused live subscription', () async {
final gateway = FakeChatGateway();
gateway.subscribe = () async {
throw StateError('live watch denied');
};
gateway.history = (_) async =>
chatPage([chatMessage('stored', 'assistant')]);
addTearDown(gateway.close);
final controller = ChatThreadController(gateway, 's');
addTearDown(controller.dispose);
await controller.load();
expect(controller.messages.single['id'], 'stored');
expect(controller.error, isNull);
expect(controller.subscribed, isFalse);
expect(controller.subscriptionError, contains('live watch denied'));
gateway.subscribe = () async => {};
await controller.resync();
expect(controller.subscribed, isTrue);
expect(controller.subscriptionError, isNull);
});
}