Files
openchamber-android-native/internal/appui/root_test.go
T
blumia 254d08b1bd feat: bootstrap OpenChamber native Android client
Add a Go client for OpenChamber built with Asuka's native widgets.

- internal/ocapi: health, password-to-device-token auth, session and
  message paging, prompt/interrupt/model/agent, permissions, SSE events,
  HTTP/SOCKS5 proxies and certificate pinning
- internal/storage: connection settings plus a device token in the
  platform keystore, with a per-install id for server-side dedupe
- internal/appui: connect, session list and chat screens with streaming
  Markdown, reasoning/tool folding, permission cards and session actions
- netcfg: native module that enables cleartext HTTP in release builds
- cmd/ocprobe: terminal probe for the API
- headless UI tests (uitest) and the research/plan document
2026-11-16 09:09:09 +08:00

224 lines
5.8 KiB
Go

package appui
import (
"encoding/json"
"fmt"
"net/http"
"net/http/httptest"
"sync"
"testing"
"github.com/egoist/asuka/ui"
"github.com/egoist/asuka/uitest"
"github.com/openchamber/openchamber-native/internal/storage"
)
// memStore is a storage.Store that keeps everything in memory.
type memStore struct {
mu sync.Mutex
conn storage.Connection
has bool
tokens map[string]string
id string
}
func (m *memStore) Connection() (storage.Connection, bool) {
m.mu.Lock()
defer m.mu.Unlock()
return m.conn, m.has
}
func (m *memStore) SaveConnection(c storage.Connection) {
m.mu.Lock()
defer m.mu.Unlock()
m.conn, m.has = c, c.URL != ""
}
func (m *memStore) ClearConnection() {
m.mu.Lock()
defer m.mu.Unlock()
m.conn, m.has = storage.Connection{}, false
}
func (m *memStore) InstallID() string {
if m.id == "" {
m.id = "test-install"
}
return m.id
}
func (m *memStore) LoadToken(server string) (string, bool, error) {
m.mu.Lock()
defer m.mu.Unlock()
t, ok := m.tokens[server]
return t, ok, nil
}
func (m *memStore) SaveToken(server, token string) error {
m.mu.Lock()
defer m.mu.Unlock()
if m.tokens == nil {
m.tokens = map[string]string{}
}
m.tokens[server] = token
return nil
}
func (m *memStore) ClearToken(server string) error {
m.mu.Lock()
defer m.mu.Unlock()
delete(m.tokens, server)
return nil
}
func (m *memStore) token(server string) string {
m.mu.Lock()
defer m.mu.Unlock()
return m.tokens[server]
}
func (m *memStore) connection() storage.Connection {
m.mu.Lock()
defer m.mu.Unlock()
return m.conn
}
// fakeServer stands in for OpenChamber: /health, /auth/session and the
// session list. password "" with validToken "" makes it passwordless.
func fakeServer(t *testing.T, password, validToken string) *httptest.Server {
t.Helper()
mux := http.NewServeMux()
authorized := func(r *http.Request) bool {
if validToken == "" {
return true
}
return r.Header.Get("Authorization") == "Bearer "+validToken
}
mux.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
fmt.Fprint(w, `{"status":"ok","openchamberVersion":"2.7.0","isOpenCodeReady":true,"serverId":"srv_1"}`)
})
mux.HandleFunc("/auth/session", func(w http.ResponseWriter, r *http.Request) {
if password == "" {
fmt.Fprint(w, `{"authenticated":true,"disabled":true}`)
return
}
switch r.Method {
case http.MethodGet:
if authorized(r) {
fmt.Fprint(w, `{"authenticated":true,"scope":"client"}`)
return
}
w.WriteHeader(http.StatusUnauthorized)
fmt.Fprint(w, `{"authenticated":false,"locked":true}`)
case http.MethodPost:
var body struct {
Password string `json:"password"`
}
_ = json.NewDecoder(r.Body).Decode(&body)
if body.Password != password {
w.WriteHeader(http.StatusUnauthorized)
fmt.Fprint(w, `{"error":"Invalid credentials"}`)
return
}
fmt.Fprintf(w, `{"authenticated":true,"clientToken":%q}`, validToken)
}
})
mux.HandleFunc("/api/session", func(w http.ResponseWriter, r *http.Request) {
if !authorized(r) {
w.WriteHeader(http.StatusUnauthorized)
return
}
fmt.Fprint(w, `{"data":[
{"id":"ses_1","title":"First session","time":{"created":1,"updated":2},
"location":{"directory":"/home/me/project"},"model":{"id":"m","providerID":"p"}}],
"cursor":{}}`)
})
mux.HandleFunc("/api/session/active", func(w http.ResponseWriter, r *http.Request) {
fmt.Fprint(w, `{"data":{"ses_1":{"type":"running"}}}`)
})
mux.HandleFunc("/api/permission/request", func(w http.ResponseWriter, r *http.Request) {
fmt.Fprint(w, `{"data":[]}`)
})
mux.HandleFunc("/api/event", func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/event-stream")
fmt.Fprint(w, "data: {\"id\":\"evt_1\",\"type\":\"server.connected\",\"data\":{}}\n\n")
if f, ok := w.(http.Flusher); ok {
f.Flush()
}
<-r.Context().Done()
})
srv := httptest.NewServer(mux)
t.Cleanup(srv.Close)
return srv
}
func mount(t *testing.T, st *memStore) *uitest.App {
t.Helper()
return uitest.Mount(t, func() ui.Node { return rootWithStore(st) }, uitest.Platform(ui.PlatformAndroid))
}
func TestConnectWithPassword(t *testing.T) {
srv := fakeServer(t, "secret", "oc_client_test")
st := &memStore{}
a := mount(t, st)
a.Expect("连接到 OpenChamber")
a.Type("http://192.168.1.5:3000", srv.URL)
a.Type("密码(可选)", "secret")
a.Tap("连接")
a.WaitFor("First session")
a.ExpectNo("密码(可选)")
if got := st.connection().URL; got != srv.URL {
t.Errorf("connection not saved: %q", got)
}
if got := st.token(srv.URL); got != "oc_client_test" {
t.Errorf("token not saved: %q", got)
}
}
func TestWrongPassword(t *testing.T) {
srv := fakeServer(t, "secret", "oc_client_test")
a := mount(t, &memStore{})
a.Type("http://192.168.1.5:3000", srv.URL)
a.Type("密码(可选)", "nope")
a.Tap("连接")
a.WaitFor("密码错误")
}
func TestAutoReconnectWithStoredToken(t *testing.T) {
srv := fakeServer(t, "secret", "oc_client_test")
st := &memStore{
conn: storage.Connection{URL: srv.URL},
has: true,
tokens: map[string]string{srv.URL: "oc_client_test"},
}
a := mount(t, st)
a.WaitFor("First session")
a.ExpectNo("连接到 OpenChamber")
}
func TestExpiredTokenAsksForPassword(t *testing.T) {
srv := fakeServer(t, "secret", "oc_client_test")
st := &memStore{
conn: storage.Connection{URL: srv.URL},
has: true,
tokens: map[string]string{srv.URL: "revoked"},
}
a := mount(t, st)
a.WaitFor("登录已失效,请输入密码重新连接")
a.Expect("连接到 OpenChamber")
a.Until("the revoked token to be dropped", func() bool { return st.token(srv.URL) == "" })
}
func TestPasswordlessServer(t *testing.T) {
srv := fakeServer(t, "", "")
st := &memStore{}
a := mount(t, st)
a.Type("http://192.168.1.5:3000", srv.URL)
a.Tap("连接")
a.WaitFor("First session")
if got := st.connection(); !got.Passwordless {
t.Errorf("passwordless not remembered: %+v", got)
}
}