242 lines
7.9 KiB
Go
242 lines
7.9 KiB
Go
package codexhost
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"net"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/coder/websocket"
|
|
)
|
|
|
|
type fakeServer struct {
|
|
ctx context.Context
|
|
conn *websocket.Conn
|
|
mu sync.Mutex
|
|
received chan message
|
|
ready chan struct{}
|
|
}
|
|
|
|
func testHost(t *testing.T) (*fakeServer, string, context.CancelFunc, <-chan error) {
|
|
t.Helper()
|
|
dir, err := os.MkdirTemp("/tmp", "codex-host-test-")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { os.RemoveAll(dir) })
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
t.Cleanup(cancel)
|
|
fake := &fakeServer{ctx: ctx, received: make(chan message, 64), ready: make(chan struct{})}
|
|
listener, err := net.Listen("unix", filepath.Join(dir, "upstream.sock"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
server := &http.Server{Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
conn, err := websocket.Accept(w, r, nil)
|
|
if err != nil {
|
|
return
|
|
}
|
|
fake.mu.Lock()
|
|
fake.conn = conn
|
|
fake.mu.Unlock()
|
|
close(fake.ready)
|
|
defer conn.CloseNow()
|
|
for {
|
|
_, data, err := conn.Read(ctx)
|
|
if err != nil {
|
|
return
|
|
}
|
|
var msg message
|
|
if json.Unmarshal(data, &msg) != nil {
|
|
return
|
|
}
|
|
var method string
|
|
_ = json.Unmarshal(msg["method"], &method)
|
|
if method == "initialize" {
|
|
fake.send(t, message{"id": msg["id"], "result": json.RawMessage(`{"userAgent":"fixture"}`)})
|
|
} else {
|
|
select {
|
|
case fake.received <- msg:
|
|
case <-ctx.Done():
|
|
return
|
|
}
|
|
}
|
|
}
|
|
})}
|
|
go server.Serve(listener)
|
|
t.Cleanup(func() {
|
|
server.Close()
|
|
fake.mu.Lock()
|
|
if fake.conn != nil {
|
|
fake.conn.CloseNow()
|
|
}
|
|
fake.mu.Unlock()
|
|
})
|
|
ready := make(chan string, 1)
|
|
done := make(chan error, 1)
|
|
go func() {
|
|
done <- Serve(ctx, Options{Dir: filepath.Join(dir, "private"), Upstream: filepath.Join(dir, "upstream.sock"), Ready: func(socket string) { ready <- socket }})
|
|
}()
|
|
var socket string
|
|
select {
|
|
case socket = <-ready:
|
|
case err := <-done:
|
|
t.Fatalf("host failed: %v", err)
|
|
case <-time.After(5 * time.Second):
|
|
t.Fatal("host did not initialize")
|
|
}
|
|
t.Cleanup(func() {
|
|
cancel()
|
|
select {
|
|
case <-done:
|
|
case <-time.After(5 * time.Second):
|
|
t.Error("host did not stop")
|
|
}
|
|
})
|
|
return fake, socket, cancel, done
|
|
}
|
|
func (f *fakeServer) send(t *testing.T, msg message) {
|
|
t.Helper()
|
|
f.mu.Lock()
|
|
defer f.mu.Unlock()
|
|
data, _ := json.Marshal(msg)
|
|
ctx, cancel := context.WithTimeout(f.ctx, 3*time.Second)
|
|
defer cancel()
|
|
if err := f.conn.Write(ctx, websocket.MessageText, data); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
func (f *fakeServer) next(t *testing.T) message {
|
|
t.Helper()
|
|
select {
|
|
case msg := <-f.received:
|
|
return msg
|
|
case <-time.After(3 * time.Second):
|
|
t.Fatal("missing upstream request")
|
|
return nil
|
|
}
|
|
}
|
|
func writeClient(t *testing.T, conn *websocket.Conn, raw string) {
|
|
t.Helper()
|
|
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
|
|
defer cancel()
|
|
if err := conn.Write(ctx, websocket.MessageText, []byte(raw)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
func readClient(t *testing.T, conn *websocket.Conn) message {
|
|
t.Helper()
|
|
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
|
|
defer cancel()
|
|
_, data, err := conn.Read(ctx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var msg message
|
|
if err := json.Unmarshal(data, &msg); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return msg
|
|
}
|
|
func attach(t *testing.T, socket string) *websocket.Conn {
|
|
t.Helper()
|
|
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
|
|
defer cancel()
|
|
conn, err := Dial(ctx, socket)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { conn.CloseNow() })
|
|
writeClient(t, conn, `{"id":1,"method":"initialize","params":{"clientInfo":{"name":"pipelines","version":"0.1"}}}`)
|
|
if got := readClient(t, conn); string(got["id"]) != "1" || len(got["result"]) == 0 {
|
|
t.Fatalf("initialize: %s", got)
|
|
}
|
|
return conn
|
|
}
|
|
func method(msg message) string { var s string; _ = json.Unmarshal(msg["method"], &s); return s }
|
|
|
|
func TestPendingInteractionsRemainAnswerableAcrossClientReplacement(t *testing.T) {
|
|
fake, socket, _, _ := testHost(t)
|
|
first := attach(t, socket)
|
|
fake.send(t, message{"id": json.RawMessage(`7`), "method": json.RawMessage(`"item/commandExecution/requestApproval"`), "params": json.RawMessage(`{"threadId":"thread-a","itemId":"command","command":"pwd"}`)})
|
|
fake.send(t, message{"id": json.RawMessage(`"question"`), "method": json.RawMessage(`"item/tool/requestUserInput"`), "params": json.RawMessage(`{"threadId":"thread-a","itemId":"question","questions":[{"id":"q","question":"Continue?"}]}`)})
|
|
approval, question := readClient(t, first), readClient(t, first)
|
|
first.CloseNow()
|
|
second := attach(t, socket)
|
|
replay1, replay2 := readClient(t, second), readClient(t, second)
|
|
replay := map[string]message{string(replay1["id"]): replay1, string(replay2["id"]): replay2}
|
|
for _, original := range []message{approval, question} {
|
|
got := replay[string(original["id"])]
|
|
if string(got["method"]) != string(original["method"]) || string(got["params"]) != string(original["params"]) {
|
|
t.Fatalf("callback changed: %s vs %s", got, original)
|
|
}
|
|
}
|
|
writeClient(t, second, `{"id":7,"result":{"decision":"accept"}}`)
|
|
if got := fake.next(t); string(got["id"]) != "7" || string(got["result"]) != `{"decision":"accept"}` {
|
|
t.Fatalf("approval answer: %s", got)
|
|
}
|
|
writeClient(t, second, `{"id":7,"result":{"decision":"decline"}}`)
|
|
writeClient(t, second, `{"id":"question","result":{"answers":{"q":{"answers":["yes"]}}}}`)
|
|
if got := fake.next(t); string(got["id"]) != `"question"` {
|
|
t.Fatalf("duplicate approval reached upstream: %s", got)
|
|
}
|
|
writeClient(t, second, `{"id":2,"method":"barrier"}`)
|
|
if got := fake.next(t); method(got) != "barrier" {
|
|
t.Fatalf("duplicate question reached upstream: %s", got)
|
|
}
|
|
second.CloseNow()
|
|
third := attach(t, socket)
|
|
writeClient(t, third, `{"id":2,"method":"last"}`)
|
|
call := fake.next(t)
|
|
fake.send(t, message{"id": call["id"], "result": json.RawMessage(`"done"`)})
|
|
if got := readClient(t, third); string(got["id"]) != "2" || string(got["result"]) != `"done"` {
|
|
t.Fatalf("resolved callback was replayed: %s", got)
|
|
}
|
|
}
|
|
|
|
func TestOldRPCResponseCannotAnswerNewClientCall(t *testing.T) {
|
|
fake, socket, _, _ := testHost(t)
|
|
first := attach(t, socket)
|
|
writeClient(t, first, `{"id":2,"method":"old"}`)
|
|
old := fake.next(t)
|
|
second := attach(t, socket) // closes the obsolete client
|
|
writeClient(t, second, `{"id":2,"method":"new"}`)
|
|
fresh := fake.next(t)
|
|
if string(old["id"]) == string(fresh["id"]) {
|
|
t.Fatal("client RPC IDs were reused upstream")
|
|
}
|
|
fake.send(t, message{"id": old["id"], "result": json.RawMessage(`"old"`)})
|
|
fake.send(t, message{"id": fresh["id"], "result": json.RawMessage(`"new"`)})
|
|
if got := readClient(t, second); string(got["id"]) != "2" || string(got["result"]) != `"new"` {
|
|
t.Fatalf("old RPC response crossed client identity: %s", got)
|
|
}
|
|
}
|
|
|
|
func TestResolvedNotificationClearsOnlyMatchingThread(t *testing.T) {
|
|
fake, socket, _, _ := testHost(t)
|
|
first := attach(t, socket)
|
|
request := message{"id": json.RawMessage(`3`), "method": json.RawMessage(`"item/commandExecution/requestApproval"`), "params": json.RawMessage(`{"threadId":"owner","itemId":"command"}`)}
|
|
fake.send(t, request)
|
|
readClient(t, first)
|
|
fake.send(t, message{"method": json.RawMessage(`"serverRequest/resolved"`), "params": json.RawMessage(`{"threadId":"foreign","requestId":3}`)})
|
|
readClient(t, first)
|
|
second := attach(t, socket)
|
|
if got := readClient(t, second); string(got["id"]) != "3" {
|
|
t.Fatalf("foreign thread resolved callback: %s", got)
|
|
}
|
|
fake.send(t, message{"method": json.RawMessage(`"serverRequest/resolved"`), "params": json.RawMessage(`{"threadId":"owner","requestId":3}`)})
|
|
readClient(t, second)
|
|
third := attach(t, socket)
|
|
writeClient(t, third, `{"id":2,"method":"barrier"}`)
|
|
call := fake.next(t)
|
|
fake.send(t, message{"id": call["id"], "result": json.RawMessage(`null`)})
|
|
if got := readClient(t, third); len(got["method"]) > 0 {
|
|
t.Fatalf("resolved callback replayed: %s", got)
|
|
}
|
|
}
|