import 'package:flutter_test/flutter_test.dart'; import 'package:pipelines_app/features/attention/domain/attention_acks.dart'; import 'package:pipelines_app/features/attention/runtime/attention_ack_queue.dart'; import 'package:pipelines_app/features/attention/runtime/attention_ack_sync.dart'; import 'package:pipelines_app/features/attention/runtime/attention_controller.dart'; import 'package:pipelines_app/features/attention/runtime/attention_store.dart'; import 'fake_ack_server.dart'; final _now = DateTime(2026, 10, 22, 12); Map _failed(int id) => { 'id': id, 'name': 'release', 'title': 'Run $id', 'status': 'failed', 'created_at': _now.subtract(const Duration(hours: 1)).toIso8601String(), 'finished_at': _now.subtract(const Duration(minutes: 30)).toIso8601String(), }; /// One device: its gateway, sync, local stores and Needs-you controller. class _Device { _Device(FakeAckServer server) : client = server.connect(), store = MemoryAttentionStore(), queue = MemoryAttentionAckQueue() { sync = AttentionAckSync(gateway: client, queue: queue); attention = AttentionController(store: store, sync: sync, now: () => _now); } final FakeAckClient client; final MemoryAttentionStore store; final MemoryAttentionAckQueue queue; late final AttentionAckSync sync; late final AttentionController attention; Future start(List> rows) async { await sync.load(); await attention.load(); attention.seedRows(rows); await sync.connected(); } List get shown => [for (final e in attention.entries) e.runId]; void dispose() { attention.dispose(); sync.dispose(); } } void main() { late FakeAckServer server; late _Device web; late _Device phone; final rows = [_failed(1), _failed(2), _failed(3)]; setUp(() async { server = FakeAckServer(); web = _Device(server); phone = _Device(server); await web.start(rows); await phone.start(rows); }); tearDown(() { web.dispose(); phone.dispose(); }); test( 'a dismissal on one device disappears on the other via the push', () async { expect(phone.shown, [3, 2, 1]); await web.attention.dismiss( web.attention.entries.firstWhere((e) => e.runId == 2), ); await settle(); expect(web.shown, [3, 1]); expect(phone.shown, [3, 1]); expect(server.state.dismissed, {'2:Failed'}); // The other device caches the shared identity locally for offline use. expect(phone.store.stored, contains('2:Failed')); // The receiving device did not send anything back. expect(phone.client.count('ack_attention'), 0); }, ); test('Clear all on the web clears the phone too', () async { final snapshot = web.attention.entries; await web.attention.clearAll(snapshot); await settle(); expect(web.shown, isEmpty); expect(phone.shown, isEmpty); expect(server.state.dismissed, {'1:Failed', '2:Failed', '3:Failed'}); }); test('a device that connects later loads the shared set', () async { await web.attention.dismiss(web.attention.entries.first); await settle(); final late = _Device(server); addTearDown(late.dispose); await late.start(rows); await settle(); expect(late.shown, [2, 1]); }); test( 'a dismissal made offline is queued, then synced on reconnect', () async { phone.client.online = false; await phone.attention.dismiss(phone.attention.entries.first); await settle(); expect(phone.shown, [2, 1]); expect(web.shown, [3, 2, 1]); expect(phone.sync.pending.dismissed, {'3:Failed'}); expect(AttentionAcks.decode(phone.queue.stored).dismissed, {'3:Failed'}); // A restarted app reads the persisted queue. final restarted = AttentionAckSync( gateway: phone.client, queue: phone.queue, ); addTearDown(restarted.dispose); await restarted.load(); expect(restarted.pending.dismissed, {'3:Failed'}); phone.client.online = true; await phone.sync.connected(); await settle(); expect(phone.sync.pending.isEmpty, isTrue); expect(AttentionAcks.decode(phone.queue.stored).isEmpty, isTrue); expect(web.shown, [2, 1]); }, ); test('a refused batch is dropped; a legacy server keeps the queue', () async { server.refuse = 'invalid attention identity'; await web.sync.acknowledge(dismissed: ['9:Failed']); expect(web.sync.pending.isEmpty, isTrue); server ..refuse = null ..legacy = true; await web.sync.connected(); expect(web.sync.supported, isFalse); await web.attention.dismiss(web.attention.entries.first); await settle(); expect(web.shown, [2, 1], reason: 'the local dismissal still applies'); expect(web.sync.pending.dismissed, {'3:Failed'}); server.legacy = false; await web.sync.connected(); await settle(); expect(web.sync.pending.isEmpty, isTrue); expect(phone.shown, [2, 1]); }); test('batches stay within the server bound', () { final big = AttentionAcks( dismissed: {for (var i = 1; i <= 600; i++) '$i:Failed'}, chatSeen: const {'ses_a': 1}, ); final batch = attentionAckBatch(big); expect(batch.length, maxAttentionAckItems); final rest = big.without(batch); expect(rest.length, big.length - maxAttentionAckItems); }); test('the send-only path matches replies and refusals by id', () async { final client = server.connect(); final sync = AttentionAckSync( gateway: client, queue: MemoryAttentionAckQueue(), sendOnly: client.sendOnly, ); addTearDown(sync.dispose); await sync.acknowledge(dismissed: ['1:Failed']); await settle(); expect(sync.pending.isEmpty, isTrue); expect(phone.shown, [3, 2]); server.refuse = 'invalid attention identity'; await sync.acknowledge(dismissed: ['2:Failed']); await settle(); expect(sync.pending.isEmpty, isTrue, reason: 'a refusal is dropped'); server.refuse = null; await web.attention.dismiss(web.attention.entries.first); await settle(); await sync.connected(); expect(sync.acks.dismissed, containsAll(['1:Failed', '3:Failed'])); }); }