114 lines
3.5 KiB
Dart
114 lines
3.5 KiB
Dart
import 'dart:async';
|
|
|
|
import 'package:pipelines_app/core/api_gateway.dart';
|
|
import 'package:pipelines_app/core/transport/connection_state.dart';
|
|
import 'package:pipelines_app/features/attention/domain/attention_acks.dart';
|
|
|
|
/// An in-memory stand-in for the server's `attention_acks` / `ack_attention`
|
|
/// protocol with any number of connected clients. Like the Go handler, an ack
|
|
/// that changes the set is pushed to every *other* connected client as an
|
|
/// `attention_acks_changed` delta.
|
|
class FakeAckServer {
|
|
AttentionAcks state = const AttentionAcks();
|
|
final clients = <FakeAckClient>[];
|
|
|
|
/// When set, every ack_attention is refused with this reason.
|
|
String? refuse;
|
|
|
|
/// When true the server predates shared acks and answers `pong`.
|
|
bool legacy = false;
|
|
|
|
/// The chat list this server reports, for chat-list controllers.
|
|
List<JsonMap> chatSessions = const [];
|
|
|
|
FakeAckClient connect() {
|
|
final client = FakeAckClient(this);
|
|
clients.add(client);
|
|
return client;
|
|
}
|
|
|
|
JsonMap _reply() => {
|
|
'type': 'attention_acks',
|
|
'attention_acks': state.toJson(),
|
|
};
|
|
|
|
JsonMap _ack(FakeAckClient from, JsonMap fields) {
|
|
final incoming = AttentionAcks.fromJson(fields['attention_acks']);
|
|
final delta = AttentionAcks(
|
|
dismissed: incoming.dismissed.difference(state.dismissed),
|
|
chatSeen: {
|
|
for (final entry in incoming.chatSeen.entries)
|
|
if (entry.value > (state.chatSeen[entry.key] ?? 0))
|
|
entry.key: entry.value,
|
|
},
|
|
);
|
|
state = state.merge(incoming);
|
|
if (!delta.isEmpty) {
|
|
for (final client in clients) {
|
|
if (identical(client, from) || !client.online) continue;
|
|
client.pushed.add({
|
|
'type': 'attention_acks_changed',
|
|
'attention_acks': delta.toJson(),
|
|
});
|
|
}
|
|
}
|
|
return _reply();
|
|
}
|
|
}
|
|
|
|
class FakeAckClient implements ApiGateway {
|
|
FakeAckClient(this.server);
|
|
|
|
final FakeAckServer server;
|
|
final pushed = StreamController<JsonMap>.broadcast();
|
|
final calls = <String>[];
|
|
bool online = true;
|
|
|
|
@override
|
|
Stream<JsonMap> get frames => pushed.stream;
|
|
|
|
@override
|
|
Future<JsonMap> call(String type, [JsonMap fields = const {}]) async {
|
|
calls.add(type);
|
|
if (!online) throw const NotConnectedError();
|
|
switch (type) {
|
|
case 'attention_acks':
|
|
case 'ack_attention':
|
|
if (server.legacy) return {'type': 'pong'};
|
|
if (type == 'attention_acks') return server._reply();
|
|
final reason = server.refuse;
|
|
if (reason != null) throw ProtocolError(reason);
|
|
return server._ack(this, fields);
|
|
case 'chat_sessions':
|
|
return {'type': 'chat_sessions', 'chat_sessions': server.chatSessions};
|
|
}
|
|
return {'type': 'pong'};
|
|
}
|
|
|
|
int count(String type) => calls.where((call) => call == type).length;
|
|
|
|
var _sequence = 0;
|
|
|
|
/// The socket's send-only path: the reply (or error) arrives later as a
|
|
/// frame carrying the request id, like the real transport.
|
|
String sendOnly(String type, JsonMap fields) {
|
|
if (!online) throw const NotConnectedError();
|
|
final id = 'send-${++_sequence}';
|
|
scheduleMicrotask(() async {
|
|
try {
|
|
pushed.add({...await call(type, fields), 'id': id});
|
|
} on ProtocolError catch (error) {
|
|
pushed.add({'type': 'error', 'id': id, 'error': error.message});
|
|
}
|
|
});
|
|
return id;
|
|
}
|
|
}
|
|
|
|
/// Lets queued microtasks and stream deliveries settle.
|
|
Future<void> settle() async {
|
|
for (var i = 0; i < 10; i++) {
|
|
await Future<void>.delayed(Duration.zero);
|
|
}
|
|
}
|