4f8e99f316
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.
106 lines
4.2 KiB
Go
106 lines
4.2 KiB
Go
package pipeline
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"testing"
|
|
|
|
"git.a-wan.net/alan/pipelines/internal/protocol"
|
|
)
|
|
|
|
func openWorkspaceStore(t *testing.T, path string) *Store {
|
|
t.Helper()
|
|
store, err := Open(path)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return store
|
|
}
|
|
|
|
func TestChatOpenWorkspacePersistsAndSeedsOnce(t *testing.T) {
|
|
path := t.TempDir() + "/workspace.db"
|
|
ctx := context.Background()
|
|
store := openWorkspaceStore(t, path)
|
|
first := []protocol.ChatOpenWorkspaceEntry{{SessionID: "ses_a", Floating: true}}
|
|
snapshot, changed, err := store.SaveChatOpenWorkspace(ctx, "default", first, true, 0)
|
|
if err != nil || !changed {
|
|
t.Fatalf("seed: changed=%v err=%v", changed, err)
|
|
}
|
|
if snapshot.Revision != 1 || len(snapshot.Entries) != 1 || !snapshot.Entries[0].Floating {
|
|
t.Fatalf("unexpected snapshot: %+v", snapshot)
|
|
}
|
|
second, changed, err := store.SaveChatOpenWorkspace(ctx, "default", []protocol.ChatOpenWorkspaceEntry{{SessionID: "ses_b"}}, true, 0)
|
|
if err != nil || changed || second.Rejected {
|
|
t.Fatalf("second seed: changed=%v rejected=%v err=%v", changed, second.Rejected, err)
|
|
}
|
|
if len(second.Entries) != 1 || second.Entries[0].SessionID != "ses_a" {
|
|
t.Fatalf("seed replaced existing workspace: %+v", second)
|
|
}
|
|
// An emptied workspace is still a stored workspace: an old device-local
|
|
// snapshot must not seed its chats back.
|
|
if _, _, err := store.SaveChatOpenWorkspace(ctx, "default", nil, false, 1); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
reseed, changed, err := store.SaveChatOpenWorkspace(ctx, "default", first, true, 0)
|
|
if err != nil || changed || len(reseed.Entries) != 0 || reseed.Revision != 2 {
|
|
t.Fatalf("seed restored an emptied workspace: %+v changed=%v err=%v", reseed, changed, err)
|
|
}
|
|
if err := store.Close(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
store = openWorkspaceStore(t, path)
|
|
defer store.Close()
|
|
loaded, err := store.ChatOpenWorkspace(ctx, "default")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if loaded.Revision != 2 || len(loaded.Entries) != 0 {
|
|
t.Fatalf("workspace did not survive restart: %+v", loaded)
|
|
}
|
|
}
|
|
|
|
func TestChatOpenWorkspaceRejectsStaleRevision(t *testing.T) {
|
|
store := openWorkspaceStore(t, t.TempDir()+"/workspace.db")
|
|
defer store.Close()
|
|
ctx := context.Background()
|
|
a := []protocol.ChatOpenWorkspaceEntry{{SessionID: "ses_a"}}
|
|
ab := []protocol.ChatOpenWorkspaceEntry{{SessionID: "ses_a"}, {SessionID: "ses_b"}}
|
|
if s, _, err := store.SaveChatOpenWorkspace(ctx, "default", a, false, 0); err != nil || s.Revision != 1 {
|
|
t.Fatalf("first write: %+v %v", s, err)
|
|
}
|
|
if s, _, err := store.SaveChatOpenWorkspace(ctx, "default", ab, false, 1); err != nil || s.Revision != 2 {
|
|
t.Fatalf("second write: %+v %v", s, err)
|
|
}
|
|
stale, changed, err := store.SaveChatOpenWorkspace(ctx, "default", nil, false, 1)
|
|
if err != nil || changed || !stale.Rejected || stale.Revision != 2 || len(stale.Entries) != 2 {
|
|
t.Fatalf("stale write = %+v changed=%v err=%v", stale, changed, err)
|
|
}
|
|
same, changed, err := store.SaveChatOpenWorkspace(ctx, "default", ab, false, 2)
|
|
if err != nil || changed || same.Revision != 2 {
|
|
t.Fatalf("identical write stored a revision: %+v changed=%v", same, changed)
|
|
}
|
|
removed, changed, err := store.RemoveChatOpenWorkspaceSessions(ctx, "default", []string{"ses_a", "ses_x"})
|
|
if err != nil || !changed || removed.Revision != 3 || len(removed.Entries) != 1 || removed.Entries[0].SessionID != "ses_b" {
|
|
t.Fatalf("remove = %+v changed=%v err=%v", removed, changed, err)
|
|
}
|
|
if _, changed, _ := store.RemoveChatOpenWorkspaceSessions(ctx, "default", []string{"ses_a"}); changed {
|
|
t.Fatal("removing an absent chat stored a revision")
|
|
}
|
|
}
|
|
|
|
func TestChatOpenWorkspaceRejectsDuplicatesAndBounds(t *testing.T) {
|
|
store := openWorkspaceStore(t, t.TempDir()+"/workspace.db")
|
|
defer store.Close()
|
|
entries := []protocol.ChatOpenWorkspaceEntry{{SessionID: "ses_a"}, {SessionID: "ses_a"}}
|
|
if _, _, err := store.SaveChatOpenWorkspace(context.Background(), "default", entries, false, 0); err == nil {
|
|
t.Fatal("duplicate workspace entries accepted")
|
|
}
|
|
many := make([]protocol.ChatOpenWorkspaceEntry, ChatOpenWorkspaceLimit+1)
|
|
for i := range many {
|
|
many[i].SessionID = fmt.Sprintf("ses_%d", i)
|
|
}
|
|
if _, _, err := store.SaveChatOpenWorkspace(context.Background(), "default", many, false, 0); err == nil {
|
|
t.Fatal("oversized workspace accepted")
|
|
}
|
|
}
|