package server import ( "context" "testing" "github.com/coder/websocket" "git.a-wan.net/alan/pipelines/internal/protocol" ) func workspaceWrite(id string, base int64, entries ...protocol.ChatOpenWorkspaceEntry) protocol.Message { return protocol.Message{Type: protocol.ChatOpenWorkspace, ID: id, ChatOpenWorkspaceRequest: &protocol.ChatOpenWorkspaceRequest{Entries: entries, BaseRevision: base}} } func workspaceIDs(snapshot *protocol.ChatOpenWorkspaceSnapshot) []string { ids := []string{} for _, entry := range snapshot.Entries { id := entry.SessionID if entry.Floating { id += "*" } ids = append(ids, id) } return ids } func sameIDs(a []string, b ...string) bool { if len(a) != len(b) { return false } for i := range a { if a[i] != b[i] { return false } } return true } // readWorkspacePush reads chat_open_workspace_changed pushes until one carries // revision; lower revisions (pushed out of order) are skipped. func readWorkspacePush(t *testing.T, ctx context.Context, conn *websocket.Conn, revision int64) *protocol.ChatOpenWorkspaceSnapshot { t.Helper() for { message := readUntil(t, ctx, conn, protocol.ChatOpenWorkspaceChanged) got := message.ChatOpenWorkspace if got == nil { t.Fatal("push without a snapshot") } if got.Revision == revision { return got } if got.Revision > revision { t.Fatalf("push revision %d, want %d", got.Revision, revision) } } } // TestChatOpenWorkspaceSyncsEveryConnection is the fan-out evidence: a write // from one connection is stored at the next revision and pushed to the other; // a write from a stale base is refused with the current snapshot; closing a // chat drops it and pushes the result to both connections; and a later write // cannot put the closed chat back. func TestChatOpenWorkspaceSyncsEveryConnection(t *testing.T) { store := newOperatorStore(t) ctx, _, conns := dialChatConns(t, Options{Chat: scriptedChat(), OperatorRegistry: store}, 2) for _, id := range []string{"ses_a", "ses_b"} { if err := store.RecordOperatorSession(ctx, id, "/work", id, protocol.ChatSessionTagOperator); err != nil { t.Fatal(err) } } a, b := protocol.ChatOpenWorkspaceEntry{SessionID: "ses_a"}, protocol.ChatOpenWorkspaceEntry{SessionID: "ses_b", Floating: true} writeChat(t, ctx, conns[0], workspaceWrite("w1", 0, a, b, protocol.ChatOpenWorkspaceEntry{SessionID: "ses_unknown"})) reply := readUntil(t, ctx, conns[0], protocol.ChatOpenWorkspace).ChatOpenWorkspace if reply.Revision != 1 || reply.Rejected || !sameIDs(workspaceIDs(reply), "ses_a", "ses_b*") { t.Fatalf("first write reply = %+v", reply) } if push := readWorkspacePush(t, ctx, conns[1], 1); !sameIDs(workspaceIDs(push), "ses_a", "ses_b*") { t.Fatalf("second connection got %v", workspaceIDs(push)) } writeChat(t, ctx, conns[1], protocol.Message{Type: protocol.ChatOpenWorkspace, ID: "r1"}) if read := readUntil(t, ctx, conns[1], protocol.ChatOpenWorkspace).ChatOpenWorkspace; read.Revision != 1 || !sameIDs(workspaceIDs(read), "ses_a", "ses_b*") { t.Fatalf("read = %+v", read) } // A write derived from revision 0 lands after revision 1: refused. writeChat(t, ctx, conns[1], workspaceWrite("w2", 0, b)) stale := readUntil(t, ctx, conns[1], protocol.ChatOpenWorkspace).ChatOpenWorkspace if !stale.Rejected || stale.Revision != 1 || !sameIDs(workspaceIDs(stale), "ses_a", "ses_b*") { t.Fatalf("stale write reply = %+v", stale) } // Reorder from the second connection reaches the first. b.Floating = false writeChat(t, ctx, conns[1], workspaceWrite("w3", 1, b, a)) if got := readUntil(t, ctx, conns[1], protocol.ChatOpenWorkspace).ChatOpenWorkspace; got.Revision != 2 { t.Fatalf("reorder reply = %+v", got) } if push := readWorkspacePush(t, ctx, conns[0], 2); !sameIDs(workspaceIDs(push), "ses_b", "ses_a") { t.Fatalf("reorder push = %v", workspaceIDs(push)) } // Closing ses_a drops it and pushes revision 3 to both connections. writeChat(t, ctx, conns[0], protocol.Message{Type: protocol.ChatClose, ID: "c1", ChatQuery: &protocol.ChatQuery{SessionID: "ses_a"}}) readUntil(t, ctx, conns[0], protocol.ChatClose) for i, conn := range conns { if push := readWorkspacePush(t, ctx, conn, 3); !sameIDs(workspaceIDs(push), "ses_b") { t.Fatalf("connection %d close push = %v", i, workspaceIDs(push)) } } // A client still showing the closed chat cannot restore it. writeChat(t, ctx, conns[1], workspaceWrite("w4", 3, a, b)) if got := readUntil(t, ctx, conns[1], protocol.ChatOpenWorkspace).ChatOpenWorkspace; got.Revision != 3 || !sameIDs(workspaceIDs(got), "ses_b") { t.Fatalf("closed chat restored: %+v", got) } } // TestChatOpenWorkspacePrunesOnConnectForEveryone pins that a chat closed // behind the workspace's back is pruned when a connection opens, and that the // pruned snapshot reaches the connections already open, not only the new one. func TestChatOpenWorkspacePrunesOnConnectForEveryone(t *testing.T) { store := newOperatorStore(t) ctx, _, srv, conns := dialChatServer(t, Options{Chat: scriptedChat(), OperatorRegistry: store}, 1) for _, id := range []string{"ses_a", "ses_b"} { if err := store.RecordOperatorSession(ctx, id, "/work", id, protocol.ChatSessionTagOperator); err != nil { t.Fatal(err) } } writeChat(t, ctx, conns[0], workspaceWrite("w1", 0, protocol.ChatOpenWorkspaceEntry{SessionID: "ses_a"}, protocol.ChatOpenWorkspaceEntry{SessionID: "ses_b"})) readUntil(t, ctx, conns[0], protocol.ChatOpenWorkspace) if err := store.CloseOperatorSession(ctx, "ses_a"); err != nil { t.Fatal(err) } late := dialChatConn(t, ctx, srv) for i, conn := range []*websocket.Conn{conns[0], late} { if push := readWorkspacePush(t, ctx, conn, 2); !sameIDs(workspaceIDs(push), "ses_b") { t.Fatalf("connection %d prune push = %v", i, workspaceIDs(push)) } } // With nothing to prune, a new connection alone is brought up to date. third := dialChatConn(t, ctx, srv) if push := readWorkspacePush(t, ctx, third, 2); !sameIDs(workspaceIDs(push), "ses_b") { t.Fatalf("catch-up push = %v", workspaceIDs(push)) } }