Files
archie/internal/webui/api_harness_test.go
T
sam 751d7afb60 feat(webui): the dashboard reads harness bindings and opens the setup terminal
The harness page lists each credential binding with its captured OAuth
state (expiry, scopes, capture time; never the tokens), and the setup
terminal route upgrades to a WebSocket and bridges it to a harness
session. The session is a narrow webui-owned HarnessTerminal seam: the
container, sandbox network and egress path belong to the daemon, so the
dashboard process cannot implement it and answers 503 until a transport
is wired (archie-core-egkf.7). Opening the terminal authorizes as the
update action on the secret, per the PRD.
2026-10-02 09:38:09 +10:00

292 lines
9.7 KiB
Go

package webui
import (
"context"
"encoding/json"
"errors"
"io"
"log/slog"
"net"
"net/http"
"net/http/httptest"
"strings"
"testing"
"time"
"golang.org/x/net/websocket"
controlpb "github.com/samcharles93/archie-core/internal/contracts/controlplane/v1"
"github.com/samcharles93/archie-core/internal/domain/access"
"github.com/samcharles93/archie-core/internal/domain/harnesssecret"
"github.com/samcharles93/archie-core/internal/domain/org"
"github.com/samcharles93/archie-core/internal/domain/storecontract"
)
// harnessSecretStub answers the harness store's two methods from a fixed
// map keyed "org/service".
type harnessSecretStub struct {
secrets map[string]harnesssecret.Secret
err error
}
func (s *harnessSecretStub) GetHarnessSecret(_ context.Context, orgID, service string) (harnesssecret.Secret, error) {
if s.err != nil {
return harnesssecret.Secret{}, s.err
}
if secret, ok := s.secrets[orgID+"/"+service]; ok {
return secret, nil
}
return harnesssecret.Secret{}, storecontract.ErrHarnessSecretNotFound
}
func (s *harnessSecretStub) PutHarnessSecret(context.Context, harnesssecret.Secret) error {
return nil
}
// pipeTerminal hands the test the far end of a net.Pipe for every session it
// opens, so the bridge test can drive both directions without a container.
type pipeTerminal struct {
peers chan net.Conn
}
func newPipeTerminal() *pipeTerminal { return &pipeTerminal{peers: make(chan net.Conn, 1)} }
func (p *pipeTerminal) Open(context.Context, string, string) (io.ReadWriteCloser, error) {
client, peer := net.Pipe()
p.peers <- peer
return client, nil
}
type failingTerminal struct{ err error }
func (f failingTerminal) Open(context.Context, string, string) (io.ReadWriteCloser, error) {
return nil, f.err
}
func harnessResources() map[string]*controlpb.Resource {
return map[string]*controlpb.Resource{
harnessBindingsKind: {Kind: harnessBindingsKind, ValueJson: []byte(
`[{"service":"github","secret":{"engine":"env","key":"GH"}},{"service":"linear"}]`,
)},
harnessProfilesKind: {Kind: harnessProfilesKind, ValueJson: []byte(
`{"claude-kit":{"kit":"ghcr.io/x/y@sha256:abc"},"plain":{"image":"x"}}`,
)},
}
}
// TestHarnessBindingsJoinsCaptureState: the page lists every binding and the
// capture state of the ones with a stored token set, and it never carries the
// token itself.
func TestHarnessBindingsJoinsCaptureState(t *testing.T) {
expires := time.Date(2026, 10, 2, 12, 0, 0, 0, time.UTC)
updated := expires.Add(-time.Hour)
secrets := &harnessSecretStub{secrets: map[string]harnesssecret.Secret{
string(org.DefaultOrgID) + "/github": {
Org: string(org.DefaultOrgID), Service: "github", AccessToken: "secret-token",
ExpiresAt: expires, UpdatedAt: updated, Scopes: []string{"repo", "read:org"},
},
}}
srv := &Server{
Log: slog.New(slog.DiscardHandler),
ControlPlane: &controlPlaneClientStub{resources: harnessResources()},
HarnessSecrets: secrets,
}
request := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/api/harness/bindings", nil)
response := httptest.NewRecorder()
srv.Handler().ServeHTTP(response, request)
if response.Code != http.StatusOK {
t.Fatalf("status = %d, body = %q", response.Code, response.Body.String())
}
var got harnessView
if err := json.Unmarshal(response.Body.Bytes(), &got); err != nil {
t.Fatal(err)
}
if got.Terminal {
t.Error("terminal reported available with no HarnessTerminal wired")
}
if len(got.Profiles) != 1 || got.Profiles[0] != "claude-kit" {
t.Fatalf("profiles = %v, want the Kit profile only", got.Profiles)
}
if len(got.Bindings) != 2 {
t.Fatalf("bindings = %+v", got.Bindings)
}
github := got.Bindings[0]
if github.Service != "github" || !github.Captured || github.ExpiresAt == nil || !github.ExpiresAt.Equal(expires) {
t.Fatalf("github binding = %+v", github)
}
if len(github.Scopes) != 2 || github.Scopes[0] != "repo" {
t.Fatalf("scopes = %v", github.Scopes)
}
if linear := got.Bindings[1]; linear.Service != "linear" || linear.Captured {
t.Fatalf("linear binding = %+v, want listed but uncaptured", linear)
}
// The token must not cross the wire in any form.
if body := response.Body.String(); strings.Contains(body, "secret-token") {
t.Fatalf("response leaked the access token: %s", body)
}
}
// TestHarnessBindingsUnavailableWithoutItsContracts: the page needs both the
// control-plane resource and the token store; either missing is a 503, never
// an empty page that reads as "this org has no bindings".
func TestHarnessBindingsUnavailableWithoutItsContracts(t *testing.T) {
cases := []struct {
name string
srv *Server
}{
{"no control plane", &Server{Log: slog.New(slog.DiscardHandler), HarnessSecrets: &harnessSecretStub{}}},
{"no secret store", &Server{Log: slog.New(slog.DiscardHandler), ControlPlane: &controlPlaneClientStub{resources: harnessResources()}}},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
request := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/api/harness/bindings", nil)
response := httptest.NewRecorder()
tc.srv.Handler().ServeHTTP(response, request)
if response.Code != http.StatusServiceUnavailable {
t.Fatalf("status = %d, want 503", response.Code)
}
})
}
}
// TestHarnessTerminalUnwiredDegrades503 is the lane's required degrade path:
// with no transport for the session, the route answers 503 and the page can
// say the terminal is unavailable rather than failing a browser upgrade.
func TestHarnessTerminalUnwiredDegrades503(t *testing.T) {
srv := &Server{Log: slog.New(slog.DiscardHandler)}
request := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/api/harness/terminal?profile=claude-kit", nil)
request.Header.Set("Upgrade", "websocket")
response := httptest.NewRecorder()
srv.Handler().ServeHTTP(response, request)
if response.Code != http.StatusServiceUnavailable {
t.Fatalf("status = %d, want 503", response.Code)
}
}
func TestHarnessTerminalRejectsNonUpgradeAndMissingProfile(t *testing.T) {
srv := &Server{Log: slog.New(slog.DiscardHandler), HarnessTerminal: newPipeTerminal()}
cases := []struct {
name string
path string
upgrade bool
want int
}{
{"no upgrade", "/api/harness/terminal?profile=claude-kit", false, http.StatusUpgradeRequired},
{"no profile", "/api/harness/terminal", true, http.StatusBadRequest},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
request := httptest.NewRequestWithContext(t.Context(), http.MethodGet, tc.path, nil)
if tc.upgrade {
request.Header.Set("Upgrade", "websocket")
}
response := httptest.NewRecorder()
srv.Handler().ServeHTTP(response, request)
if response.Code != tc.want {
t.Fatalf("status = %d, want %d", response.Code, tc.want)
}
})
}
}
func TestHarnessTerminalOpenFailureIsBadGateway(t *testing.T) {
srv := &Server{Log: slog.New(slog.DiscardHandler), HarnessTerminal: failingTerminal{err: errors.New("no daemon")}}
request := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/api/harness/terminal?profile=claude-kit", nil)
request.Header.Set("Upgrade", "websocket")
response := httptest.NewRecorder()
srv.Handler().ServeHTTP(response, request)
if response.Code != http.StatusBadGateway {
t.Fatalf("status = %d, want 502", response.Code)
}
}
// TestHarnessTerminalBridgesWebSocketToSession proves the upgrade path moves
// bytes both ways: the WebSocket is a PTY, so what the browser types reaches
// the session and what the session prints reaches the browser.
func TestHarnessTerminalBridgesWebSocketToSession(t *testing.T) {
terminal := newPipeTerminal()
srv := &Server{Log: slog.New(slog.DiscardHandler), HarnessTerminal: terminal}
ts := httptest.NewServer(srv.Handler())
t.Cleanup(ts.Close)
wsURL := "ws" + strings.TrimPrefix(ts.URL, "http") + "/api/harness/terminal?profile=claude-kit"
ws, err := websocket.Dial(wsURL, "", ts.URL)
if err != nil {
t.Fatalf("dial: %v", err)
}
t.Cleanup(func() { _ = ws.Close() })
var peer net.Conn
select {
case peer = <-terminal.peers:
case <-time.After(5 * time.Second):
t.Fatal("the handler never opened a session")
}
t.Cleanup(func() { _ = peer.Close() })
// Session to browser.
go func() { _, _ = peer.Write([]byte("from-session")) }()
got := make([]byte, len("from-session"))
_ = ws.SetReadDeadline(time.Now().Add(5 * time.Second))
if _, err := io.ReadFull(ws, got); err != nil {
t.Fatalf("read from websocket: %v", err)
}
if string(got) != "from-session" {
t.Fatalf("websocket read %q", got)
}
// Browser to session.
typed := make(chan string, 1)
go func() {
buf := make([]byte, len("from-browser"))
if _, err := io.ReadFull(peer, buf); err != nil {
typed <- "ERR:" + err.Error()
return
}
typed <- string(buf)
}()
if _, err := ws.Write([]byte("from-browser")); err != nil {
t.Fatalf("write to websocket: %v", err)
}
select {
case got := <-typed:
if got != "from-browser" {
t.Fatalf("session read %q", got)
}
case <-time.After(5 * time.Second):
t.Fatal("the session never received the browser's input")
}
}
// TestHarnessRoutesAuthorizeAsSecretUpdate pins the route mapping the PRD
// names: opening the terminal is the update action on the secret, and the
// bindings read is a secret read.
func TestHarnessRoutesAuthorizeAsSecretUpdate(t *testing.T) {
cases := []struct {
path string
method string
want access.Action
kind access.ResourceKind
}{
{"/api/harness/terminal", http.MethodGet, access.ActionUpdate, access.KindSecret},
{"/api/harness/bindings", http.MethodGet, access.ActionRead, access.KindSecret},
}
for _, tc := range cases {
request := httptest.NewRequestWithContext(t.Context(), tc.method, tc.path, nil)
action, kind, _ := accessRequest(request)
if action != tc.want || kind != tc.kind {
t.Errorf("%s: got %s/%s, want %s/%s", tc.path, action, kind, tc.want, tc.kind)
}
}
}