Files
pipelines/app/test/features/chat/conversation/chat_transcript_cache_test.dart
T
alan 0a19ef229f Show a reopened chat's last transcript while it refreshes
ChatScreen keeps a bounded in-memory cache of recently left transcripts
(16 chats / 4000 messages, LRU). A reopened chat is seeded from it with no
loading state, still re-subscribes and re-reads, and the newest page replaces
the cached copy while live frames received during the read are kept. /close
removes the entry; only transcripts backed by a successful read on the
current connection are written.

Adds tool/chat_reopen_probe.mjs and an optional history delay in the loopback
fixture. Measurement shows a second cost the cache does not remove: opening at
the end of the top-anchored transcript lays out every row (notes).
2026-10-24 18:14:27 +01:00

226 lines
7.1 KiB
Dart

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 'package:pipelines_app/features/chat/conversation/chat_transcript_cache.dart';
import 'package:pipelines_app/features/chat/domain/chat_transcript.dart';
import 'chat_thread_fixtures.dart';
JsonMap _text(String id, String role, String text) => chatMessage(
id,
role,
parts: [
{'type': 'text', 'id': 'p-$id', 'text': text},
],
);
ChatTranscriptSnapshot _snapshot(int count, {String prefix = 'm'}) =>
ChatTranscriptSnapshot(
messages: [
for (var i = 0; i < count; i++) chatMessage('$prefix$i', 'user'),
],
);
List<Object?> _ids(List<JsonMap> messages) => [
for (final message in messages) message['id'],
];
void main() {
group('ChatTranscriptCache', () {
test('keeps the most recently used sessions within the session bound', () {
final cache = ChatTranscriptCache(maxSessions: 3, maxMessages: 100);
for (final id in ['a', 'b', 'c']) {
cache.write(id, _snapshot(1));
}
// Reading marks a conversation recently used, so it outlives b.
expect(cache.read('a'), isNotNull);
cache.write('d', _snapshot(1));
expect(cache.sessionIds, ['c', 'a', 'd']);
expect(cache.read('b'), isNull);
});
test('evicts the least recently used until the message bound holds', () {
final cache = ChatTranscriptCache(maxSessions: 10, maxMessages: 10);
cache.write('a', _snapshot(4));
cache.write('b', _snapshot(4));
cache.write('c', _snapshot(4));
expect(cache.sessionIds, ['b', 'c']);
expect(cache.messageCount, 8);
// Rewriting one conversation replaces its count instead of adding to it.
cache.write('b', _snapshot(2));
expect(cache.messageCount, 6);
expect(cache.sessionIds, ['c', 'b']);
});
test('never keeps a transcript larger than the whole bound', () {
final cache = ChatTranscriptCache(maxSessions: 10, maxMessages: 10);
cache.write('a', _snapshot(3));
cache.write('a', _snapshot(11));
expect(cache.read('a'), isNull);
expect(cache.messageCount, 0);
});
test('remove and clear forget transcripts and their counts', () {
final cache = ChatTranscriptCache();
cache.write('a', _snapshot(2));
cache.write('b', _snapshot(3));
cache.remove('a');
expect(cache.sessionIds, ['b']);
expect(cache.messageCount, 3);
cache.clear();
expect(cache.sessionIds, isEmpty);
expect(cache.messageCount, 0);
});
});
test('refreshCachedChatHistory lets the page decide and keeps live '
'arrivals', () {
final held = [
_text('gone', 'user', 'deleted on the server'),
_text('u1', 'user', 'cached question'),
_text('a1', 'assistant', 'cached stale answer'),
_text('live', 'assistant', 'arrived after reopening'),
];
final page = {
'messages': [
_text('u1', 'user', 'cached question'),
_text('a1', 'assistant', 'authoritative answer'),
_text('u2', 'user', 'sent from another client'),
],
'nextCursor': 'next',
'hasMore': true,
};
final merged = refreshCachedChatHistory(held, page, {'gone', 'u1', 'a1'});
expect(_ids(merged['messages'] as List<JsonMap>), [
'u1',
'a1',
'u2',
'live',
]);
expect(
((merged['messages'] as List<JsonMap>)[1]['parts'] as List)
.single['text'],
'authoritative answer',
);
expect(merged['nextCursor'], 'next');
expect(merged['hasMore'], isTrue);
});
group('a controller reopened on a cached transcript', () {
late FakeChatGateway gateway;
late ChatThreadController controller;
final cached = ChatTranscriptSnapshot(
messages: [
_text('u1', 'user', 'question'),
_text('a', 'assistant', 'cached answer'),
],
cursor: 'cached-cursor',
hasMore: true,
);
setUp(() {
gateway = FakeChatGateway();
controller = ChatThreadController(gateway, 's', cached: cached);
});
tearDown(() {
controller.dispose();
gateway.close();
});
test('shows the cached transcript before the read, then re-subscribes '
'and lets the newest page replace it', () async {
expect(controller.loaded, isTrue);
expect(controller.showingCached, isTrue);
expect(_ids(controller.messages), ['u1', 'a']);
// A cached transcript is not backed by a read on this connection.
expect(controller.snapshot, isNull);
final load = controller.load();
await pumpEventQueue();
expect(gateway.calls.map((call) => call.type), [
'chat_subscribe',
'chat_messages',
]);
expect(controller.loading, isTrue);
expect(_ids(controller.messages), ['u1', 'a']);
gateway.historyRequests.single.complete(
chatPage([
_text('a', 'assistant', 'fresh answer'),
_text('u2', 'user', 'newer question'),
]),
);
await load;
expect(controller.showingCached, isFalse);
expect(controller.loading, isFalse);
expect(_ids(controller.messages), ['a', 'u2']);
expect(
(controller.messages.first['parts'] as List).single['text'],
'fresh answer',
);
expect(controller.cursor, '');
expect(controller.hasMore, isFalse);
expect(_ids(controller.snapshot!.messages), ['a', 'u2']);
});
test('keeps a live frame that arrives while the read is pending', () async {
final load = controller.load();
await pumpEventQueue();
gateway.emitEvent(chatTextFrame('streamed reply', messageId: 'live'));
await pumpEventQueue();
expect(_ids(controller.messages), ['u1', 'a', 'live']);
gateway.historyRequests.single.complete(
chatPage([
_text('u1', 'user', 'question'),
_text('a', 'assistant', 'cached answer'),
]),
);
await load;
expect(_ids(controller.messages), ['u1', 'a', 'live']);
expect(
(controller.messages.last['parts'] as List).single['text'],
'streamed reply',
);
expect(controller.running, isTrue);
});
test('a refused read keeps the cached transcript with its error and '
'offers nothing to cache', () async {
gateway.history = (_) async => throw StateError('offline');
await controller.load();
expect(controller.error, contains('offline'));
expect(_ids(controller.messages), ['u1', 'a']);
expect(controller.snapshot, isNull);
});
test('a socket gap withdraws the snapshot until the repair read', () async {
gateway.history = (_) async => chatPage([_text('a', 'assistant', 'x')]);
await controller.load();
expect(controller.snapshot, isNotNull);
final repaired = Completer<JsonMap>();
gateway.history = (_) => repaired.future;
final resync = controller.resync();
await pumpEventQueue();
expect(controller.snapshot, isNull);
repaired.complete(chatPage([_text('a', 'assistant', 'y')]));
await resync;
expect(controller.snapshot, isNotNull);
});
});
}