Serialize open-chat sync writes by server revision and fan out prunes
Server: chat_open_workspace is a compare-and-swap on base_revision; a stale write is refused and answered with the current snapshot (rejected: true). Each stored change increments the revision; identical writes store nothing. A request with no body reads the set. Seeds apply only to a never-stored set. Validation uses the operator registry (recorded, not closed). chat_close and connection-time pruning store a new revision and push it to every connection; otherwise a new connection gets the current set to catch up. App: ChatOpenWorkspaceController keeps one write in flight, coalesces later changes, sends from the last replied revision and ignores lower revisions; pushes and rejected replies win over unsent changes. It starts after the local layout restores (seed or read), keeps a deep-linked chat, and is disposed on server/gateway rebind. Remote membership is applied by reconcileChatWorkspaceTree, keeping pane ids and split sizes. Federated lists keep their local layout. Tests: Go store/handler fan-out tests; app controller, reconcile and screen sync tests. Notes record a live two-client scratch check.
This commit is contained in:
@@ -46,9 +46,7 @@ mixin _ChatScreenFloat on State<ChatScreen>, _ChatScreenWorkspace {
|
||||
final pane = _workspace.detach(paneId);
|
||||
if (pane == null) return;
|
||||
widget.windows?.float(pane.sessionId);
|
||||
if (!_applyingServerWorkspace) {
|
||||
unawaited(_openWorkspace?.replace(_serverWorkspaceEntries()));
|
||||
}
|
||||
_syncOpenWorkspace();
|
||||
// Floating the last tiled chat leaves the list, as closing it does.
|
||||
if (_workspace.paneCount == 0) _back();
|
||||
}
|
||||
@@ -64,9 +62,7 @@ mixin _ChatScreenFloat on State<ChatScreen>, _ChatScreenWorkspace {
|
||||
_floatPane(pane.id);
|
||||
} else {
|
||||
windows.float(id);
|
||||
if (!_applyingServerWorkspace) {
|
||||
unawaited(_openWorkspace?.replace(_serverWorkspaceEntries()));
|
||||
}
|
||||
_syncOpenWorkspace();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -75,9 +71,7 @@ mixin _ChatScreenFloat on State<ChatScreen>, _ChatScreenWorkspace {
|
||||
_workspaceVisible = true;
|
||||
if (!_pageOpen && showsListBesideDetail(context)) _usedWorkspace = true;
|
||||
_workspace.dock(sessionId);
|
||||
if (!_applyingServerWorkspace) {
|
||||
unawaited(_openWorkspace?.replace(_serverWorkspaceEntries()));
|
||||
}
|
||||
_syncOpenWorkspace();
|
||||
_composerFocus.request(sessionId);
|
||||
}
|
||||
|
||||
|
||||
@@ -101,12 +101,42 @@ mixin _ChatScreenWorkspace on State<ChatScreen> {
|
||||
}
|
||||
}
|
||||
|
||||
/// Sends this device's open chats to the server, unless the change is the
|
||||
/// server's own snapshot being applied.
|
||||
void _syncOpenWorkspace() {
|
||||
if (_applyingServerWorkspace) return;
|
||||
_openWorkspace?.replace(_serverWorkspaceEntries());
|
||||
}
|
||||
|
||||
/// Binds the server's open-chat set for [widget.gateway], disposing the
|
||||
/// previous binding (its subscription and queued writes) first. A
|
||||
/// federated list spans several servers, so it keeps its local layout.
|
||||
void _bindOpenWorkspace({required Future<void> after}) {
|
||||
_openWorkspace?.dispose();
|
||||
_openWorkspace = null;
|
||||
_openWorkspaceApplied = false;
|
||||
if (!widget.persistWorkspace || widget.gateway is FederatedChatGateway) {
|
||||
return;
|
||||
}
|
||||
final open = ChatOpenWorkspaceController(gateway: widget.gateway)
|
||||
..onChanged = _applyOpenWorkspace;
|
||||
_openWorkspace = open;
|
||||
// Seed from the restored local layout once it is restored.
|
||||
unawaited(
|
||||
after.then((_) async {
|
||||
if (!mounted || open.disposed) return;
|
||||
await open.start(local: _serverWorkspaceEntries());
|
||||
}),
|
||||
);
|
||||
}
|
||||
|
||||
void _bindWorkspacePersistence() {
|
||||
if (!widget.persistWorkspace) return;
|
||||
if (!widget.persistWorkspace) {
|
||||
_bindOpenWorkspace(after: Future.value());
|
||||
return;
|
||||
}
|
||||
final scope = serverStorageScope(serverIdentity(widget.gateway));
|
||||
_workspaceScope = scope;
|
||||
_openWorkspace = ChatOpenWorkspaceController(gateway: widget.gateway)
|
||||
..onChanged = _applyOpenWorkspace;
|
||||
_workspaceBinding = ChatWorkspaceBinding(
|
||||
controller: _workspace,
|
||||
store: widget.gateway is FederatedChatGateway
|
||||
@@ -132,14 +162,35 @@ mixin _ChatScreenWorkspace on State<ChatScreen> {
|
||||
_publishWorkspaceRoute();
|
||||
},
|
||||
);
|
||||
unawaited(
|
||||
_workspaceBinding!.start(initialSessionId: widget.initialSessionId),
|
||||
_bindOpenWorkspace(
|
||||
after: _workspaceBinding!.start(
|
||||
initialSessionId: widget.initialSessionId,
|
||||
),
|
||||
);
|
||||
unawaited(_openWorkspace!.start(legacy: _serverWorkspaceEntries()));
|
||||
}
|
||||
|
||||
/// Whether a server snapshot was applied since binding. The first one keeps
|
||||
/// the chat this visit was opened on (a deep link) and adds it if absent.
|
||||
bool _openWorkspaceApplied = false;
|
||||
|
||||
/// Applies the server's membership: windows and panes for chats it no
|
||||
/// longer lists close, floating state follows it, and tiled chats take its
|
||||
/// order while this device's split geometry stays.
|
||||
void _applyOpenWorkspace(ChatOpenWorkspaceSnapshot snapshot) {
|
||||
if (!mounted) return;
|
||||
final initial = widget.initialSessionId ?? '';
|
||||
final first = !_openWorkspaceApplied;
|
||||
final keepInitial =
|
||||
first &&
|
||||
initial.isNotEmpty &&
|
||||
!snapshot.entries.any((entry) => entry.sessionId == initial);
|
||||
_openWorkspaceApplied = true;
|
||||
if (keepInitial) {
|
||||
snapshot = ChatOpenWorkspaceSnapshot(snapshot.revision, [
|
||||
...snapshot.entries,
|
||||
ChatOpenWorkspaceEntry(initial),
|
||||
]);
|
||||
}
|
||||
_applyingServerWorkspace = true;
|
||||
try {
|
||||
final windows = widget.windows;
|
||||
@@ -172,20 +223,44 @@ mixin _ChatScreenWorkspace on State<ChatScreen> {
|
||||
.where((entry) => !entry.floating)
|
||||
.map((entry) => entry.sessionId),
|
||||
);
|
||||
if (keepInitial) {
|
||||
final pane = _workspace.panes
|
||||
.where((pane) => pane.sessionId == initial)
|
||||
.firstOrNull;
|
||||
if (pane != null) _workspace.activate(pane.id);
|
||||
}
|
||||
if (_workspace.paneCount == 0 && _workspaceVisible) _back();
|
||||
} finally {
|
||||
_applyingServerWorkspace = false;
|
||||
}
|
||||
// The first snapshot shows the server's chats as a restored layout does;
|
||||
// later ones never pull this device into a chat another one opened.
|
||||
if (first && _workspace.paneCount > 0 && !_workspaceVisible) {
|
||||
setState(() {
|
||||
_usedWorkspace = true;
|
||||
_workspaceVisible = true;
|
||||
});
|
||||
_publishWorkspaceRoute();
|
||||
}
|
||||
if (keepInitial) _syncOpenWorkspace();
|
||||
}
|
||||
|
||||
bool _updateWorkspacePersistence(ChatScreen oldWidget) {
|
||||
final scope = serverStorageScope(serverIdentity(widget.gateway));
|
||||
if (oldWidget.persistWorkspace == widget.persistWorkspace &&
|
||||
(!widget.persistWorkspace || scope == _workspaceScope)) {
|
||||
// Another connection to the same server: only the open-chat sync
|
||||
// follows the gateway.
|
||||
if (widget.persistWorkspace &&
|
||||
!identical(oldWidget.gateway, widget.gateway)) {
|
||||
_bindOpenWorkspace(after: Future.value());
|
||||
}
|
||||
return false;
|
||||
}
|
||||
_workspaceBinding?.dispose();
|
||||
_workspaceBinding = null;
|
||||
_openWorkspace?.dispose();
|
||||
_openWorkspace = null;
|
||||
if (_workspaceScope != null && scope != _workspaceScope) {
|
||||
_workspace.restoreLayout(ChatWorkspaceSnapshot.fromLayout(null, null)!);
|
||||
_workspaceVisible = false;
|
||||
@@ -261,9 +336,7 @@ mixin _ChatScreenWorkspace on State<ChatScreen> {
|
||||
'${_workspace.activePaneId}:${_workspace.panes.map((p) => '${p.id}=${p.sessionId}').join(',')}';
|
||||
if (_workspaceSignature == signature) return;
|
||||
_workspaceSignature = signature;
|
||||
if (!_applyingServerWorkspace) {
|
||||
unawaited(_openWorkspace?.replace(_serverWorkspaceEntries()));
|
||||
}
|
||||
_syncOpenWorkspace();
|
||||
void update() {
|
||||
if (!mounted) return;
|
||||
setState(() {});
|
||||
|
||||
@@ -1,43 +1,115 @@
|
||||
import 'dart:async';
|
||||
import '../../../../core/api_gateway.dart';
|
||||
import '../../../core/api_gateway.dart';
|
||||
import 'chat_open_workspace_gateway.dart';
|
||||
|
||||
/// Keeps one device's open chats in step with the server's open-chat set.
|
||||
///
|
||||
/// Writes are serialized: one is in flight at a time, and changes made while
|
||||
/// it is pending coalesce into the latest full snapshot, sent next from the
|
||||
/// revision the reply reported. Every reply and push is reconciled by server
|
||||
/// revision, so a late or reordered one never overwrites newer state. A
|
||||
/// snapshot from another device (or a refused stale write) wins over local
|
||||
/// changes not yet sent, and reaches [onChanged].
|
||||
class ChatOpenWorkspaceController {
|
||||
ChatOpenWorkspaceController({required ApiGateway gateway})
|
||||
: _gateway = ChatOpenWorkspaceGateway(gateway);
|
||||
final ChatOpenWorkspaceGateway _gateway;
|
||||
StreamSubscription<ChatOpenWorkspaceSnapshot>? _subscription;
|
||||
int revision = 0;
|
||||
bool _disposed = false;
|
||||
bool _writing = false;
|
||||
List<ChatOpenWorkspaceEntry>? _pending;
|
||||
ChatOpenWorkspaceSnapshot? _current;
|
||||
|
||||
/// Applies a server snapshot to the device's panes and windows.
|
||||
void Function(ChatOpenWorkspaceSnapshot snapshot)? onChanged;
|
||||
|
||||
/// The latest server revision this device has seen; 0 before any.
|
||||
int get revision => _current?.revision ?? 0;
|
||||
|
||||
/// Whether the server answered, so local changes are sent. Before that (or
|
||||
/// against a server without the request) the device keeps its own layout.
|
||||
bool get ready => _current != null;
|
||||
|
||||
bool get disposed => _disposed;
|
||||
|
||||
/// Subscribes to pushes, then seeds the server from [local] (the device's
|
||||
/// restored layout, migrated once from the old local snapshot) or, with no
|
||||
/// local chats, reads the server's set. The server's answer is applied.
|
||||
Future<void> start({
|
||||
Iterable<ChatOpenWorkspaceEntry> legacy = const [],
|
||||
Iterable<ChatOpenWorkspaceEntry> local = const [],
|
||||
}) async {
|
||||
if (_subscription != null || _disposed) return;
|
||||
_subscription = _gateway.changes.listen((snapshot) {
|
||||
if (_disposed || snapshot.revision < revision) return;
|
||||
revision = snapshot.revision;
|
||||
onChanged?.call(snapshot);
|
||||
});
|
||||
if (legacy.isNotEmpty) {
|
||||
final snapshot = await _gateway.replace(legacy, seed: true);
|
||||
if (snapshot != null && snapshot.revision >= revision) {
|
||||
revision = snapshot.revision;
|
||||
onChanged?.call(snapshot);
|
||||
_subscription = _gateway.changes.listen(_accept);
|
||||
final entries = local.toList(growable: false);
|
||||
ChatOpenWorkspaceSnapshot? snapshot;
|
||||
try {
|
||||
snapshot = entries.isEmpty
|
||||
? await _gateway.read()
|
||||
: await _gateway.replace(entries, seed: true);
|
||||
} on Object {
|
||||
return;
|
||||
}
|
||||
if (snapshot != null) _accept(snapshot, force: true);
|
||||
}
|
||||
|
||||
/// Sends the device's full open-chat set. Ignored until [ready]; coalesced
|
||||
/// while a write is in flight.
|
||||
void replace(Iterable<ChatOpenWorkspaceEntry> entries) {
|
||||
if (_disposed || !ready) return;
|
||||
_pending = entries.toList(growable: false);
|
||||
if (!_writing) unawaited(_drain());
|
||||
}
|
||||
|
||||
Future<void> _drain() async {
|
||||
_writing = true;
|
||||
try {
|
||||
while (!_disposed) {
|
||||
final sent = _pending;
|
||||
_pending = null;
|
||||
if (sent == null) return;
|
||||
final current = _current;
|
||||
if (current != null && current.sameEntries(sent)) continue;
|
||||
ChatOpenWorkspaceSnapshot? reply;
|
||||
try {
|
||||
reply = await _gateway.replace(sent, baseRevision: revision);
|
||||
} on Object {
|
||||
reply = null;
|
||||
}
|
||||
if (_disposed || reply == null || reply.revision < revision) continue;
|
||||
if (reply.rejected) {
|
||||
// Another change landed first: the server's state wins over this
|
||||
// write and anything queued behind it.
|
||||
_accept(reply, force: true);
|
||||
} else {
|
||||
// The server may have left out closed or unknown chats. This device
|
||||
// keeps showing them (a closed chat can still be read here); the
|
||||
// other devices never receive them.
|
||||
_current = reply;
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
_writing = false;
|
||||
}
|
||||
}
|
||||
|
||||
Future<void> replace(Iterable<ChatOpenWorkspaceEntry> entries) async {
|
||||
void _accept(ChatOpenWorkspaceSnapshot snapshot, {bool force = false}) {
|
||||
if (_disposed) return;
|
||||
final snapshot = await _gateway.replace(entries);
|
||||
if (snapshot != null && snapshot.revision >= revision) {
|
||||
revision = snapshot.revision;
|
||||
final current = _current;
|
||||
if (current != null &&
|
||||
(snapshot.revision < current.revision ||
|
||||
(!force && snapshot.revision == current.revision))) {
|
||||
return;
|
||||
}
|
||||
_current = snapshot;
|
||||
_pending = null;
|
||||
onChanged?.call(snapshot);
|
||||
}
|
||||
|
||||
void dispose() {
|
||||
_disposed = true;
|
||||
_pending = null;
|
||||
onChanged = null;
|
||||
unawaited(_subscription?.cancel());
|
||||
_subscription = null;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,5 +1,7 @@
|
||||
import '../../../../core/api_gateway.dart';
|
||||
import '../../../core/api_gateway.dart';
|
||||
|
||||
/// One chat in the server-owned open-chat set: its session and whether it is
|
||||
/// floating. Geometry stays on the device.
|
||||
class ChatOpenWorkspaceEntry {
|
||||
const ChatOpenWorkspaceEntry(this.sessionId, {this.floating = false});
|
||||
final String sessionId;
|
||||
@@ -17,10 +19,31 @@ class ChatOpenWorkspaceEntry {
|
||||
}
|
||||
}
|
||||
|
||||
/// The complete open-chat set at one server revision. [rejected] marks the
|
||||
/// reply to a write from a stale base: the write was not applied and this is
|
||||
/// the current state.
|
||||
class ChatOpenWorkspaceSnapshot {
|
||||
const ChatOpenWorkspaceSnapshot(this.revision, this.entries);
|
||||
const ChatOpenWorkspaceSnapshot(
|
||||
this.revision,
|
||||
this.entries, {
|
||||
this.rejected = false,
|
||||
});
|
||||
final int revision;
|
||||
final List<ChatOpenWorkspaceEntry> entries;
|
||||
final bool rejected;
|
||||
|
||||
bool sameEntries(Iterable<ChatOpenWorkspaceEntry> other) {
|
||||
final list = other.toList(growable: false);
|
||||
if (list.length != entries.length) return false;
|
||||
for (var i = 0; i < list.length; i++) {
|
||||
if (list[i].sessionId != entries[i].sessionId ||
|
||||
list[i].floating != entries[i].floating) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
static ChatOpenWorkspaceSnapshot? fromJson(Object? value) {
|
||||
if (value is! Map || value['entries'] is! List) return null;
|
||||
final entries = <ChatOpenWorkspaceEntry>[];
|
||||
@@ -36,15 +59,28 @@ class ChatOpenWorkspaceSnapshot {
|
||||
return ChatOpenWorkspaceSnapshot(
|
||||
(value['revision'] as num?)?.toInt() ?? 0,
|
||||
List.unmodifiable(entries),
|
||||
rejected: value['rejected'] == true,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// The `chat_open_workspace` request and its `chat_open_workspace_changed`
|
||||
/// push, decoded.
|
||||
class ChatOpenWorkspaceGateway {
|
||||
ChatOpenWorkspaceGateway(this.gateway);
|
||||
final ApiGateway gateway;
|
||||
|
||||
/// The current snapshot, without changing it.
|
||||
Future<ChatOpenWorkspaceSnapshot?> read() async {
|
||||
final response = await gateway.call('chat_open_workspace');
|
||||
return ChatOpenWorkspaceSnapshot.fromJson(response['chat_open_workspace']);
|
||||
}
|
||||
|
||||
/// Replaces the set, derived from [baseRevision]. A [seed] applies only
|
||||
/// when the server never stored a set and otherwise returns the stored one.
|
||||
Future<ChatOpenWorkspaceSnapshot?> replace(
|
||||
Iterable<ChatOpenWorkspaceEntry> entries, {
|
||||
int baseRevision = 0,
|
||||
bool seed = false,
|
||||
}) async {
|
||||
final response = await gateway.call('chat_open_workspace', {
|
||||
@@ -52,6 +88,7 @@ class ChatOpenWorkspaceGateway {
|
||||
'entries': entries
|
||||
.map((entry) => entry.toJson())
|
||||
.toList(growable: false),
|
||||
'base_revision': baseRevision,
|
||||
if (seed) 'seed': true,
|
||||
},
|
||||
});
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
import 'package:flutter/foundation.dart';
|
||||
|
||||
import 'chat_workspace_nodes.dart';
|
||||
import 'chat_workspace_reconcile.dart';
|
||||
import 'chat_workspace_snapshot.dart';
|
||||
|
||||
export 'chat_workspace_nodes.dart';
|
||||
@@ -203,45 +204,20 @@ class ChatWorkspaceController extends ChangeNotifier {
|
||||
_changed();
|
||||
}
|
||||
|
||||
/// Reconciles tiled membership and order without discarding the local split
|
||||
/// geometry. Floating membership is handled by the window host.
|
||||
/// Tiles exactly [sessionIds] in order, as the server's open-chat set
|
||||
/// names them, keeping this device's geometry (see
|
||||
/// [reconcileChatWorkspaceTree]). Floating membership is the window host's.
|
||||
void reconcileSessions(Iterable<String> sessionIds) {
|
||||
final wanted = <String>[];
|
||||
final seen = <String>{};
|
||||
for (final id in sessionIds) {
|
||||
if (id.isNotEmpty && seen.add(id)) wanted.add(id);
|
||||
}
|
||||
final current = panes;
|
||||
if (wanted.isEmpty) {
|
||||
if (_root == null) return;
|
||||
_root = null;
|
||||
_active = null;
|
||||
_changed();
|
||||
return;
|
||||
}
|
||||
final retained = current.take(wanted.length).toList();
|
||||
for (var i = 0; i < retained.length; i++) {
|
||||
final pane = retained[i];
|
||||
final id = wanted[i];
|
||||
if (pane.sessionId != id) {
|
||||
_root = _replace(_root!, pane.id, ChatWorkspacePane(pane.id, id));
|
||||
}
|
||||
}
|
||||
for (final pane in current.skip(wanted.length).toList()) {
|
||||
_root = _remove(_root!, pane.id);
|
||||
}
|
||||
if (retained.isEmpty) {
|
||||
final pane = ChatWorkspacePane(_id('pane'), wanted.first);
|
||||
_root = pane;
|
||||
_active = pane.id;
|
||||
} else {
|
||||
for (final id in wanted.skip(retained.length)) {
|
||||
splitActive(id, ChatSplitAxis.horizontal);
|
||||
}
|
||||
}
|
||||
if (_active == null || !panes.any((pane) => pane.id == _active)) {
|
||||
_active = panes.first.id;
|
||||
}
|
||||
final next = reconcileChatWorkspaceTree(_root, wanted, _id);
|
||||
if (identical(next, _root)) return;
|
||||
_root = next;
|
||||
final ids = panes.map((pane) => pane.id).toSet();
|
||||
if (!ids.contains(_active)) _active = ids.firstOrNull;
|
||||
_changed();
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,118 @@
|
||||
import 'chat_workspace_nodes.dart';
|
||||
|
||||
/// Returns [root] tiled with exactly [wanted] (distinct session ids) in
|
||||
/// order, keeping the local geometry: panes whose chat left are removed with
|
||||
/// their splits, surviving panes keep their ids and split sizes and move
|
||||
/// between slots to follow the order, and new chats split off the last pane.
|
||||
/// Returns [root] itself when it already matches.
|
||||
ChatWorkspaceNode? reconcileChatWorkspaceTree(
|
||||
ChatWorkspaceNode? root,
|
||||
List<String> wanted,
|
||||
String Function(String kind) newId,
|
||||
) {
|
||||
if (wanted.isEmpty) return null;
|
||||
final keep = wanted.toSet();
|
||||
final seen = <String>{};
|
||||
var node = root == null ? null : _retain(root, keep, seen);
|
||||
final leaves = node == null ? <ChatWorkspacePane>[] : _leaves(node).toList();
|
||||
final bySession = {for (final pane in leaves) pane.sessionId: pane};
|
||||
final order = wanted.where(bySession.containsKey).toList();
|
||||
var slot = 0;
|
||||
if (node != null) {
|
||||
node = _reorder(node, () => bySession[order[slot++]]!);
|
||||
}
|
||||
for (final id in wanted.where((id) => !bySession.containsKey(id))) {
|
||||
final added = ChatWorkspacePane(newId('pane'), id);
|
||||
if (node == null) {
|
||||
node = added;
|
||||
continue;
|
||||
}
|
||||
final last = _leaves(node).last;
|
||||
node = _swapLeaf(
|
||||
node,
|
||||
last.id,
|
||||
ChatWorkspaceSplit(newId('split'), ChatSplitAxis.horizontal, last, added),
|
||||
);
|
||||
}
|
||||
return _same(node, root) ? root : node;
|
||||
}
|
||||
|
||||
Iterable<ChatWorkspacePane> _leaves(ChatWorkspaceNode node) sync* {
|
||||
if (node is ChatWorkspacePane) yield node;
|
||||
if (node is ChatWorkspaceSplit) {
|
||||
yield* _leaves(node.first);
|
||||
yield* _leaves(node.second);
|
||||
}
|
||||
}
|
||||
|
||||
/// Drops panes outside [keep] and repeats of a session already kept.
|
||||
ChatWorkspaceNode? _retain(
|
||||
ChatWorkspaceNode node,
|
||||
Set<String> keep,
|
||||
Set<String> seen,
|
||||
) {
|
||||
if (node is ChatWorkspacePane) {
|
||||
return keep.contains(node.sessionId) && seen.add(node.sessionId)
|
||||
? node
|
||||
: null;
|
||||
}
|
||||
final split = node as ChatWorkspaceSplit;
|
||||
final first = _retain(split.first, keep, seen);
|
||||
final second = _retain(split.second, keep, seen);
|
||||
if (first == null) return second;
|
||||
if (second == null) return first;
|
||||
return ChatWorkspaceSplit(
|
||||
split.id,
|
||||
split.axis,
|
||||
first,
|
||||
second,
|
||||
ratio: split.ratio,
|
||||
);
|
||||
}
|
||||
|
||||
ChatWorkspaceNode _reorder(
|
||||
ChatWorkspaceNode node,
|
||||
ChatWorkspacePane Function() next,
|
||||
) {
|
||||
if (node is ChatWorkspacePane) return next();
|
||||
final split = node as ChatWorkspaceSplit;
|
||||
final first = _reorder(split.first, next);
|
||||
return ChatWorkspaceSplit(
|
||||
split.id,
|
||||
split.axis,
|
||||
first,
|
||||
_reorder(split.second, next),
|
||||
ratio: split.ratio,
|
||||
);
|
||||
}
|
||||
|
||||
ChatWorkspaceNode _swapLeaf(
|
||||
ChatWorkspaceNode node,
|
||||
String id,
|
||||
ChatWorkspaceNode replacement,
|
||||
) {
|
||||
if (node.id == id) return replacement;
|
||||
if (node is! ChatWorkspaceSplit) return node;
|
||||
return ChatWorkspaceSplit(
|
||||
node.id,
|
||||
node.axis,
|
||||
_swapLeaf(node.first, id, replacement),
|
||||
_swapLeaf(node.second, id, replacement),
|
||||
ratio: node.ratio,
|
||||
);
|
||||
}
|
||||
|
||||
bool _same(ChatWorkspaceNode? a, ChatWorkspaceNode? b) {
|
||||
if (a == null || b == null) return a == b;
|
||||
if (a is ChatWorkspacePane && b is ChatWorkspacePane) {
|
||||
return a.id == b.id && a.sessionId == b.sessionId;
|
||||
}
|
||||
if (a is ChatWorkspaceSplit && b is ChatWorkspaceSplit) {
|
||||
return a.id == b.id &&
|
||||
a.axis == b.axis &&
|
||||
a.ratio == b.ratio &&
|
||||
_same(a.first, b.first) &&
|
||||
_same(a.second, b.second);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
@@ -2,33 +2,62 @@
|
||||
|
||||
## Behaviour
|
||||
|
||||
The authenticated `/connect` protocol now stores one bounded ordered workspace
|
||||
per server scope. Entries contain only operator session ids and a floating bit.
|
||||
Opening, closing, reordering, docking and floating publish a full authoritative
|
||||
snapshot; other connections receive `chat_open_workspace_changed`. The first
|
||||
client may seed an empty server snapshot from its legacy local layout. Split
|
||||
ratios, pane ids, window rectangles and other presentation geometry remain local.
|
||||
The authenticated `/connect` protocol stores one bounded ordered open-chat set
|
||||
per server scope (`default`). Entries hold only an operator session id and a
|
||||
floating bit; split ratios, pane ids and window rectangles stay on the device.
|
||||
|
||||
The server drops closed, missing, unowned, or no-longer-live broker sessions
|
||||
before saving. The store caps membership at 64 entries and rejects duplicates or
|
||||
invalid ids. Protocol and application parsers apply the same bounds.
|
||||
* `chat_open_workspace` without `chat_open_workspace_request` reads the set.
|
||||
With a request it replaces the set as a compare-and-swap on `base_revision`:
|
||||
a write from a stale base is not applied and the reply carries the current
|
||||
set with `rejected: true`. Each stored change increments `revision`; an
|
||||
identical write stores nothing.
|
||||
* `seed: true` applies only when the server never stored a set (even an
|
||||
emptied set wins over an old device-local snapshot), so the migration from
|
||||
the old local layout happens once.
|
||||
* Stored changes are pushed to every other connection as
|
||||
`chat_open_workspace_changed`. Pushes run on separate goroutines and can
|
||||
arrive out of order; clients keep the highest revision.
|
||||
* Only recorded, not-closed operator chats are kept (registry check; the broker
|
||||
is not asked, so validation never starts a harness). `chat_close` drops the
|
||||
chat and pushes the new revision to every connection. A new connection
|
||||
prunes stale entries and pushes the result to all connections, else sends
|
||||
the current set to the new connection only (reconnect catch-up).
|
||||
|
||||
## Security and limits
|
||||
App (`ChatOpenWorkspaceController`): one write in flight at a time; later
|
||||
changes coalesce into the newest full set, sent from the revision of the last
|
||||
reply. Pushes and replies with a lower (or, for pushes, equal) revision are
|
||||
ignored. A push or a rejected reply wins over unsent local changes. After the
|
||||
local layout is restored, the device seeds (or, with no chats, reads) and
|
||||
applies the answer; the first answer keeps a deep-linked chat. Server drops in
|
||||
a successful reply are not applied locally, so a closed chat can still be read
|
||||
on the device that opened it, but no other device receives it. Remote
|
||||
membership is applied with `reconcileChatWorkspaceTree`: removed chats' panes
|
||||
go, survivors keep pane ids and split sizes and move to follow the order, new
|
||||
chats split off the last pane. The controller is disposed on a server or
|
||||
gateway rebind. A federated (all-servers) list keeps its local layout.
|
||||
|
||||
Workspace writes use the existing authenticated websocket. The server requires
|
||||
both an operator-session registry row and a live broker session, so pipeline-owned
|
||||
or another user's ids cannot be retained. No credentials, transcripts, drafts,
|
||||
tokens or geometry are persisted. The current scope is the authenticated local
|
||||
server's single operator (`default`); multi-user identity is not yet modelled.
|
||||
Ctrl+Tab: main's behaviour (floating chats when shown, else visible panes) is
|
||||
kept; the single-pane recent-chat swap is removed there.
|
||||
|
||||
## Verification
|
||||
|
||||
* `go test ./internal/protocol -run 'Test.*Chat|Test.*Workspace'` — passed.
|
||||
* `go test ./internal/pipeline -run 'TestChatOpenWorkspace'` — passed.
|
||||
* `go test ./internal/server -run 'TestChat(Open|Close|NewSession)|TestEmbeddedSchedulesReadOnlyOverWebSocket|TestStorageWebsocketProtocolAndNoStartupCleanup|TestTemplatesDoNotSeedDatabaseAndCreateOnlyPreservesExisting'` — passed.
|
||||
* `go build ./cmd/pipelines-server` — passed.
|
||||
* `cd app && tool/memwatch/full.sh 'test/features/chat/workspace/chat_open_workspace_gateway_test.dart test/features/chat/workspace/chat_workspace_binding_test.dart'` — 7 passed, 0 failed, 0 skipped; peak 800 MB; exit 0.
|
||||
* `cd app && tool/analyze.sh` — clean; 0 errors, 0 warnings, 2 infos before the brace cleanup; rerun after cleanup was not captured.
|
||||
* Go: `internal/pipeline` `TestChatOpenWorkspace*` (seed once, stale revision,
|
||||
remove, bounds); `internal/server` `TestChatOpenWorkspaceSyncsEveryConnection`
|
||||
(two connections get the same snapshot, stale write rejected, reorder,
|
||||
close pruned and pushed to both, closed chat not restorable) and
|
||||
`TestChatOpenWorkspacePrunesOnConnectForEveryone`.
|
||||
* App: `test/features/chat/workspace/chat_open_workspace_controller_test.dart`
|
||||
(serialized writes, late reply vs newer push, rejected write, dispose),
|
||||
`chat_workspace_reconcile_test.dart`, and
|
||||
`test/features/chat/chat_open_workspace_sync_test.dart` (seed migration,
|
||||
remote removal drops the pane, server set wins over an old local snapshot,
|
||||
rebind disposes the old sync).
|
||||
* Live two-client check (2026-11-12): server built from this worktree, run on
|
||||
an OS-assigned loopback port with a scratch HOME/XDG and database, three
|
||||
scratch operator rows; a Node script drove two websocket clients through
|
||||
read, open, reorder, stale write, float, pane close, `chat_close`, write-back
|
||||
of the closed chat, and an out-of-band close pruned on a third connection.
|
||||
All 16 checks passed (`RESULT: PASS`); every connection received the same
|
||||
revisions. The scratch server and its own OpenCode child were stopped.
|
||||
|
||||
Not tested: a live two-client scratch websocket/broker check and rendered UI
|
||||
captures. The shared server was not restarted or contacted.
|
||||
Not verified: rendered UI captures and on-device behaviour.
|
||||
|
||||
@@ -0,0 +1,205 @@
|
||||
import 'package:flutter/material.dart';
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:shared_preferences/shared_preferences.dart';
|
||||
import 'package:pipelines_app/core/api_gateway.dart';
|
||||
import 'package:pipelines_app/core/servers/server_scope.dart';
|
||||
import 'package:pipelines_app/features/chat/screen.dart';
|
||||
import 'package:pipelines_app/features/chat/workspace/chat_workspace.dart';
|
||||
import 'package:pipelines_app/features/chat/workspace/chat_workspace_store.dart';
|
||||
import 'package:pipelines_app/shell/adaptive_shell.dart';
|
||||
import 'package:pipelines_app/shell/destination.dart';
|
||||
|
||||
import 'conversation/chat_thread_fixtures.dart';
|
||||
|
||||
/// A chat server that keeps the open-chat set with the real revision rules:
|
||||
/// a seed applies only to a never-stored set, a write from a stale base is
|
||||
/// refused with the current set.
|
||||
class _Server extends FakeChatGateway {
|
||||
_Server({this.revision = 0, List<String> open = const []})
|
||||
: open = List.of(open);
|
||||
int revision;
|
||||
List<String> open;
|
||||
final writes = <List<String>>[];
|
||||
|
||||
@override
|
||||
Future<JsonMap> call(String type, [JsonMap fields = const {}]) {
|
||||
if (type == 'chat_sessions') {
|
||||
return Future.value({
|
||||
'chat_sessions': [
|
||||
for (final id in ['a', 'b', 'c', 'd'])
|
||||
{'id': id, 'title': 'Chat $id'},
|
||||
],
|
||||
});
|
||||
}
|
||||
if (type == 'chat_shells') return Future.value({'chat_shells': []});
|
||||
if (type == 'chat_open_workspace') return Future.value(_workspace(fields));
|
||||
return super.call(type, fields);
|
||||
}
|
||||
|
||||
JsonMap _workspace(JsonMap fields) {
|
||||
final request = fields['chat_open_workspace_request'] as Map?;
|
||||
var rejected = false;
|
||||
if (request != null) {
|
||||
final ids = [
|
||||
for (final entry in request['entries'] as List)
|
||||
'${entry['session_id']}',
|
||||
];
|
||||
writes.add(ids);
|
||||
if (request['seed'] == true) {
|
||||
if (revision == 0) {
|
||||
open = ids;
|
||||
revision = 1;
|
||||
}
|
||||
} else if (request['base_revision'] != revision) {
|
||||
rejected = true;
|
||||
} else {
|
||||
open = ids;
|
||||
revision++;
|
||||
}
|
||||
}
|
||||
return {
|
||||
'type': 'chat_open_workspace',
|
||||
'chat_open_workspace': _body(rejected),
|
||||
};
|
||||
}
|
||||
|
||||
JsonMap _body([bool rejected = false]) => {
|
||||
'revision': revision,
|
||||
'entries': [
|
||||
for (final id in open) {'session_id': id},
|
||||
],
|
||||
if (rejected) 'rejected': true,
|
||||
};
|
||||
|
||||
/// Another device (or the server) changed the set.
|
||||
void change(List<String> ids) {
|
||||
open = List.of(ids);
|
||||
revision++;
|
||||
emitRaw({
|
||||
'type': 'chat_open_workspace_changed',
|
||||
'chat_open_workspace': _body(),
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
ChatWorkspaceController _workspace(WidgetTester tester) =>
|
||||
tester.widget<ChatWorkspace>(find.byType(ChatWorkspace)).controller;
|
||||
|
||||
List<String> _open(WidgetTester tester) =>
|
||||
_workspace(tester).panes.map((pane) => pane.sessionId).toList();
|
||||
|
||||
Future<void> _mount(WidgetTester tester, _Server server) async {
|
||||
await tester.pumpWidget(
|
||||
MaterialApp(
|
||||
home: AdaptiveShell(
|
||||
destination: AppDestination.chat,
|
||||
destinationBodies: {
|
||||
AppDestination.chat: (_) =>
|
||||
ChatScreen(gateway: server, persistWorkspace: true),
|
||||
},
|
||||
),
|
||||
),
|
||||
);
|
||||
await tester.pumpAndSettle();
|
||||
}
|
||||
|
||||
_Server _server(
|
||||
String identity, {
|
||||
int revision = 0,
|
||||
List<String> open = const [],
|
||||
}) {
|
||||
final server = _Server(revision: revision, open: open)
|
||||
..history = (_) async => chatPage([]);
|
||||
bindServerIdentity(server, identity);
|
||||
addTearDown(server.close);
|
||||
return server;
|
||||
}
|
||||
|
||||
void _saveLocal(String identity, List<String> ids) {
|
||||
final saved = ChatWorkspaceController()..open(ids.first);
|
||||
for (final id in ids.skip(1)) {
|
||||
saved.splitActive(id, ChatSplitAxis.horizontal);
|
||||
}
|
||||
SharedPreferences.setMockInitialValues({
|
||||
scopedServerKey(chatWorkspacePreferenceKey, identity): saved
|
||||
.snapshot()!
|
||||
.encode(),
|
||||
});
|
||||
}
|
||||
|
||||
void main() {
|
||||
testWidgets(
|
||||
'the local layout seeds a new server and remote removal drops its pane',
|
||||
(tester) async {
|
||||
tester.view.physicalSize = const Size(1800, 1000);
|
||||
tester.view.devicePixelRatio = 1;
|
||||
addTearDown(tester.view.reset);
|
||||
_saveLocal('server-a', ['a', 'b']);
|
||||
final server = _server('server-a');
|
||||
await _mount(tester, server);
|
||||
expect(server.revision, 1);
|
||||
expect(server.open, ['a', 'b']);
|
||||
expect(_open(tester), ['a', 'b']);
|
||||
|
||||
server.change(['b']);
|
||||
await tester.pumpAndSettle();
|
||||
expect(_open(tester), ['b']);
|
||||
// Applying the server's change is not written back.
|
||||
expect(server.writes, hasLength(1));
|
||||
await tester.pumpWidget(const SizedBox.shrink());
|
||||
await tester.pumpAndSettle();
|
||||
},
|
||||
);
|
||||
|
||||
testWidgets('an existing server set wins over an old local snapshot', (
|
||||
tester,
|
||||
) async {
|
||||
tester.view.physicalSize = const Size(1800, 1000);
|
||||
tester.view.devicePixelRatio = 1;
|
||||
addTearDown(tester.view.reset);
|
||||
_saveLocal('server-a', ['a']);
|
||||
final server = _server('server-a', revision: 3, open: ['b', 'c']);
|
||||
await _mount(tester, server);
|
||||
expect(_open(tester), ['b', 'c']);
|
||||
expect(server.open, ['b', 'c']);
|
||||
expect(server.revision, 3);
|
||||
// A local change is sent from the server's revision and accepted.
|
||||
_workspace(tester).close(_workspace(tester).panes.first.id);
|
||||
await tester.pumpAndSettle();
|
||||
expect(server.open, ['c']);
|
||||
expect(server.revision, 4);
|
||||
await tester.pumpWidget(const SizedBox.shrink());
|
||||
await tester.pumpAndSettle();
|
||||
});
|
||||
|
||||
testWidgets('rebinding to another server disposes the old sync', (
|
||||
tester,
|
||||
) async {
|
||||
tester.view.physicalSize = const Size(1800, 1000);
|
||||
tester.view.devicePixelRatio = 1;
|
||||
addTearDown(tester.view.reset);
|
||||
SharedPreferences.setMockInitialValues({});
|
||||
final first = _server('server-a', revision: 1, open: ['a']);
|
||||
final second = _server('server-b', revision: 1, open: ['c']);
|
||||
await _mount(tester, first);
|
||||
expect(_open(tester), ['a']);
|
||||
await _mount(tester, second);
|
||||
expect(_open(tester), ['c']);
|
||||
|
||||
// The old server's pushes no longer reach this screen.
|
||||
first.change(['a', 'b', 'd']);
|
||||
await tester.pumpAndSettle();
|
||||
expect(_open(tester), ['c']);
|
||||
// The new server's do, and local changes go only to it.
|
||||
second.change(['c', 'd']);
|
||||
await tester.pumpAndSettle();
|
||||
expect(_open(tester), ['c', 'd']);
|
||||
final firstWrites = first.writes.length;
|
||||
_workspace(tester).close(_workspace(tester).panes.last.id);
|
||||
await tester.pumpAndSettle();
|
||||
expect(second.open, ['c']);
|
||||
expect(first.writes, hasLength(firstWrites));
|
||||
await tester.pumpWidget(const SizedBox.shrink());
|
||||
await tester.pumpAndSettle();
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,211 @@
|
||||
import 'dart:async';
|
||||
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:pipelines_app/core/api_gateway.dart';
|
||||
import 'package:pipelines_app/features/chat/workspace/chat_open_workspace_controller.dart';
|
||||
import 'package:pipelines_app/features/chat/workspace/chat_open_workspace_gateway.dart';
|
||||
|
||||
/// Answers each chat_open_workspace call only when the test completes it.
|
||||
class _Gateway implements ApiGateway {
|
||||
final requests = <({JsonMap fields, Completer<JsonMap> reply})>[];
|
||||
final _frames = StreamController<JsonMap>.broadcast();
|
||||
|
||||
@override
|
||||
Future<JsonMap> call(String type, [JsonMap fields = const {}]) {
|
||||
final reply = Completer<JsonMap>();
|
||||
requests.add((fields: fields, reply: reply));
|
||||
return reply.future;
|
||||
}
|
||||
|
||||
@override
|
||||
Stream<JsonMap> get frames => _frames.stream;
|
||||
|
||||
void push(int revision, List<String> ids) => _frames.add({
|
||||
'type': 'chat_open_workspace_changed',
|
||||
'chat_open_workspace': _snapshot(revision, ids),
|
||||
});
|
||||
|
||||
void answer(
|
||||
int index,
|
||||
int revision,
|
||||
List<String> ids, {
|
||||
bool rejected = false,
|
||||
}) => requests[index].reply.complete({
|
||||
'type': 'chat_open_workspace',
|
||||
'chat_open_workspace': _snapshot(revision, ids, rejected: rejected),
|
||||
});
|
||||
|
||||
List<String> sentIds(int index) => [
|
||||
for (final entry
|
||||
in (requests[index].fields['chat_open_workspace_request']
|
||||
as Map)['entries']
|
||||
as List)
|
||||
'${entry['session_id']}',
|
||||
];
|
||||
|
||||
int base(int index) =>
|
||||
(requests[index].fields['chat_open_workspace_request']
|
||||
as Map)['base_revision'];
|
||||
}
|
||||
|
||||
JsonMap _snapshot(int revision, List<String> ids, {bool rejected = false}) => {
|
||||
'revision': revision,
|
||||
'entries': [
|
||||
for (final id in ids) {'session_id': id},
|
||||
],
|
||||
if (rejected) 'rejected': true,
|
||||
};
|
||||
|
||||
List<ChatOpenWorkspaceEntry> _entries(List<String> ids) => [
|
||||
for (final id in ids) ChatOpenWorkspaceEntry(id),
|
||||
];
|
||||
|
||||
Future<(ChatOpenWorkspaceController, _Gateway, List<List<String>>)> _started({
|
||||
int revision = 1,
|
||||
List<String> ids = const ['a'],
|
||||
}) async {
|
||||
final gateway = _Gateway();
|
||||
final applied = <List<String>>[];
|
||||
final controller = ChatOpenWorkspaceController(gateway: gateway)
|
||||
..onChanged = (snapshot) =>
|
||||
applied.add(snapshot.entries.map((e) => e.sessionId).toList());
|
||||
final started = controller.start(local: _entries(ids));
|
||||
await pumpEventQueue();
|
||||
expect(gateway.requests.single.fields['chat_open_workspace_request'], {
|
||||
'entries': [
|
||||
for (final id in ids) {'session_id': id},
|
||||
],
|
||||
'base_revision': 0,
|
||||
'seed': true,
|
||||
});
|
||||
gateway.answer(0, revision, ids);
|
||||
await started;
|
||||
return (controller, gateway, applied);
|
||||
}
|
||||
|
||||
void main() {
|
||||
test('reads instead of seeding when the device has no chats', () async {
|
||||
final gateway = _Gateway();
|
||||
final controller = ChatOpenWorkspaceController(gateway: gateway);
|
||||
final started = controller.start();
|
||||
await pumpEventQueue();
|
||||
expect(gateway.requests.single.fields, isEmpty);
|
||||
gateway.answer(0, 4, ['x']);
|
||||
await started;
|
||||
expect(controller.revision, 4);
|
||||
expect(controller.ready, isTrue);
|
||||
});
|
||||
|
||||
test(
|
||||
'serializes writes and sends the latest from the replied revision',
|
||||
() async {
|
||||
final (controller, gateway, _) = await _started();
|
||||
controller.replace(_entries(['a', 'b']));
|
||||
controller.replace(_entries(['a', 'b', 'c']));
|
||||
controller.replace(_entries(['c', 'a', 'b']));
|
||||
await pumpEventQueue();
|
||||
// One write in flight; the two later ones coalesced behind it.
|
||||
expect(gateway.requests, hasLength(2));
|
||||
expect(gateway.sentIds(1), ['a', 'b']);
|
||||
expect(gateway.base(1), 1);
|
||||
gateway.answer(1, 2, ['a', 'b']);
|
||||
await pumpEventQueue();
|
||||
expect(gateway.requests, hasLength(3));
|
||||
expect(gateway.sentIds(2), ['c', 'a', 'b']);
|
||||
expect(gateway.base(2), 2);
|
||||
gateway.answer(2, 3, ['c', 'a', 'b']);
|
||||
await pumpEventQueue();
|
||||
expect(controller.revision, 3);
|
||||
// An unchanged set is not sent again.
|
||||
controller.replace(_entries(['c', 'a', 'b']));
|
||||
await pumpEventQueue();
|
||||
expect(gateway.requests, hasLength(3));
|
||||
},
|
||||
);
|
||||
|
||||
test('a late reply never overwrites a newer pushed revision', () async {
|
||||
final (controller, gateway, applied) = await _started();
|
||||
controller.replace(_entries(['a', 'b']));
|
||||
await pumpEventQueue();
|
||||
// Another device's change (revision 3) is pushed before this write's
|
||||
// reply (revision 2) arrives.
|
||||
gateway.push(3, ['z']);
|
||||
await pumpEventQueue();
|
||||
gateway.answer(1, 2, ['a', 'b']);
|
||||
await pumpEventQueue();
|
||||
expect(controller.revision, 3);
|
||||
expect(applied.last, ['z']);
|
||||
// Older and repeated pushes are ignored.
|
||||
gateway.push(2, ['a', 'b']);
|
||||
gateway.push(3, ['z']);
|
||||
await pumpEventQueue();
|
||||
expect(applied, [
|
||||
['a'],
|
||||
['z'],
|
||||
]);
|
||||
});
|
||||
|
||||
test(
|
||||
'a refused stale write applies the server state and drops queued ones',
|
||||
() async {
|
||||
final (controller, gateway, applied) = await _started();
|
||||
controller.replace(_entries(['a', 'b']));
|
||||
await pumpEventQueue();
|
||||
controller.replace(_entries(['a', 'b', 'c']));
|
||||
gateway.answer(1, 5, ['q'], rejected: true);
|
||||
await pumpEventQueue();
|
||||
expect(applied.last, ['q']);
|
||||
expect(controller.revision, 5);
|
||||
expect(gateway.requests, hasLength(2));
|
||||
// The next change is derived from the server's state.
|
||||
controller.replace(_entries(['q', 'r']));
|
||||
await pumpEventQueue();
|
||||
expect(gateway.base(2), 5);
|
||||
},
|
||||
);
|
||||
|
||||
test('a push applied while writing replaces the queued write', () async {
|
||||
final (controller, gateway, applied) = await _started();
|
||||
controller.replace(_entries(['a', 'b']));
|
||||
await pumpEventQueue();
|
||||
controller.replace(_entries(['a', 'b', 'c']));
|
||||
gateway.push(4, ['b']);
|
||||
await pumpEventQueue();
|
||||
expect(applied.last, ['b']);
|
||||
gateway.answer(1, 4, ['b'], rejected: true);
|
||||
await pumpEventQueue();
|
||||
expect(gateway.requests, hasLength(2));
|
||||
});
|
||||
|
||||
test('dispose stops pushes and writes', () async {
|
||||
final (controller, gateway, applied) = await _started();
|
||||
controller.dispose();
|
||||
gateway.push(9, ['late']);
|
||||
controller.replace(_entries(['x']));
|
||||
await pumpEventQueue();
|
||||
expect(applied, [
|
||||
['a'],
|
||||
]);
|
||||
expect(gateway.requests, hasLength(1));
|
||||
});
|
||||
|
||||
test(
|
||||
'stays local-only when the server does not answer the request',
|
||||
() async {
|
||||
final gateway = _Gateway();
|
||||
final controller = ChatOpenWorkspaceController(gateway: gateway);
|
||||
final started = controller.start(local: _entries(['a']));
|
||||
await pumpEventQueue();
|
||||
gateway.requests.single.reply.completeError(StateError('unknown type'));
|
||||
await started;
|
||||
expect(controller.ready, isFalse);
|
||||
controller.replace(_entries(['a', 'b']));
|
||||
await pumpEventQueue();
|
||||
expect(gateway.requests, hasLength(1));
|
||||
// A server push (a reconnect) brings it up to date and enables writes.
|
||||
gateway.push(2, ['a']);
|
||||
await pumpEventQueue();
|
||||
expect(controller.ready, isTrue);
|
||||
},
|
||||
);
|
||||
}
|
||||
@@ -11,7 +11,10 @@ void main() {
|
||||
],
|
||||
});
|
||||
expect(snapshot?.revision, 7);
|
||||
expect(snapshot?.entries.map((entry) => entry.sessionId), ['ses_a', 'ses_b']);
|
||||
expect(snapshot?.entries.map((entry) => entry.sessionId), [
|
||||
'ses_a',
|
||||
'ses_b',
|
||||
]);
|
||||
expect(snapshot?.entries.first.floating, isTrue);
|
||||
});
|
||||
|
||||
|
||||
@@ -0,0 +1,56 @@
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:pipelines_app/features/chat/workspace/chat_workspace_controller.dart';
|
||||
|
||||
List<String> _sessions(ChatWorkspaceController c) =>
|
||||
c.panes.map((pane) => pane.sessionId).toList();
|
||||
|
||||
ChatWorkspaceController _three() {
|
||||
final c = ChatWorkspaceController()..open('a');
|
||||
c.splitActive('b', ChatSplitAxis.vertical);
|
||||
c.splitActive('c', ChatSplitAxis.horizontal);
|
||||
c.resize(c.root!.id, .3);
|
||||
return c;
|
||||
}
|
||||
|
||||
void main() {
|
||||
test('a remote removal drops only that pane and keeps the geometry', () {
|
||||
final c = _three();
|
||||
final paneA = c.panes.first.id;
|
||||
final paneC = c.panes.last.id;
|
||||
c.reconcileSessions(['a', 'c']);
|
||||
expect(_sessions(c), ['a', 'c']);
|
||||
expect(c.panes.map((pane) => pane.id), [paneA, paneC]);
|
||||
expect((c.root as ChatWorkspaceSplit).ratio, .3);
|
||||
});
|
||||
|
||||
test('a reorder moves panes with their ids and keeps the splits', () {
|
||||
final c = _three();
|
||||
final ids = {for (final pane in c.panes) pane.sessionId: pane.id};
|
||||
final splitId = c.root!.id;
|
||||
c.reconcileSessions(['c', 'a', 'b']);
|
||||
expect(_sessions(c), ['c', 'a', 'b']);
|
||||
expect(c.panes.map((pane) => pane.id), [ids['c'], ids['a'], ids['b']]);
|
||||
expect(c.root!.id, splitId);
|
||||
expect((c.root as ChatWorkspaceSplit).ratio, .3);
|
||||
});
|
||||
|
||||
test('new chats split off and an unchanged set notifies nothing', () {
|
||||
final c = ChatWorkspaceController()..open('a');
|
||||
c.reconcileSessions(['a', 'b']);
|
||||
expect(_sessions(c), ['a', 'b']);
|
||||
var notified = 0;
|
||||
c.addListener(() => notified++);
|
||||
c.reconcileSessions(['a', 'b']);
|
||||
expect(notified, 0);
|
||||
c.reconcileSessions(const []);
|
||||
expect(c.panes, isEmpty);
|
||||
expect(c.activePane, isNull);
|
||||
});
|
||||
|
||||
test('the active pane moves on when its chat is removed', () {
|
||||
final c = _three();
|
||||
expect(c.activePane?.sessionId, 'c');
|
||||
c.reconcileSessions(['b']);
|
||||
expect(c.activePane?.sessionId, 'b');
|
||||
});
|
||||
}
|
||||
Reference in New Issue
Block a user