Files

309 lines
9.3 KiB
Go
Raw Permalink Normal View History

package ocapi
import (
"context"
"encoding/json"
"fmt"
"io"
"net/http"
"net/http/httptest"
"strings"
"testing"
"time"
)
func TestNormalizeBaseURL(t *testing.T) {
cases := []struct {
in, want string
}{
{"127.0.0.1:3000", "http://127.0.0.1:3000"},
{"192.168.1.5:3000/", "http://192.168.1.5:3000"},
{"http://host:3000/", "http://host:3000"},
{"https://oc.example.com", "https://oc.example.com"},
{"oc.example.com", "https://oc.example.com"},
}
for _, c := range cases {
got, err := NormalizeBaseURL(c.in)
if err != nil {
t.Fatalf("NormalizeBaseURL(%q): %v", c.in, err)
}
if got != c.want {
t.Errorf("NormalizeBaseURL(%q) = %q, want %q", c.in, got, c.want)
}
}
if _, err := NormalizeBaseURL(" "); err == nil {
t.Error("empty URL accepted")
}
if _, err := NormalizeBaseURL("ftp://host"); err == nil {
t.Error("ftp scheme accepted")
}
}
func TestHealth(t *testing.T) {
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/health" {
t.Errorf("path = %q", r.URL.Path)
}
fmt.Fprint(w, `{"status":"ok","openchamberVersion":"2.7.0","serverId":"abc","isOpenCodeReady":true}`)
}))
defer srv.Close()
c, err := New(srv.URL, Options{})
if err != nil {
t.Fatal(err)
}
h, err := c.Health(context.Background())
if err != nil {
t.Fatal(err)
}
if h.OpenChamberVersion != "2.7.0" || h.ServerID != "abc" || !h.IsOpenCodeReady {
t.Fatalf("unexpected health: %+v", h)
}
}
func TestSessionStatusAndLogin(t *testing.T) {
var loginBody map[string]any
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
switch r.URL.Path {
case "/auth/session":
if r.Method == http.MethodGet {
w.WriteHeader(http.StatusUnauthorized)
fmt.Fprint(w, `{"authenticated":false,"locked":true}`)
return
}
if err := json.NewDecoder(r.Body).Decode(&loginBody); err != nil {
t.Errorf("login body: %v", err)
}
fmt.Fprint(w, `{"authenticated":true,"clientToken":"oc_client_test"}`)
default:
t.Errorf("unexpected path %q", r.URL.Path)
}
}))
defer srv.Close()
c, _ := New(srv.URL, Options{})
_, err := c.SessionStatus(context.Background())
if !IsUnauthorized(err) {
t.Fatalf("want 401, got %v", err)
}
res, err := c.Login(context.Background(), LoginRequest{Password: "pw", DedupeKey: "install-1"})
if err != nil {
t.Fatal(err)
}
if res.ClientToken != "oc_client_test" || c.Token() != "oc_client_test" {
t.Fatalf("token not stored: %+v, %q", res, c.Token())
}
if loginBody["trustDevice"] != true || loginBody["issueClientToken"] != true {
t.Errorf("login defaults missing: %v", loginBody)
}
if loginBody["clientKind"] != "mobile" || loginBody["password"] != "pw" {
t.Errorf("login body: %v", loginBody)
}
}
func TestListSessionsScoped(t *testing.T) {
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/api/session" {
t.Errorf("path = %q", r.URL.Path)
}
if got := r.URL.Query().Get("directory"); got != "/home/me/proj" {
t.Errorf("directory query = %q", got)
}
if got := r.Header.Get("x-opencode-directory"); got != "%2Fhome%2Fme%2Fproj" {
t.Errorf("directory header = %q", got)
}
if got := r.Header.Get("x-opencode-directory-encoding"); got != "uri" {
t.Errorf("directory encoding = %q", got)
}
if got := r.URL.Query().Get("limit"); got != "50" {
t.Errorf("limit = %q", got)
}
fmt.Fprint(w, `{"data":[{"id":"ses_1","title":"Hi","time":{"created":1,"updated":2},"location":{"directory":"/home/me/proj"}}],"cursor":{"next":"n1"}}`)
}))
defer srv.Close()
c, _ := New(srv.URL, Options{})
page, err := c.ListSessions(context.Background(), ListSessionsOptions{Directory: "/home/me/proj", Limit: 50})
if err != nil {
t.Fatal(err)
}
if len(page.Data) != 1 || page.Data[0].ID != "ses_1" || page.Cursor.Next != "n1" {
t.Fatalf("unexpected page: %+v", page)
}
}
func TestMessagesAndTurn(t *testing.T) {
var promptBody map[string]any
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
switch r.URL.Path {
case "/api/session/ses_1/message":
if got := r.URL.Query().Get("order"); got != "desc" {
t.Errorf("order = %q", got)
}
fmt.Fprint(w, `{"data":[{"id":"msg_1","type":"assistant","content":[{"type":"text","text":"hello"}]}],"cursor":{"next":"m1"}}`)
case "/api/session/ses_1/prompt":
_ = json.NewDecoder(r.Body).Decode(&promptBody)
fmt.Fprint(w, `{"data":{}}`)
case "/api/session/ses_1/interrupt":
fmt.Fprint(w, `{"interrupted":true}`)
default:
t.Errorf("unexpected path %q", r.URL.Path)
}
}))
defer srv.Close()
c, _ := New(srv.URL, Options{})
page, err := c.ListMessages(context.Background(), "ses_1", ListMessagesOptions{Limit: 20, Order: "desc"})
if err != nil {
t.Fatal(err)
}
if len(page.Data) != 1 || page.Data[0].Content[0].Text != "hello" {
t.Fatalf("unexpected messages: %+v", page)
}
if err := c.Prompt(context.Background(), "ses_1", PromptOptions{
Text: "ping", MessageID: "msg_9",
Files: []PromptFile{{URI: "data:text/plain;base64,aGk=", Name: "note.txt"}},
}); err != nil {
t.Fatal(err)
}
if promptBody["text"] != "ping" || promptBody["id"] != "msg_9" {
t.Errorf("prompt body: %v", promptBody)
}
files, _ := promptBody["files"].([]any)
if len(files) != 1 {
t.Fatalf("prompt files: %v", promptBody["files"])
}
file, _ := files[0].(map[string]any)
if file["name"] != "note.txt" || file["uri"] != "data:text/plain;base64,aGk=" {
t.Errorf("prompt file: %v", file)
}
ok, err := c.Interrupt(context.Background(), "ses_1", "")
if err != nil || !ok {
t.Fatalf("interrupt: %v %v", ok, err)
}
}
func TestRateLimit(t *testing.T) {
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusTooManyRequests)
fmt.Fprint(w, `{"error":"Too many login attempts, please try again later","retryAfter":12}`)
}))
defer srv.Close()
c, _ := New(srv.URL, Options{})
_, err := c.Login(context.Background(), LoginRequest{Password: "x"})
wait, ok := IsRateLimited(err)
if !ok || wait != 12*time.Second {
t.Fatalf("rate limit: %v %v", wait, err)
}
}
func TestStreamEvents(t *testing.T) {
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if got := r.URL.Query()["types"]; len(got) != 2 {
t.Errorf("types = %v", got)
}
w.Header().Set("Content-Type", "text/event-stream")
flusher := w.(http.Flusher)
// Split an event across writes and use two data lines, which
// SSE joins with a newline.
fmt.Fprint(w, "event: message\n")
flusher.Flush()
fmt.Fprint(w, "data: {\"id\":\"evt_1\",")
flusher.Flush()
fmt.Fprint(w, "\"type\":\"session.text.delta\",")
flusher.Flush()
fmt.Fprint(w, "\"data\":{\"delta\":\"hi\"}}\n\n")
flusher.Flush()
<-r.Context().Done()
}))
defer srv.Close()
c, _ := New(srv.URL, Options{})
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
got := make(chan Event, 1)
go func() {
_ = c.StreamEvents(ctx, []string{"session.text.delta", "permission.asked"}, func(ev Event) error {
got <- ev
cancel()
return nil
})
}()
select {
case ev := <-got:
if ev.ID != "evt_1" || ev.Type != "session.text.delta" {
t.Fatalf("event: %+v", ev)
}
var data SessionEventData
if err := ev.UnmarshalData(&data); err != nil || data.Delta != "hi" {
t.Fatalf("data: %+v %v", data, err)
}
case <-time.After(5 * time.Second):
t.Fatal("timed out waiting for an event")
}
}
func TestProxyDialer(t *testing.T) {
// A SOCKS5 address is accepted; the connection itself is not made.
c, err := New("http://127.0.0.1:3000", Options{Proxy: "socks5://127.0.0.1:1080"})
if err != nil {
t.Fatal(err)
}
if c.http.Transport == nil {
t.Fatal("no transport")
}
if _, err := New("http://127.0.0.1:3000", Options{Proxy: "ftp://x"}); err == nil {
t.Fatal("unsupported proxy scheme accepted")
}
}
func TestDecodeMessageContent(t *testing.T) {
body := `{"data":[{"id":"msg_1","type":"assistant","content":[
{"type":"reasoning","text":"think"},
{"type":"text","text":"answer"},
{"type":"tool","id":"call_1","name":"shell","state":{"status":"completed","input":{"command":"ls"},"content":[{"type":"text","text":"a.txt"}]}}]}]}`
var page MessagePage
if err := json.Unmarshal([]byte(body), &page); err != nil {
t.Fatal(err)
}
m := page.Data[0]
if len(m.Content) != 3 || m.Content[2].State == nil || m.Content[2].State.Status != "completed" {
t.Fatalf("content: %+v", m.Content)
}
if m.Content[2].State.Input["command"] != "ls" {
t.Fatalf("input: %+v", m.Content[2].State.Input)
}
if m.Content[2].State.Content[0].Text != "a.txt" {
t.Fatalf("tool content: %+v", m.Content[2].State.Content)
}
}
func TestErrorBodyKept(t *testing.T) {
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusBadRequest)
_, _ = io.WriteString(w, `{"error":"bad thing"}`)
}))
defer srv.Close()
c, _ := New(srv.URL, Options{})
err := c.DeleteSession(context.Background(), "ses_x", "")
var apiErr *APIError
if !strings.Contains(err.Error(), "bad thing") || !asAPIError(err, &apiErr) || apiErr.Status != 400 {
t.Fatalf("error: %v", err)
}
}
func asAPIError(err error, target **APIError) bool {
for err != nil {
if e, ok := err.(*APIError); ok {
*target = e
return true
}
u, ok := err.(interface{ Unwrap() error })
if !ok {
return false
}
err = u.Unwrap()
}
return false
}