test(agentctl): cover the agentctl HTTP API handlers (#2499)

Co-authored-by: Kandev Agent <agent@kandev.dev>
Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
João Salavisa
2026-08-10 20:44:44 +02:00
committed by GitHub
parent 5df7d5be7f
commit e9d3cb02cb
13 changed files with 3667 additions and 48 deletions
@@ -0,0 +1,350 @@
package api
import (
"context"
"errors"
"io"
"strings"
"testing"
"github.com/kandev/kandev/internal/agentctl/server/adapter"
"github.com/kandev/kandev/internal/agentctl/types"
v1 "github.com/kandev/kandev/pkg/api/v1"
ws "github.com/kandev/kandev/pkg/websocket"
)
// bareAgentAdapter satisfies adapter.AgentAdapter and nothing else, so it
// stands in for a transport that supports none of the optional session
// controls (set_mode, set_model, authenticate, reset).
type bareAgentAdapter struct {
sessionID string
}
func (*bareAgentAdapter) PrepareEnvironment() (map[string]string, error) { return nil, nil }
func (*bareAgentAdapter) PrepareCommandArgs() []string { return nil }
func (*bareAgentAdapter) Connect(io.Writer, io.Reader) error { return nil }
func (*bareAgentAdapter) Initialize(context.Context) error { return nil }
func (*bareAgentAdapter) GetAgentInfo() *adapter.AgentInfo { return nil }
func (a *bareAgentAdapter) NewSession(context.Context, []types.McpServer) (string, error) {
return a.sessionID, nil
}
func (a *bareAgentAdapter) LoadSession(_ context.Context, sessionID string, _ []types.McpServer) error {
a.sessionID = sessionID
return nil
}
func (*bareAgentAdapter) Prompt(context.Context, string, []v1.MessageAttachment, uint64) error {
return nil
}
func (*bareAgentAdapter) Cancel(context.Context) error { return nil }
func (*bareAgentAdapter) Updates() <-chan adapter.AgentEvent { return nil }
func (a *bareAgentAdapter) GetSessionID() string { return a.sessionID }
func (*bareAgentAdapter) GetOperationID() string { return "" }
func (*bareAgentAdapter) SetPermissionHandler(adapter.PermissionHandler) {}
func (*bareAgentAdapter) Close() error { return nil }
func (*bareAgentAdapter) RequiresProcessKill() bool { return false }
// capableAgentAdapter additionally implements every optional session-control
// interface and records exactly what it was handed, so the tests can prove the
// payload field reached the adapter rather than a zero value.
type capableAgentAdapter struct {
bareAgentAdapter
modeID string
modelID string
methodID string
resetServers []types.McpServer
resetErr error
failWith error
}
func (a *capableAgentAdapter) SetMode(_ context.Context, modeID string) error {
a.modeID = modeID
return a.failWith
}
func (a *capableAgentAdapter) SetModel(_ context.Context, modelID string) error {
a.modelID = modelID
return a.failWith
}
func (a *capableAgentAdapter) Authenticate(_ context.Context, methodID string) error {
a.methodID = methodID
return a.failWith
}
func (a *capableAgentAdapter) ResetSession(_ context.Context, servers []types.McpServer) (string, error) {
a.resetServers = servers
if a.resetErr != nil {
return "", a.resetErr
}
return "session-after-reset", nil
}
func errorPayload(t *testing.T, msg *ws.Message) ws.ErrorPayload {
t.Helper()
if msg.Type != ws.MessageTypeError {
t.Fatalf("message type = %q, want %q (payload %s)", msg.Type, ws.MessageTypeError, string(msg.Payload))
}
var payload ws.ErrorPayload
if err := msg.ParsePayload(&payload); err != nil {
t.Fatalf("parse error payload: %v", err)
}
return payload
}
func assertAdapterActionSuccess(t *testing.T, msg *ws.Message) {
t.Helper()
if msg.Type == ws.MessageTypeError {
t.Fatalf("action failed: %s", string(msg.Payload))
}
var payload map[string]any
if err := msg.ParsePayload(&payload); err != nil {
t.Fatalf("parse response payload: %v", err)
}
if payload["success"] != true {
t.Errorf("payload = %v, want success:true", payload)
}
}
// adapterActionCase describes one optional session-control handler. Running
// them through a single table is what keeps the three failure shapes
// (no adapter / unsupported adapter / adapter error) identical across
// handlers — the frontend renders them with shared code.
type adapterActionCase struct {
name string
action string
payload any
invoke func(s *Server, msg *ws.Message) *ws.Message
// unsupported is the message a transport lacking the optional interface
// must produce.
unsupported string
// assertReceived checks the value the adapter was handed.
assertReceived func(t *testing.T, a *capableAgentAdapter)
}
func adapterActionCases() []adapterActionCase {
return []adapterActionCase{
{
name: "set_mode",
action: "agent.session.set_mode",
payload: map[string]string{"session_id": "s1", "mode_id": "plan"},
invoke: func(s *Server, msg *ws.Message) *ws.Message { return s.handleWSSetMode(context.Background(), msg) },
unsupported: "agent does not support mode switching",
assertReceived: func(t *testing.T, a *capableAgentAdapter) {
if a.modeID != "plan" {
t.Errorf("mode_id = %q, want %q", a.modeID, "plan")
}
},
},
{
name: "set_model",
action: "agent.session.set_model",
payload: map[string]string{"model_id": "claude-opus-5"},
invoke: func(s *Server, msg *ws.Message) *ws.Message { return s.handleWSSetModel(context.Background(), msg) },
unsupported: "agent does not support model switching",
assertReceived: func(t *testing.T, a *capableAgentAdapter) {
if a.modelID != "claude-opus-5" {
t.Errorf("model_id = %q, want %q", a.modelID, "claude-opus-5")
}
},
},
{
name: "authenticate",
action: "agent.authenticate",
payload: map[string]string{"method_id": "oauth"},
invoke: func(s *Server, msg *ws.Message) *ws.Message { return s.handleWSAuthenticate(context.Background(), msg) },
unsupported: "agent does not support authenticate",
assertReceived: func(t *testing.T, a *capableAgentAdapter) {
if a.methodID != "oauth" {
t.Errorf("method_id = %q, want %q", a.methodID, "oauth")
}
},
},
}
}
// TestAdapterActions_ForwardPayloadToAdapter covers the success branch of
// adapterAction for every optional session control, and asserts the specific
// payload field reached the adapter.
func TestAdapterActions_ForwardPayloadToAdapter(t *testing.T) {
for _, tc := range adapterActionCases() {
t.Run(tc.name, func(t *testing.T) {
s := newTestServer(t)
agentAdapter := &capableAgentAdapter{}
s.procMgr.SetAdapterForTest(agentAdapter)
msg, err := ws.NewRequest("req-1", tc.action, tc.payload)
if err != nil {
t.Fatalf("build request: %v", err)
}
assertAdapterActionSuccess(t, tc.invoke(s, msg))
tc.assertReceived(t, agentAdapter)
})
}
}
// TestAdapterActions_RejectWhenAgentNotRunning covers the nil-adapter branch,
// which is what a click on a stale UI produces after the agent exits.
func TestAdapterActions_RejectWhenAgentNotRunning(t *testing.T) {
for _, tc := range adapterActionCases() {
t.Run(tc.name, func(t *testing.T) {
s := newTestServer(t)
msg, err := ws.NewRequest("req-1", tc.action, tc.payload)
if err != nil {
t.Fatalf("build request: %v", err)
}
payload := errorPayload(t, tc.invoke(s, msg))
if payload.Code != ws.ErrorCodeInternalError {
t.Errorf("code = %q, want %q", payload.Code, ws.ErrorCodeInternalError)
}
if payload.Message != "agent not running" {
t.Errorf("message = %q, want %q", payload.Message, "agent not running")
}
})
}
}
// TestAdapterActions_RejectUnsupportedTransport covers the interface assertion.
// A transport that never implemented the control must say so by name rather
// than reporting a generic failure.
func TestAdapterActions_RejectUnsupportedTransport(t *testing.T) {
for _, tc := range adapterActionCases() {
t.Run(tc.name, func(t *testing.T) {
s := newTestServer(t)
s.procMgr.SetAdapterForTest(&bareAgentAdapter{})
msg, err := ws.NewRequest("req-1", tc.action, tc.payload)
if err != nil {
t.Fatalf("build request: %v", err)
}
if got := errorPayload(t, tc.invoke(s, msg)).Message; got != tc.unsupported {
t.Errorf("message = %q, want %q", got, tc.unsupported)
}
})
}
}
// TestAdapterActions_SurfaceAdapterError covers the last branch: the adapter
// accepted the call and failed, and its reason has to reach the caller intact.
func TestAdapterActions_SurfaceAdapterError(t *testing.T) {
for _, tc := range adapterActionCases() {
t.Run(tc.name, func(t *testing.T) {
s := newTestServer(t)
s.procMgr.SetAdapterForTest(&capableAgentAdapter{failWith: errors.New("upstream refused")})
msg, err := ws.NewRequest("req-1", tc.action, tc.payload)
if err != nil {
t.Fatalf("build request: %v", err)
}
if got := errorPayload(t, tc.invoke(s, msg)).Message; got != "upstream refused" {
t.Errorf("message = %q, want %q", got, "upstream refused")
}
})
}
}
// TestAdapterActions_RejectMalformedPayload covers the parse guard, which runs
// before the adapter is even looked up.
func TestAdapterActions_RejectMalformedPayload(t *testing.T) {
for _, tc := range adapterActionCases() {
t.Run(tc.name, func(t *testing.T) {
s := newTestServer(t)
s.procMgr.SetAdapterForTest(&capableAgentAdapter{})
msg, err := ws.NewRequest("req-1", tc.action, "not-an-object")
if err != nil {
t.Fatalf("build request: %v", err)
}
payload := errorPayload(t, tc.invoke(s, msg))
if payload.Code != ws.ErrorCodeBadRequest {
t.Errorf("code = %q, want %q", payload.Code, ws.ErrorCodeBadRequest)
}
if !strings.HasPrefix(payload.Message, "invalid request: ") {
t.Errorf("message = %q, want an %q prefix", payload.Message, "invalid request: ")
}
})
}
}
// TestHandleWSResetSession_ReturnsNewSessionID covers the happy path of the
// context-reset control. The new session ID is what the backend persists as
// ACPSessionID, so returning the old one would silently break resume.
func TestHandleWSResetSession_ReturnsNewSessionID(t *testing.T) {
s := newTestServer(t)
agentAdapter := &capableAgentAdapter{}
agentAdapter.sessionID = "session-before-reset"
s.procMgr.SetAdapterForTest(agentAdapter)
msg, err := ws.NewRequest("req-1", "agent.session.reset", NewSessionRequest{
McpServers: []types.McpServer{{Name: "external", URL: "https://example.invalid/mcp"}},
})
if err != nil {
t.Fatalf("build request: %v", err)
}
resp := s.handleWSResetSession(context.Background(), msg)
if resp.Type == ws.MessageTypeError {
t.Fatalf("reset failed: %s", string(resp.Payload))
}
var payload NewSessionResponse
if err := resp.ParsePayload(&payload); err != nil {
t.Fatalf("parse reset payload: %v", err)
}
if !payload.Success || payload.SessionID != "session-after-reset" {
t.Errorf("payload = %+v, want the adapter's new session id", payload)
}
if len(agentAdapter.resetServers) != 1 || agentAdapter.resetServers[0].Name != "external" {
t.Errorf("adapter received %+v, want the caller's MCP servers", agentAdapter.resetServers)
}
}
// TestHandleWSResetSession_Rejections covers all three refusal branches of the
// reset handler, which does not go through adapterAction and so needs its own
// coverage of each shape.
func TestHandleWSResetSession_Rejections(t *testing.T) {
cases := []struct {
name string
payload any
adapter adapter.AgentAdapter
wantCode string
wantMessage string
}{
{"malformed payload", "not-an-object", &capableAgentAdapter{}, ws.ErrorCodeBadRequest, ""},
{"agent not running", NewSessionRequest{}, nil, ws.ErrorCodeInternalError, "agent not running"},
{
"unsupported transport",
NewSessionRequest{},
&bareAgentAdapter{},
ws.ErrorCodeInternalError,
"agent does not support session reset",
},
{
"adapter failure",
NewSessionRequest{},
&capableAgentAdapter{resetErr: errors.New("reset refused")},
ws.ErrorCodeInternalError,
"reset refused",
},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
s := newTestServer(t)
if tc.adapter != nil {
s.procMgr.SetAdapterForTest(tc.adapter)
}
msg, err := ws.NewRequest("req-1", "agent.session.reset", tc.payload)
if err != nil {
t.Fatalf("build request: %v", err)
}
payload := errorPayload(t, s.handleWSResetSession(context.Background(), msg))
if payload.Code != tc.wantCode {
t.Errorf("code = %q, want %q", payload.Code, tc.wantCode)
}
if tc.wantMessage != "" && payload.Message != tc.wantMessage {
t.Errorf("message = %q, want %q", payload.Message, tc.wantMessage)
}
})
}
}
@@ -0,0 +1,973 @@
package api
import (
"bytes"
"encoding/json"
"errors"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"slices"
"strings"
"testing"
"github.com/gin-gonic/gin"
"github.com/kandev/kandev/internal/agentctl/server/config"
"github.com/kandev/kandev/internal/agentctl/server/process"
"github.com/kandev/kandev/internal/common/logger"
)
// gitAPIFixture is a single-repo workspace wired to a bare `origin` remote.
// The remote matters: it gives `origin/main` a real ref so merge-base anchoring
// in handleGitLog / handleGitCumulativeDiff behaves the way it does in
// production rather than falling through the no-upstream recovery paths.
type gitAPIFixture struct {
server *Server
repo string
bare string
}
// newGitAPIFixture seeds main (one commit, pushed to origin) plus a
// feature/work branch carrying two more commits, and returns a Server whose
// workspace root is that repository.
func newGitAPIFixture(t *testing.T) *gitAPIFixture {
t.Helper()
root := t.TempDir()
bare := filepath.Join(root, "origin.git")
runGitAPI(t, root, "init", "--bare", "--initial-branch=main", bare)
repo := filepath.Join(root, "work")
if err := os.Mkdir(repo, 0o755); err != nil {
t.Fatalf("mkdir work: %v", err)
}
runGitAPI(t, repo, "init", "--initial-branch=main")
runGitAPI(t, repo, "config", "user.email", "test@test.com")
runGitAPI(t, repo, "config", "user.name", "Test User")
writeFileAPI(t, repo, "README.md", "base\n")
runGitAPI(t, repo, "add", ".")
runGitAPI(t, repo, "commit", "-m", "initial")
runGitAPI(t, repo, "remote", "add", "origin", bare)
runGitAPI(t, repo, "push", "-u", "origin", "main")
runGitAPI(t, repo, "checkout", "-b", "feature/work")
writeFileAPI(t, repo, "one.txt", "one\n")
runGitAPI(t, repo, "add", ".")
runGitAPI(t, repo, "commit", "-m", "feature one")
writeFileAPI(t, repo, "two.txt", "two\n")
runGitAPI(t, repo, "add", ".")
runGitAPI(t, repo, "commit", "-m", "feature two")
log, _ := logger.NewLogger(logger.LoggingConfig{Level: "error"})
cfg := &config.InstanceConfig{WorkDir: repo}
return &gitAPIFixture{
server: NewServer(cfg, process.NewManager(cfg, log), nil, nil, log),
repo: repo,
bare: bare,
}
}
func (f *gitAPIFixture) head(t *testing.T) string {
t.Helper()
return strings.TrimSpace(runGitAPI(t, f.repo, "rev-parse", "HEAD"))
}
func (f *gitAPIFixture) branch(t *testing.T) string {
t.Helper()
return strings.TrimSpace(runGitAPI(t, f.repo, "rev-parse", "--abbrev-ref", "HEAD"))
}
// postGitAPI issues a POST with a JSON body (or a raw string body verbatim,
// which is how the malformed-payload cases are expressed).
func postGitAPI(t *testing.T, srv *Server, path string, body any) *httptest.ResponseRecorder {
t.Helper()
var payload []byte
switch v := body.(type) {
case string:
payload = []byte(v)
default:
encoded, err := json.Marshal(v)
if err != nil {
t.Fatalf("marshal body: %v", err)
}
payload = encoded
}
req := httptest.NewRequest(http.MethodPost, path, bytes.NewReader(payload))
req.Header.Set("Content-Type", "application/json")
rec := httptest.NewRecorder()
srv.Router().ServeHTTP(rec, req)
return rec
}
func getGitAPI(t *testing.T, srv *Server, path string) *httptest.ResponseRecorder {
t.Helper()
rec := httptest.NewRecorder()
srv.Router().ServeHTTP(rec, httptest.NewRequest(http.MethodGet, path, nil))
return rec
}
func decodeGitOperationResult(t *testing.T, rec *httptest.ResponseRecorder) process.GitOperationResult {
t.Helper()
var result process.GitOperationResult
if err := json.Unmarshal(rec.Body.Bytes(), &result); err != nil {
t.Fatalf("decode git operation result from %q: %v", rec.Body.String(), err)
}
return result
}
// TestGitHandlers_RejectMalformedBody pins the shape of the 400 every git POST
// handler writes for an unparseable body: the operation label the caller sent
// the request for, and an "invalid request: " prefixed error. The operation
// label is what the frontend keys its error toast off, so a copy-paste slip
// between handlers is a user-visible bug that no status-code-only test catches.
func TestGitHandlers_RejectMalformedBody(t *testing.T) {
fixture := newGitAPIFixture(t)
cases := []struct {
path string
operation string
}{
{"/api/v1/git/pull", "pull"},
{"/api/v1/git/push", "push"},
{"/api/v1/git/push-preflight", "push_preflight"},
{"/api/v1/git/rebase", "rebase"},
{"/api/v1/git/merge", "merge"},
{"/api/v1/git/abort", "abort"},
{"/api/v1/git/commit", "commit"},
{"/api/v1/git/rename-branch", "rename_branch"},
{"/api/v1/git/stage", "stage"},
{"/api/v1/git/unstage", "unstage"},
{"/api/v1/git/discard", "discard"},
{"/api/v1/git/revert-commit", "revert_commit"},
{"/api/v1/git/reset", "reset"},
}
for _, tc := range cases {
t.Run(tc.operation, func(t *testing.T) {
rec := postGitAPI(t, fixture.server, tc.path, "{not json")
if rec.Code != http.StatusBadRequest {
t.Fatalf("status = %d, want %d (body %s)", rec.Code, http.StatusBadRequest, rec.Body.String())
}
result := decodeGitOperationResult(t, rec)
if result.Success {
t.Errorf("success = true, want false")
}
if result.Operation != tc.operation {
t.Errorf("operation = %q, want %q", result.Operation, tc.operation)
}
if !strings.HasPrefix(result.Error, "invalid request: ") {
t.Errorf("error = %q, want an %q prefix", result.Error, "invalid request: ")
}
})
}
}
// TestGitHandlers_RejectMissingRequiredFields pins each handler's own
// pre-flight validation message. These are the only guards standing between an
// empty form field and a git invocation with a missing argument.
func TestGitHandlers_RejectMissingRequiredFields(t *testing.T) {
fixture := newGitAPIFixture(t)
cases := []struct {
name string
path string
body any
operation string
wantError string
}{
{"rebase without base", "/api/v1/git/rebase", GitRebaseRequest{}, "rebase", "base_branch is required"},
{"merge without base", "/api/v1/git/merge", GitMergeRequest{}, "merge", "base_branch is required"},
{
"abort with unknown operation",
"/api/v1/git/abort",
GitAbortRequest{Operation: "cherry-pick"},
"abort",
"operation must be 'merge' or 'rebase'",
},
{"commit without message", "/api/v1/git/commit", GitCommitRequest{}, "commit", "message is required"},
{
"rename-branch without name",
"/api/v1/git/rename-branch",
GitRenameBranchRequest{},
"rename_branch",
"new_name is required",
},
{"discard without paths", "/api/v1/git/discard", GitDiscardRequest{}, "discard", "paths are required"},
{
"revert-commit without sha",
"/api/v1/git/revert-commit",
GitRevertCommitRequest{},
"revert_commit",
"commit_sha is required",
},
{"reset without sha", "/api/v1/git/reset", GitResetRequest{}, "reset", "commit_sha is required"},
{
"reset with unknown mode",
"/api/v1/git/reset",
GitResetRequest{CommitSHA: "HEAD", Mode: "squash"},
"reset",
"invalid reset mode: squash (must be soft, mixed, or hard)",
},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
rec := postGitAPI(t, fixture.server, tc.path, tc.body)
if rec.Code != http.StatusBadRequest {
t.Fatalf("status = %d, want %d (body %s)", rec.Code, http.StatusBadRequest, rec.Body.String())
}
result := decodeGitOperationResult(t, rec)
if result.Success {
t.Errorf("success = true, want false")
}
if result.Operation != tc.operation {
t.Errorf("operation = %q, want %q", result.Operation, tc.operation)
}
if result.Error != tc.wantError {
t.Errorf("error = %q, want %q", result.Error, tc.wantError)
}
})
}
}
// TestGitOpForRepo_RejectsUnresolvableSubpath covers the shared repo-scope
// barrier. A bad `repo` must be refused before any git command runs, and the
// refusal has to carry the operation the caller asked for so the failure is
// attributable in a multi-repo UI.
func TestGitOpForRepo_RejectsUnresolvableSubpath(t *testing.T) {
fixture := newGitAPIFixture(t)
cases := []struct {
name string
path string
body any
operation string
wantError string
}{
{"missing subpath", "/api/v1/git/pull", GitPullRequest{Repo: "nope"}, "pull", "repo subpath not found"},
{
"traversal",
"/api/v1/git/commit",
GitCommitRequest{Message: "m", Repo: "../escape"},
"commit",
"invalid repo subpath",
},
{
"absolute",
"/api/v1/git/stage",
GitStageRequest{Repo: filepath.Join(t.TempDir(), "abs")},
"stage",
"repo subpath must be relative",
},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
rec := postGitAPI(t, fixture.server, tc.path, tc.body)
if rec.Code != http.StatusBadRequest {
t.Fatalf("status = %d, want %d (body %s)", rec.Code, http.StatusBadRequest, rec.Body.String())
}
result := decodeGitOperationResult(t, rec)
if result.Operation != tc.operation {
t.Errorf("operation = %q, want %q", result.Operation, tc.operation)
}
if !strings.Contains(result.Error, tc.wantError) {
t.Errorf("error = %q, want it to contain %q", result.Error, tc.wantError)
}
})
}
}
// TestHandleGitCommit_CreatesCommitInWorktree asserts the endpoint's real
// effect rather than only its response: the working-tree change is staged and
// committed with exactly the requested message.
func TestHandleGitCommit_CreatesCommitInWorktree(t *testing.T) {
fixture := newGitAPIFixture(t)
writeFileAPI(t, fixture.repo, "three.txt", "three\n")
rec := postGitAPI(t, fixture.server, "/api/v1/git/commit", GitCommitRequest{
Message: "handler commit",
StageAll: true,
})
if rec.Code != http.StatusOK {
t.Fatalf("status = %d, want 200 (body %s)", rec.Code, rec.Body.String())
}
result := decodeGitOperationResult(t, rec)
if !result.Success {
t.Fatalf("commit failed: %+v", result)
}
if got := strings.TrimSpace(runGitAPI(t, fixture.repo, "log", "-1", "--format=%s")); got != "handler commit" {
t.Errorf("HEAD subject = %q, want %q", got, "handler commit")
}
if got := strings.TrimSpace(runGitAPI(t, fixture.repo, "status", "--porcelain")); got != "" {
t.Errorf("worktree not clean after stage_all commit: %q", got)
}
}
// TestHandleGitStageAndUnstage checks both directions of the index against
// `git status --porcelain`, which is the only place the difference between
// staged and unstaged is observable.
func TestHandleGitStageAndUnstage(t *testing.T) {
fixture := newGitAPIFixture(t)
writeFileAPI(t, fixture.repo, "staged.txt", "staged\n")
stage := postGitAPI(t, fixture.server, "/api/v1/git/stage", GitStageRequest{Paths: []string{"staged.txt"}})
if stage.Code != http.StatusOK {
t.Fatalf("stage status = %d (body %s)", stage.Code, stage.Body.String())
}
if result := decodeGitOperationResult(t, stage); !result.Success {
t.Fatalf("stage failed: %+v", result)
}
if got := strings.TrimSpace(runGitAPI(t, fixture.repo, "status", "--porcelain", "staged.txt")); got != "A staged.txt" {
t.Fatalf("porcelain after stage = %q, want %q", got, "A staged.txt")
}
unstage := postGitAPI(t, fixture.server, "/api/v1/git/unstage", GitUnstageRequest{Paths: []string{"staged.txt"}})
if unstage.Code != http.StatusOK {
t.Fatalf("unstage status = %d (body %s)", unstage.Code, unstage.Body.String())
}
if result := decodeGitOperationResult(t, unstage); !result.Success {
t.Fatalf("unstage failed: %+v", result)
}
if got := strings.TrimSpace(runGitAPI(t, fixture.repo, "status", "--porcelain", "staged.txt")); got != "?? staged.txt" {
t.Errorf("porcelain after unstage = %q, want %q", got, "?? staged.txt")
}
}
// TestHandleGitDiscard_RestoresTrackedFile asserts the destructive path
// actually restores the committed bytes.
func TestHandleGitDiscard_RestoresTrackedFile(t *testing.T) {
fixture := newGitAPIFixture(t)
writeFileAPI(t, fixture.repo, "one.txt", "locally edited\n")
rec := postGitAPI(t, fixture.server, "/api/v1/git/discard", GitDiscardRequest{Paths: []string{"one.txt"}})
if rec.Code != http.StatusOK {
t.Fatalf("status = %d (body %s)", rec.Code, rec.Body.String())
}
if result := decodeGitOperationResult(t, rec); !result.Success {
t.Fatalf("discard failed: %+v", result)
}
content, err := os.ReadFile(filepath.Join(fixture.repo, "one.txt"))
if err != nil {
t.Fatalf("read one.txt: %v", err)
}
if string(content) != "one\n" {
t.Errorf("one.txt = %q, want the committed %q", string(content), "one\n")
}
}
// TestHandleGitRenameBranch_MovesCurrentBranch verifies the rename lands on the
// checked-out branch rather than merely returning success.
func TestHandleGitRenameBranch_MovesCurrentBranch(t *testing.T) {
fixture := newGitAPIFixture(t)
rec := postGitAPI(t, fixture.server, "/api/v1/git/rename-branch", GitRenameBranchRequest{NewName: "feature/renamed"})
if rec.Code != http.StatusOK {
t.Fatalf("status = %d (body %s)", rec.Code, rec.Body.String())
}
if result := decodeGitOperationResult(t, rec); !result.Success {
t.Fatalf("rename failed: %+v", result)
}
if got := fixture.branch(t); got != "feature/renamed" {
t.Errorf("current branch = %q, want %q", got, "feature/renamed")
}
}
// TestHandleGitReset_HardMovesHead asserts the mode is forwarded: a hard reset
// has to move HEAD *and* drop the working-tree file, which a soft reset would
// not do.
func TestHandleGitReset_HardMovesHead(t *testing.T) {
fixture := newGitAPIFixture(t)
target := strings.TrimSpace(runGitAPI(t, fixture.repo, "rev-parse", "HEAD~1"))
rec := postGitAPI(t, fixture.server, "/api/v1/git/reset", GitResetRequest{CommitSHA: target, Mode: "hard"})
if rec.Code != http.StatusOK {
t.Fatalf("status = %d (body %s)", rec.Code, rec.Body.String())
}
if result := decodeGitOperationResult(t, rec); !result.Success {
t.Fatalf("reset failed: %+v", result)
}
if got := fixture.head(t); got != target {
t.Errorf("HEAD = %q, want %q", got, target)
}
if _, err := os.Stat(filepath.Join(fixture.repo, "two.txt")); !errors.Is(err, os.ErrNotExist) {
t.Errorf("two.txt still present after a hard reset (stat err = %v)", err)
}
}
// TestHandleGitRevertCommit_UncommitsHeadKeepingWork pins what revert_commit
// actually is: a soft un-commit of HEAD, which rewinds history one commit while
// leaving the files staged. Losing the staged work — or rewinding further than
// one commit — would be silent data loss for the user who clicked "undo commit".
func TestHandleGitRevertCommit_UncommitsHeadKeepingWork(t *testing.T) {
fixture := newGitAPIFixture(t)
target := fixture.head(t)
parent := strings.TrimSpace(runGitAPI(t, fixture.repo, "rev-parse", "HEAD~1"))
rec := postGitAPI(t, fixture.server, "/api/v1/git/revert-commit", GitRevertCommitRequest{CommitSHA: target})
if rec.Code != http.StatusOK {
t.Fatalf("status = %d (body %s)", rec.Code, rec.Body.String())
}
if result := decodeGitOperationResult(t, rec); !result.Success {
t.Fatalf("revert failed: %+v", result)
}
if got := fixture.head(t); got != parent {
t.Errorf("HEAD = %q, want the parent commit %q", got, parent)
}
if got := strings.TrimSpace(runGitAPI(t, fixture.repo, "status", "--porcelain", "two.txt")); got != "A two.txt" {
t.Errorf("porcelain for two.txt = %q, want it staged as %q", got, "A two.txt")
}
}
// TestHandleGitRevertCommit_RefusesOlderCommit covers the guard that keeps the
// soft un-commit from rewinding past HEAD, which would drop the commits in
// between without the caller asking for it.
func TestHandleGitRevertCommit_RefusesOlderCommit(t *testing.T) {
fixture := newGitAPIFixture(t)
head := fixture.head(t)
older := strings.TrimSpace(runGitAPI(t, fixture.repo, "rev-parse", "HEAD~1"))
rec := postGitAPI(t, fixture.server, "/api/v1/git/revert-commit", GitRevertCommitRequest{CommitSHA: older})
if rec.Code != http.StatusOK {
t.Fatalf("status = %d, want 200 (body %s)", rec.Code, rec.Body.String())
}
result := decodeGitOperationResult(t, rec)
if result.Success {
t.Errorf("success = true; only the latest commit may be reverted")
}
if result.Error != "can only revert the latest commit" {
t.Errorf("error = %q, want %q", result.Error, "can only revert the latest commit")
}
if got := fixture.head(t); got != head {
t.Errorf("HEAD moved to %q despite the refusal; want it left at %q", got, head)
}
}
// TestHandleGitShowCommit_ReturnsRequestedCommit pins the URI binding: the sha
// travels through the path parameter, and the response must be about that
// commit specifically.
func TestHandleGitShowCommit_ReturnsRequestedCommit(t *testing.T) {
fixture := newGitAPIFixture(t)
sha := fixture.head(t)
rec := getGitAPI(t, fixture.server, "/api/v1/git/commit/"+sha)
if rec.Code != http.StatusOK {
t.Fatalf("status = %d (body %s)", rec.Code, rec.Body.String())
}
var result process.CommitDiffResult
if err := json.Unmarshal(rec.Body.Bytes(), &result); err != nil {
t.Fatalf("decode commit diff: %v", err)
}
if !result.Success {
t.Fatalf("show commit failed: %+v", result)
}
if result.CommitSHA != sha {
t.Errorf("commit_sha = %q, want %q", result.CommitSHA, sha)
}
if _, ok := result.Files["two.txt"]; !ok {
t.Errorf("files = %v, want it to contain two.txt", mapKeys(result.Files))
}
}
// TestHandleGitShowCommit_UnknownCommitReportsInBody covers the failure branch.
// A missing object is a per-commit result failure, not a transport error, so it
// answers 200 with success=false — the frontend renders the message inline
// rather than treating the request as broken.
func TestHandleGitShowCommit_UnknownCommitReportsInBody(t *testing.T) {
fixture := newGitAPIFixture(t)
const missing = "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef"
rec := getGitAPI(t, fixture.server, "/api/v1/git/commit/"+missing)
if rec.Code != http.StatusOK {
t.Fatalf("status = %d, want 200 (body %s)", rec.Code, rec.Body.String())
}
var result process.CommitDiffResult
if err := json.Unmarshal(rec.Body.Bytes(), &result); err != nil {
t.Fatalf("decode commit diff: %v", err)
}
if result.Success {
t.Errorf("success = true, want false")
}
if result.CommitSHA != missing {
t.Errorf("commit_sha = %q, want the requested sha echoed back", result.CommitSHA)
}
if !strings.Contains(result.Error, "bad object") {
t.Errorf("error = %q, want it to name the bad object", result.Error)
}
}
// TestHandleGitShowCommit_RejectsUnresolvableRepo covers the `?repo=` branch of
// the same handler, which has its own CommitDiffResult error shape.
func TestHandleGitShowCommit_RejectsUnresolvableRepo(t *testing.T) {
fixture := newGitAPIFixture(t)
sha := fixture.head(t)
rec := getGitAPI(t, fixture.server, "/api/v1/git/commit/"+sha+"?repo=nope")
if rec.Code != http.StatusBadRequest {
t.Fatalf("status = %d, want 400 (body %s)", rec.Code, rec.Body.String())
}
var result process.CommitDiffResult
if err := json.Unmarshal(rec.Body.Bytes(), &result); err != nil {
t.Fatalf("decode commit diff: %v", err)
}
if !strings.Contains(result.Error, "repo subpath not found") {
t.Errorf("error = %q, want a repo-subpath failure", result.Error)
}
}
// TestHandleGitPushAndPull_RoundTripThroughOrigin drives both remote-facing
// handlers against a real bare repository so the assertions are about the
// remote's state, not just a success flag.
func TestHandleGitPushAndPull_RoundTripThroughOrigin(t *testing.T) {
fixture := newGitAPIFixture(t)
head := fixture.head(t)
push := postGitAPI(t, fixture.server, "/api/v1/git/push", GitPushRequest{SetUpstream: true})
if push.Code != http.StatusOK {
t.Fatalf("push status = %d (body %s)", push.Code, push.Body.String())
}
if result := decodeGitOperationResult(t, push); !result.Success {
t.Fatalf("push failed: %+v", result)
}
remoteHead := strings.TrimSpace(runGitAPI(t, fixture.bare, "rev-parse", "refs/heads/feature/work"))
if remoteHead != head {
t.Errorf("origin feature/work = %q, want the pushed HEAD %q", remoteHead, head)
}
pull := postGitAPI(t, fixture.server, "/api/v1/git/pull", GitPullRequest{})
if pull.Code != http.StatusOK {
t.Fatalf("pull status = %d (body %s)", pull.Code, pull.Body.String())
}
if result := decodeGitOperationResult(t, pull); !result.Success {
t.Fatalf("pull failed: %+v", result)
}
if got := fixture.head(t); got != head {
t.Errorf("HEAD moved during a no-op pull: %q != %q", got, head)
}
}
// TestHandleGitPushPreflight_ReportsRemoteState exercises the preflight
// endpoint, which the changes panel calls before offering a push.
func TestHandleGitPushPreflight_ReportsRemoteState(t *testing.T) {
fixture := newGitAPIFixture(t)
rec := postGitAPI(t, fixture.server, "/api/v1/git/push-preflight", GitPushPreflightRequest{})
if rec.Code != http.StatusOK {
t.Fatalf("status = %d (body %s)", rec.Code, rec.Body.String())
}
result := decodeGitOperationResult(t, rec)
if result.Operation != "push_preflight" {
t.Errorf("operation = %q, want %q", result.Operation, "push_preflight")
}
}
// advanceOriginMain adds a commit to main and publishes it, so the rebase and
// merge handlers — which both fetch and then operate on `origin/<base>` rather
// than the local ref — have something to integrate.
func (f *gitAPIFixture) advanceOriginMain(t *testing.T) string {
t.Helper()
runGitAPI(t, f.repo, "checkout", "main")
writeFileAPI(t, f.repo, "main-only.txt", "main\n")
runGitAPI(t, f.repo, "add", ".")
runGitAPI(t, f.repo, "commit", "-m", "main moves")
runGitAPI(t, f.repo, "push", "origin", "main")
mainHead := strings.TrimSpace(runGitAPI(t, f.repo, "rev-parse", "HEAD"))
runGitAPI(t, f.repo, "checkout", "feature/work")
return mainHead
}
// TestHandleGitRebase_ReplaysOntoBase asserts the branch is genuinely replayed:
// after rebasing onto a moved main, main's new commit is an ancestor of HEAD.
func TestHandleGitRebase_ReplaysOntoBase(t *testing.T) {
fixture := newGitAPIFixture(t)
mainHead := fixture.advanceOriginMain(t)
rec := postGitAPI(t, fixture.server, "/api/v1/git/rebase", GitRebaseRequest{BaseBranch: "main"})
if rec.Code != http.StatusOK {
t.Fatalf("status = %d (body %s)", rec.Code, rec.Body.String())
}
if result := decodeGitOperationResult(t, rec); !result.Success {
t.Fatalf("rebase failed: %+v", result)
}
if got := strings.TrimSpace(runGitAPI(t, fixture.repo, "merge-base", "HEAD", "main")); got != mainHead {
t.Errorf("merge-base with main = %q, want main's tip %q — the branch was not replayed", got, mainHead)
}
}
// TestHandleGitMerge_BringsBaseCommitIn covers the merge counterpart, which
// leaves main's commit reachable from HEAD without rewriting the branch.
func TestHandleGitMerge_BringsBaseCommitIn(t *testing.T) {
fixture := newGitAPIFixture(t)
featureHead := fixture.head(t)
mainHead := fixture.advanceOriginMain(t)
rec := postGitAPI(t, fixture.server, "/api/v1/git/merge", GitMergeRequest{BaseBranch: "main"})
if rec.Code != http.StatusOK {
t.Fatalf("status = %d (body %s)", rec.Code, rec.Body.String())
}
if result := decodeGitOperationResult(t, rec); !result.Success {
t.Fatalf("merge failed: %+v", result)
}
for _, want := range []string{featureHead, mainHead} {
runGitAPI(t, fixture.repo, "merge-base", "--is-ancestor", want, "HEAD")
}
}
// TestHandleGitAbort_WithNothingInProgress covers the abort handler's runtime
// path: the guard accepts "rebase", git refuses because nothing is in flight,
// and the failure is reported inside a 200 GitOperationResult rather than as a
// transport error.
func TestHandleGitAbort_WithNothingInProgress(t *testing.T) {
fixture := newGitAPIFixture(t)
rec := postGitAPI(t, fixture.server, "/api/v1/git/abort", GitAbortRequest{Operation: "rebase"})
if rec.Code != http.StatusOK {
t.Fatalf("status = %d, want 200 (body %s)", rec.Code, rec.Body.String())
}
result := decodeGitOperationResult(t, rec)
if result.Operation != "abort" {
t.Errorf("operation = %q, want %q", result.Operation, "abort")
}
if result.Success {
t.Errorf("success = true, but no rebase was in progress")
}
}
// TestHandleGitCreatePR_UnsupportedRemoteReportsProviderError pins the
// create-PR success path's error shape. The fixture's origin is a local path,
// which no PR provider claims; the refusal has to reach the caller inside a
// PRCreateResult (not as a transport failure) so the changes panel can explain
// which remotes are supported.
func TestHandleGitCreatePR_UnsupportedRemoteReportsProviderError(t *testing.T) {
fixture := newGitAPIFixture(t)
rec := postGitAPI(t, fixture.server, "/api/v1/git/create-pr", GitCreatePRRequest{
Title: "add feature",
Body: "body",
BaseBranch: "main",
})
if rec.Code != http.StatusOK {
t.Fatalf("status = %d, want 200 (body %s)", rec.Code, rec.Body.String())
}
var result process.PRCreateResult
if err := json.Unmarshal(rec.Body.Bytes(), &result); err != nil {
t.Fatalf("decode PR result: %v", err)
}
if result.Success {
t.Errorf("success = true, want false")
}
if !strings.Contains(result.Error, "unsupported git remote for PR creation") {
t.Errorf("error = %q, want it to name the unsupported remote", result.Error)
}
}
// TestHandleGitCreatePR_ValidationErrors covers the two 400 branches, both of
// which answer with a PRCreateResult (not the GitOperationResult shape the
// neighbouring handlers use).
func TestHandleGitCreatePR_ValidationErrors(t *testing.T) {
fixture := newGitAPIFixture(t)
cases := []struct {
name string
body any
wantError string
}{
{"malformed body", "{not json", "invalid request: "},
{"missing title", GitCreatePRRequest{Body: "b"}, "title is required"},
{"unresolvable repo", GitCreatePRRequest{Title: "t", Repo: "nope"}, "repo subpath not found"},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
rec := postGitAPI(t, fixture.server, "/api/v1/git/create-pr", tc.body)
if rec.Code != http.StatusBadRequest {
t.Fatalf("status = %d, want 400 (body %s)", rec.Code, rec.Body.String())
}
var result process.PRCreateResult
if err := json.Unmarshal(rec.Body.Bytes(), &result); err != nil {
t.Fatalf("decode PR result: %v", err)
}
if result.Success {
t.Errorf("success = true, want false")
}
if !strings.Contains(result.Error, tc.wantError) {
t.Errorf("error = %q, want it to contain %q", result.Error, tc.wantError)
}
})
}
}
// TestHandleGitLog_BoundsLimit pins both ends of the limit guard: an
// over-large limit is refused outright, and an unparseable one fails binding.
func TestHandleGitLog_BoundsLimit(t *testing.T) {
fixture := newGitAPIFixture(t)
cases := []struct {
name string
query string
wantError string
}{
{"above maximum", "?limit=501", "limit must be between 1 and 500"},
{"not a number", "?limit=many", "invalid request: "},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
rec := getGitAPI(t, fixture.server, "/api/v1/git/log"+tc.query)
if rec.Code != http.StatusBadRequest {
t.Fatalf("status = %d, want 400 (body %s)", rec.Code, rec.Body.String())
}
var result process.GitLogResult
if err := json.Unmarshal(rec.Body.Bytes(), &result); err != nil {
t.Fatalf("decode git log: %v", err)
}
if result.Success {
t.Errorf("success = true, want false")
}
if !strings.Contains(result.Error, tc.wantError) {
t.Errorf("error = %q, want it to contain %q", result.Error, tc.wantError)
}
})
}
}
// TestHandleGitLog_RejectsUnsafeTargetBranch is the sanitiser test. A valid
// target anchors the log at the merge-base with origin/main, so only the
// branch's own two commits come back. An injection-shaped ref must be dropped
// rather than interpolated into the git arguments — which is observable as the
// handler falling back to the open-ended "recent commits" walk that also
// includes main's initial commit.
func TestHandleGitLog_RejectsUnsafeTargetBranch(t *testing.T) {
fixture := newGitAPIFixture(t)
anchored := gitLogSubjects(t, fixture.server, "/api/v1/git/log?target_branch=main")
if len(anchored) != 2 || anchored[0] != "feature two" || anchored[1] != "feature one" {
t.Fatalf("anchored log = %v, want exactly the branch's own commits", anchored)
}
for _, unsafe := range []string{"main;whoami", "main..HEAD", "/etc/passwd", "main.lock", "-main"} {
t.Run(unsafe, func(t *testing.T) {
got := gitLogSubjects(t, fixture.server, "/api/v1/git/log?target_branch="+unsafe)
if len(got) != 3 {
t.Fatalf("log for %q = %v, want the unanchored 3-commit history "+
"(the ref must be dropped, not passed to git)", unsafe, got)
}
if got[2] != "initial" {
t.Errorf("oldest commit = %q, want %q", got[2], "initial")
}
})
}
}
// TestHandleGitLog_HonoursSince covers the explicit-base path, where the caller
// supplies the anchor instead of a branch to merge-base against.
func TestHandleGitLog_HonoursSince(t *testing.T) {
fixture := newGitAPIFixture(t)
base := strings.TrimSpace(runGitAPI(t, fixture.repo, "rev-parse", "HEAD~1"))
got := gitLogSubjects(t, fixture.server, "/api/v1/git/log?since="+base)
if len(got) != 1 || got[0] != "feature two" {
t.Errorf("log since HEAD~1 = %v, want just [feature two]", got)
}
}
func gitLogSubjects(t *testing.T, srv *Server, path string) []string {
t.Helper()
rec := getGitAPI(t, srv, path)
if rec.Code != http.StatusOK {
t.Fatalf("git log %s: status = %d (body %s)", path, rec.Code, rec.Body.String())
}
var result process.GitLogResult
if err := json.Unmarshal(rec.Body.Bytes(), &result); err != nil {
t.Fatalf("decode git log: %v", err)
}
if !result.Success {
t.Fatalf("git log %s failed: %+v", path, result)
}
subjects := make([]string, 0, len(result.Commits))
for _, commit := range result.Commits {
subjects = append(subjects, commit.CommitMessage)
}
return subjects
}
// TestHandleGitCumulativeDiff_RequiresBase covers the query binding, which is
// the only required parameter on the endpoint.
func TestHandleGitCumulativeDiff_RequiresBase(t *testing.T) {
fixture := newGitAPIFixture(t)
rec := getGitAPI(t, fixture.server, "/api/v1/git/cumulative-diff")
if rec.Code != http.StatusBadRequest {
t.Fatalf("status = %d, want 400 (body %s)", rec.Code, rec.Body.String())
}
var result process.CumulativeDiffResult
if err := json.Unmarshal(rec.Body.Bytes(), &result); err != nil {
t.Fatalf("decode cumulative diff: %v", err)
}
if !strings.HasPrefix(result.Error, "invalid request: ") {
t.Errorf("error = %q, want an %q prefix", result.Error, "invalid request: ")
}
}
// TestHandleGitCumulativeDiff_AnchorsOnTargetBranch checks the merge-base
// recomputation: the caller's stale base is replaced by the live divergence
// with origin/main, so the diff carries exactly the branch's own files.
func TestHandleGitCumulativeDiff_AnchorsOnTargetBranch(t *testing.T) {
fixture := newGitAPIFixture(t)
stale := fixture.head(t) // HEAD as base would produce an empty diff
rec := getGitAPI(t, fixture.server, "/api/v1/git/cumulative-diff?base="+stale+"&target_branch=main")
if rec.Code != http.StatusOK {
t.Fatalf("status = %d (body %s)", rec.Code, rec.Body.String())
}
var result process.CumulativeDiffResult
if err := json.Unmarshal(rec.Body.Bytes(), &result); err != nil {
t.Fatalf("decode cumulative diff: %v", err)
}
if !result.Success {
t.Fatalf("cumulative diff failed: %+v", result)
}
for _, want := range []string{"one.txt", "two.txt"} {
if _, ok := result.Files[want]; !ok {
t.Errorf("files = %v, want it to contain %q", mapKeys(result.Files), want)
}
}
if _, ok := result.Files["README.md"]; ok {
t.Errorf("files include README.md; the diff is not anchored at the merge-base")
}
}
// TestHandleGitCumulativeDiff_RejectsUnresolvableRepo covers the 400 branch
// that runGitCumulativeDiffForRepo returns before touching git.
func TestHandleGitCumulativeDiff_RejectsUnresolvableRepo(t *testing.T) {
fixture := newGitAPIFixture(t)
rec := getGitAPI(t, fixture.server, "/api/v1/git/cumulative-diff?base=HEAD&repo=nope")
if rec.Code != http.StatusBadRequest {
t.Fatalf("status = %d, want 400 (body %s)", rec.Code, rec.Body.String())
}
var result process.CumulativeDiffResult
if err := json.Unmarshal(rec.Body.Bytes(), &result); err != nil {
t.Fatalf("decode cumulative diff: %v", err)
}
if !strings.Contains(result.Error, "repo subpath not found") {
t.Errorf("error = %q, want a repo-subpath failure", result.Error)
}
}
// TestHandleGitStatus_ReportsWorktreeState asserts the single-repo status
// endpoint reflects the real worktree, including the branch name and the
// classification of each dirty path.
func TestHandleGitStatus_ReportsWorktreeState(t *testing.T) {
fixture := newGitAPIFixture(t)
writeFileAPI(t, fixture.repo, "untracked.txt", "new\n")
writeFileAPI(t, fixture.repo, "one.txt", "edited\n")
rec := getGitAPI(t, fixture.server, "/api/v1/git/status?fresh=true")
if rec.Code != http.StatusOK {
t.Fatalf("status = %d (body %s)", rec.Code, rec.Body.String())
}
var result GitStatusResult
if err := json.Unmarshal(rec.Body.Bytes(), &result); err != nil {
t.Fatalf("decode git status: %v", err)
}
if !result.Success {
t.Fatalf("git status failed: %+v", result)
}
if result.Branch != "feature/work" {
t.Errorf("branch = %q, want %q", result.Branch, "feature/work")
}
if !slices.Contains(result.Untracked, "untracked.txt") {
t.Errorf("untracked = %v, want it to contain untracked.txt", result.Untracked)
}
if !slices.Contains(result.Modified, "one.txt") {
t.Errorf("modified = %v, want it to contain one.txt", result.Modified)
}
if result.Timestamp == "" {
t.Errorf("timestamp is empty; the response must carry a snapshot time")
}
}
// TestHandleGitStatus_RejectsUnresolvableRepo covers the tracker-lookup 400.
func TestHandleGitStatus_RejectsUnresolvableRepo(t *testing.T) {
fixture := newGitAPIFixture(t)
rec := getGitAPI(t, fixture.server, "/api/v1/git/status?repo=nope")
if rec.Code != http.StatusBadRequest {
t.Fatalf("status = %d, want 400 (body %s)", rec.Code, rec.Body.String())
}
var result GitStatusResult
if err := json.Unmarshal(rec.Body.Bytes(), &result); err != nil {
t.Fatalf("decode git status: %v", err)
}
if result.Success {
t.Errorf("success = true, want false")
}
if !strings.Contains(result.Error, "repo subpath not found") {
t.Errorf("error = %q, want a repo-subpath failure", result.Error)
}
}
// TestHandleGitStatusMulti_SingleRepoUsesEmptyRepositoryName pins the uniform
// response shape callers rely on: a single-repo workspace still answers with
// the multi shape, tagged with an empty repository name.
func TestHandleGitStatusMulti_SingleRepoUsesEmptyRepositoryName(t *testing.T) {
fixture := newGitAPIFixture(t)
rec := getGitAPI(t, fixture.server, "/api/v1/git/status/multi")
if rec.Code != http.StatusOK {
t.Fatalf("status = %d (body %s)", rec.Code, rec.Body.String())
}
var result MultiRepoGitStatusResult
if err := json.Unmarshal(rec.Body.Bytes(), &result); err != nil {
t.Fatalf("decode multi status: %v", err)
}
if !result.Success || len(result.Repos) != 1 {
t.Fatalf("multi status = %+v, want exactly one repo entry", result)
}
if result.Repos[0].RepositoryName != "" {
t.Errorf("repository_name = %q, want empty for a single-repo workspace", result.Repos[0].RepositoryName)
}
if result.Repos[0].Status.Branch != "feature/work" {
t.Errorf("branch = %q, want %q", result.Repos[0].Status.Branch, "feature/work")
}
}
// TestHandleGitError_ClassifiesOperationInProgress pins the one branch of
// handleGitError that is not a generic 500: a busy GitOperator must answer 409
// with a stable, non-leaking message, because the frontend retries on that
// code and shows the raw error on every other one.
func TestHandleGitError_ClassifiesOperationInProgress(t *testing.T) {
fixture := newGitAPIFixture(t)
cases := []struct {
name string
err error
wantStatus int
wantError string
}{
{
"busy operator",
process.ErrOperationInProgress,
http.StatusConflict,
"another git operation is already in progress",
},
{"other failure", errors.New("fatal: not a git repository"), http.StatusInternalServerError, "fatal: not a git repository"},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
rec := httptest.NewRecorder()
c, _ := gin.CreateTestContext(rec)
fixture.server.handleGitError(c, "rebase", tc.err)
if rec.Code != tc.wantStatus {
t.Fatalf("status = %d, want %d (body %s)", rec.Code, tc.wantStatus, rec.Body.String())
}
result := decodeGitOperationResult(t, rec)
if result.Success {
t.Errorf("success = true, want false")
}
if result.Operation != "rebase" {
t.Errorf("operation = %q, want %q", result.Operation, "rebase")
}
if result.Error != tc.wantError {
t.Errorf("error = %q, want %q", result.Error, tc.wantError)
}
})
}
}
@@ -180,54 +180,6 @@ func statusesByRepo(t *testing.T, result MultiRepoGitStatusResult, wantRepos []s
return statuses
}
func mapKeys[V any](values map[string]V) []string {
keys := make([]string, 0, len(values))
for key := range values {
keys = append(keys, key)
}
return keys
}
func assertRepoNames(t *testing.T, got, want []string) {
t.Helper()
gotSet := make(map[string]bool, len(got))
for _, repo := range got {
gotSet[repo] = true
}
for _, repo := range want {
if !gotSet[repo] {
t.Errorf("repositories %v missing %q", got, repo)
}
}
}
func newMultiRepoStatusServer(t *testing.T) (*Server, []string) {
t.Helper()
taskRoot := t.TempDir()
repoNames := []string{"alpha", "beta"}
for _, repo := range repoNames {
newStatusTestRepo(t, taskRoot, repo)
}
log, _ := logger.NewLogger(logger.LoggingConfig{Level: "error"})
cfg := &config.InstanceConfig{WorkDir: taskRoot}
return NewServer(cfg, process.NewManager(cfg, log), nil, nil, log), repoNames
}
func newStatusTestRepo(t *testing.T, taskRoot, name string) string {
t.Helper()
repoDir := filepath.Join(taskRoot, name)
if err := os.Mkdir(repoDir, 0o755); err != nil {
t.Fatalf("mkdir %s: %v", name, err)
}
runGitAPI(t, repoDir, "init", "--initial-branch=main")
runGitAPI(t, repoDir, "config", "user.email", "test@test.com")
runGitAPI(t, repoDir, "config", "user.name", "Test User")
writeFileAPI(t, repoDir, "README.md", name+"\n")
runGitAPI(t, repoDir, "add", ".")
runGitAPI(t, repoDir, "commit", "-m", "initial")
return repoDir
}
type gitStatusCommandGate struct {
events *os.File
release *os.File
@@ -0,0 +1,65 @@
package api
import (
"os"
"path/filepath"
"testing"
"github.com/kandev/kandev/internal/agentctl/server/config"
"github.com/kandev/kandev/internal/agentctl/server/process"
"github.com/kandev/kandev/internal/common/logger"
)
// Shared multi-repo status fixtures. These live in their own file rather than
// alongside the concurrency test that first needed them because that file is
// //go:build !windows (it needs mkfifo to gate git), while nothing here is
// platform-specific — and a Windows `go vet` fails on any untagged test that
// reaches for a symbol defined only in the tagged one.
func newMultiRepoStatusServer(t *testing.T) (*Server, []string) {
t.Helper()
taskRoot := t.TempDir()
repoNames := []string{"alpha", "beta"}
for _, repo := range repoNames {
newStatusTestRepo(t, taskRoot, repo)
}
log, _ := logger.NewLogger(logger.LoggingConfig{Level: "error"})
cfg := &config.InstanceConfig{WorkDir: taskRoot}
return NewServer(cfg, process.NewManager(cfg, log), nil, nil, log), repoNames
}
func newStatusTestRepo(t *testing.T, taskRoot, name string) string {
t.Helper()
repoDir := filepath.Join(taskRoot, name)
if err := os.Mkdir(repoDir, 0o755); err != nil {
t.Fatalf("mkdir %s: %v", name, err)
}
runGitAPI(t, repoDir, "init", "--initial-branch=main")
runGitAPI(t, repoDir, "config", "user.email", "test@test.com")
runGitAPI(t, repoDir, "config", "user.name", "Test User")
writeFileAPI(t, repoDir, "README.md", name+"\n")
runGitAPI(t, repoDir, "add", ".")
runGitAPI(t, repoDir, "commit", "-m", "initial")
return repoDir
}
func assertRepoNames(t *testing.T, got, want []string) {
t.Helper()
gotSet := make(map[string]bool, len(got))
for _, repo := range got {
gotSet[repo] = true
}
for _, repo := range want {
if !gotSet[repo] {
t.Errorf("repositories %v missing %q", got, repo)
}
}
}
func mapKeys[V any](values map[string]V) []string {
keys := make([]string, 0, len(values))
for key := range values {
keys = append(keys, key)
}
return keys
}
@@ -0,0 +1,93 @@
package api
import (
"encoding/json"
"net/http"
"reflect"
"testing"
"github.com/kandev/kandev/internal/system/metrics"
)
// TestSplitMetrics covers the query-list parser. Blank entries have to be
// dropped rather than passed through, because an empty metric ID reaches the
// collector as an unknown metric.
func TestSplitMetrics(t *testing.T) {
cases := []struct {
name string
raw string
want []string
}{
{"empty", "", nil},
{"single", "cpu", []string{"cpu"}},
{"several with spaces", " cpu , memory ,disk ", []string{"cpu", "memory", "disk"}},
{"blank entries dropped", "cpu,,memory,", []string{"cpu", "memory"}},
{"only separators", ",,,", []string{}},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
got := splitMetrics(tc.raw)
if !reflect.DeepEqual(got, tc.want) {
t.Errorf("splitMetrics(%q) = %#v, want %#v", tc.raw, got, tc.want)
}
})
}
}
// TestHandleSystemMetrics_StampsExecutionIdentity asserts the snapshot is
// labelled as this executor before it leaves the handler. The dashboard merges
// host and executor snapshots into one list keyed by ID, so an unstamped
// snapshot would collide with the host's.
func TestHandleSystemMetrics_StampsExecutionIdentity(t *testing.T) {
srv := newTestServer(t)
rec := serverGet(t, srv, "/api/v1/system/metrics")
if rec.Code != http.StatusOK {
t.Fatalf("status = %d (body %s)", rec.Code, rec.Body.String())
}
var snapshot struct {
ID string `json:"id"`
Label string `json:"label"`
Kind string `json:"kind"`
Metrics []map[string]any `json:"metrics"`
}
if err := json.Unmarshal(rec.Body.Bytes(), &snapshot); err != nil {
t.Fatalf("decode snapshot %q: %v", rec.Body.String(), err)
}
if snapshot.ID != "agentctl" {
t.Errorf("id = %q, want %q", snapshot.ID, "agentctl")
}
if snapshot.Label != "Execution" {
t.Errorf("label = %q, want %q", snapshot.Label, "Execution")
}
if snapshot.Kind != "execution" {
t.Errorf("kind = %q, want %q", snapshot.Kind, "execution")
}
if len(snapshot.Metrics) != len(metrics.DefaultSettings().Metrics) {
t.Errorf("sampled %d metrics, want the %d defaults",
len(snapshot.Metrics), len(metrics.DefaultSettings().Metrics))
}
}
// TestHandleSystemMetrics_HonoursRequestedMetrics pins the selection: asking
// for one metric must sample exactly that one, not the default set.
func TestHandleSystemMetrics_HonoursRequestedMetrics(t *testing.T) {
srv := newTestServer(t)
wanted := metrics.DefaultSettings().Metrics[0]
rec := serverGet(t, srv, "/api/v1/system/metrics?metrics="+wanted)
if rec.Code != http.StatusOK {
t.Fatalf("status = %d (body %s)", rec.Code, rec.Body.String())
}
var snapshot struct {
Metrics []struct {
ID string `json:"id"`
} `json:"metrics"`
}
if err := json.Unmarshal(rec.Body.Bytes(), &snapshot); err != nil {
t.Fatalf("decode snapshot %q: %v", rec.Body.String(), err)
}
if len(snapshot.Metrics) != 1 || snapshot.Metrics[0].ID != wanted {
t.Errorf("metrics = %+v, want exactly [%s]", snapshot.Metrics, wanted)
}
}
@@ -0,0 +1,209 @@
//go:build !windows
package api
import (
"encoding/json"
"net"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"runtime"
"strconv"
"strings"
"testing"
)
// installPortDetectorShim puts a fake `ss`/`lsof` on PATH so the detectors can
// be driven with fixed output. The real commands report whatever the host
// happens to be listening on, which is neither stable nor assertable.
func installPortDetectorShim(t *testing.T, name, stdout string, exitCode int) {
t.Helper()
binDir := t.TempDir()
script := "#!/bin/sh\n"
if stdout != "" {
script += "cat <<'KANDEV_EOF'\n" + stdout + "\nKANDEV_EOF\n"
}
script += "exit " + strconv.Itoa(exitCode) + "\n"
if err := os.WriteFile(filepath.Join(binDir, name), []byte(script), 0o755); err != nil {
t.Fatalf("write %s shim: %v", name, err)
}
t.Setenv("PATH", binDir+string(os.PathListSeparator)+os.Getenv("PATH"))
}
func portsByNumber(t *testing.T, ports []ListeningPort) map[int]ListeningPort {
t.Helper()
byPort := make(map[int]ListeningPort, len(ports))
for _, port := range ports {
if _, dup := byPort[port.Port]; dup {
t.Errorf("port %d reported twice: %+v", port.Port, ports)
}
byPort[port.Port] = port
}
return byPort
}
const ssShimOutput = `LISTEN 0 511 0.0.0.0:3000 0.0.0.0:* users:(("next-server (v1",pid=16186,fd=24))
LISTEN 0 511 0.0.0.0:3000 0.0.0.0:* users:(("next-server (v1",pid=16187,fd=25))
LISTEN 0 128 127.0.0.1:22 0.0.0.0:* users:(("sshd",pid=900,fd=3))
LISTEN 0 4096 *:9000 *:* users:(("vite",pid=17000,fd=11))
LISTEN 0 4096 127.0.0.1:5432 0.0.0.0:*
LISTEN 0 4096
LISTEN 0 4096 garbage 0.0.0.0:* users:(("bogus",pid=1,fd=1))`
// TestDetectFromSS_ParsesListeners covers every branch of the `ss` parser at
// once: process-name extraction, first-wins de-duplication, the privileged-port
// filter, wildcard-host normalisation, a row with no process column, and two
// malformed rows that must be skipped rather than crash the sweep.
func TestDetectFromSS_ParsesListeners(t *testing.T) {
installPortDetectorShim(t, "ss", ssShimOutput, 0)
ports, err := detectFromSS()
if err != nil {
t.Fatalf("detectFromSS: %v", err)
}
byPort := portsByNumber(t, ports)
if len(byPort) != 3 {
t.Fatalf("detected %d ports, want 3 (3000, 9000, 5432): %+v", len(byPort), ports)
}
if got := byPort[3000]; got.Process != "next-server (v1" || got.Address != "0.0.0.0" {
t.Errorf("port 3000 = %+v, want the quoted process name and 0.0.0.0", got)
}
if got := byPort[9000]; got.Address != defaultListenAddr || got.Process != "vite" {
t.Errorf("port 9000 = %+v, want %q normalised to %q", got, "*", defaultListenAddr)
}
if got := byPort[5432]; got.Address != "127.0.0.1" || got.Process != "" {
t.Errorf("port 5432 = %+v, want a loopback listener with no process name", got)
}
if _, listed := byPort[22]; listed {
t.Errorf("port 22 was reported; ports below 1024 are filtered out")
}
}
// TestDetectFromSS_ReportsCommandFailure covers the error branch, which is what
// pushes detectListeningPorts onto its /proc/net/tcp fallback.
func TestDetectFromSS_ReportsCommandFailure(t *testing.T) {
installPortDetectorShim(t, "ss", "", 1)
ports, err := detectFromSS()
if err == nil {
t.Fatalf("detectFromSS succeeded with a failing command: %+v", ports)
}
if !strings.Contains(err.Error(), "ss failed") {
t.Errorf("error = %q, want it to name the failed command", err)
}
}
const lsofShimOutput = `cnext-server
n*:3000
n127.0.0.1:3000
csshd
n127.0.0.1:22
cvite
n[::1]:9000
nnot-an-address`
// TestDetectFromLsof_ParsesListeners covers the non-Linux fallback parser: the
// `c` record carries the process name for every `n` record that follows it, and
// the same filtering and de-duplication rules apply as for `ss` (port 3000 is
// bound on two addresses and must be reported once, keeping the first).
func TestDetectFromLsof_ParsesListeners(t *testing.T) {
installPortDetectorShim(t, "lsof", lsofShimOutput, 0)
ports, err := detectFromLsof()
if err != nil {
t.Fatalf("detectFromLsof: %v", err)
}
byPort := portsByNumber(t, ports)
if len(byPort) != 2 {
t.Fatalf("detected %d ports, want 2 (3000, 9000): %+v", len(byPort), ports)
}
if got := byPort[3000]; got.Process != "next-server" {
t.Errorf("port 3000 = %+v, want the preceding `c` record's process name", got)
}
if got := byPort[9000]; got.Process != "vite" {
t.Errorf("port 9000 = %+v, want the process name to follow the newest `c` record", got)
}
if _, listed := byPort[22]; listed {
t.Errorf("port 22 was reported; ports below 1024 are filtered out")
}
}
// TestDetectFromLsof_ReportsCommandFailure covers the last-resort error, which
// is the only way handleListPorts can answer 500.
func TestDetectFromLsof_ReportsCommandFailure(t *testing.T) {
installPortDetectorShim(t, "lsof", "", 3)
if _, err := detectFromLsof(); err == nil || !strings.Contains(err.Error(), "lsof failed") {
t.Errorf("error = %v, want an lsof failure", err)
}
}
// TestDetectFromProcNet_FindsRealListener covers the container fallback against
// the kernel's own table. A socket this test just opened has to show up, which
// is the one assertion that proves the hex parsing, the LISTEN-state filter and
// the file walk all agree with what /proc/net/tcp actually contains.
func TestDetectFromProcNet_FindsRealListener(t *testing.T) {
if runtime.GOOS != "linux" {
t.Skip("/proc/net/tcp is Linux-only")
}
listener, err := net.Listen("tcp", "127.0.0.1:0")
if err != nil {
t.Fatalf("listen: %v", err)
}
t.Cleanup(func() { _ = listener.Close() })
_, portStr, err := net.SplitHostPort(listener.Addr().String())
if err != nil {
t.Fatalf("split listener address: %v", err)
}
want, err := strconv.Atoi(portStr)
if err != nil {
t.Fatalf("parse listener port: %v", err)
}
ports, err := detectFromProcNet()
if err != nil {
t.Fatalf("detectFromProcNet: %v", err)
}
byPort := portsByNumber(t, ports)
if _, ok := byPort[want]; !ok {
t.Fatalf("port %d is missing from %+v", want, ports)
}
for _, port := range ports {
if port.Port < 1024 {
t.Errorf("port %d is below the 1024 floor: %+v", port.Port, port)
}
}
}
// TestHandleListPorts_ReturnsDetectedPorts drives the HTTP endpoint end to end
// with both detectors shimmed, so the assertion holds whichever one the host
// platform selects.
func TestHandleListPorts_ReturnsDetectedPorts(t *testing.T) {
installPortDetectorShim(t, "ss", ssShimOutput, 0)
installPortDetectorShim(t, "lsof", lsofShimOutput, 0)
srv := newTestServer(t)
rec := httptest.NewRecorder()
srv.Router().ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/api/v1/ports", nil))
if rec.Code != http.StatusOK {
t.Fatalf("status = %d, want 200 (body %s)", rec.Code, rec.Body.String())
}
var body struct {
Ports []ListeningPort `json:"ports"`
}
if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
t.Fatalf("decode ports: %v", err)
}
byPort := portsByNumber(t, body.Ports)
if _, ok := byPort[3000]; !ok {
t.Errorf("ports = %+v, want the shimmed listener on 3000", body.Ports)
}
if _, ok := byPort[22]; ok {
t.Errorf("ports = %+v, want privileged ports filtered out", body.Ports)
}
}
@@ -0,0 +1,96 @@
package api
import (
"testing"
)
// TestParseProcNetLine covers the /proc/net/tcp row parser, which is the
// fallback path used inside minimal containers that ship no `ss`.
func TestParseProcNetLine(t *testing.T) {
cases := []struct {
name string
line string
wantPort int
wantAddr string
wantOK bool
}{
{
name: "listening ipv4 socket",
line: " 0: 0100007F:1F90 00000000:0000 0A 00000000:00000000 00:00000000 00000000 1000 0 12345 1 0000 100 0 0 10 0",
wantPort: 8080,
wantAddr: "127.0.0.1",
wantOK: true,
},
{
name: "all interfaces",
line: " 1: 00000000:0BB8 00000000:0000 0A 00000000:00000000 00:00000000 00000000 1000 0 12346 1 0000 100 0 0 10 0",
wantPort: 3000,
wantAddr: "0.0.0.0",
wantOK: true,
},
{
name: "established socket is not a listener",
line: " 2: 0100007F:1F90 0100007F:9C40 01 00000000:00000000 00:00000000 00000000 1000 0 12347 1 0000 100 0 0 10 0",
wantPort: 0,
wantOK: false,
},
{
name: "truncated row",
line: " 3: 0100007F:1F90 00000000:0000",
wantOK: false,
},
{
name: "local address without a port",
line: " 4: 0100007F 00000000:0000 0A 00000000:00000000 00:00000000 00000000",
wantOK: false,
},
{
name: "non-hex port",
line: " 5: 0100007F:ZZZZ 00000000:0000 0A 00000000:00000000 00:00000000 00000000",
wantOK: false,
},
{
name: "blank line",
line: "",
wantOK: false,
},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
port, addr, ok := parseProcNetLine(tc.line)
if ok != tc.wantOK {
t.Fatalf("ok = %v, want %v (port %d, addr %q)", ok, tc.wantOK, port, addr)
}
if !tc.wantOK {
return
}
if port != tc.wantPort {
t.Errorf("port = %d, want %d", port, tc.wantPort)
}
if addr != tc.wantAddr {
t.Errorf("address = %q, want %q", addr, tc.wantAddr)
}
})
}
}
// TestParseHexIP pins the little-endian byte order /proc/net/tcp uses for IPv4.
// Reading it big-endian yields a plausible-looking but wrong address (1.0.0.127
// instead of 127.0.0.1), which no smoke test would catch.
func TestParseHexIP(t *testing.T) {
cases := map[string]string{
"0100007F": "127.0.0.1",
"00000000": "0.0.0.0",
"0201A8C0": "192.168.1.2",
"00000000000000000000000000000000": defaultListenAddr, // IPv6 collapses to all-interfaces
"0000000000000000FFFF00000100007F": defaultListenAddr, // IPv4-mapped IPv6
"ZZZZ": defaultListenAddr, // undecodable
"0100": defaultListenAddr, // too short for an address
"": defaultListenAddr,
}
for input, want := range cases {
if got := parseHexIP(input); got != want {
t.Errorf("parseHexIP(%q) = %q, want %q", input, got, want)
}
}
}
@@ -0,0 +1,391 @@
package api
import (
"bytes"
"encoding/json"
"net/http"
"net/http/httptest"
"strings"
"testing"
"time"
"github.com/kandev/kandev/internal/agentctl/server/process"
"github.com/kandev/kandev/internal/agentctl/types"
)
func processRequest(t *testing.T, srv *Server, method, path string, body any) *httptest.ResponseRecorder {
t.Helper()
var payload []byte
switch v := body.(type) {
case nil:
case string:
payload = []byte(v)
default:
encoded, err := json.Marshal(v)
if err != nil {
t.Fatalf("marshal body: %v", err)
}
payload = encoded
}
req := httptest.NewRequest(method, path, bytes.NewReader(payload))
req.Header.Set("Content-Type", "application/json")
rec := httptest.NewRecorder()
srv.Router().ServeHTTP(rec, req)
return rec
}
func decodeProcessError(t *testing.T, rec *httptest.ResponseRecorder) string {
t.Helper()
var body struct {
Error string `json:"error"`
}
if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
t.Fatalf("decode error body %q: %v", rec.Body.String(), err)
}
return body.Error
}
// awaitProcessOutput polls the get-process endpoint until the buffered output
// contains marker, and returns the snapshot that carried it. The process must
// still be running: a finished process is reaped out of the runner's map (see
// ProcessRunner.ensureProcessGroupReaped), so its output is only observable
// while it is alive.
func awaitProcessOutput(t *testing.T, srv *Server, id, marker string) process.ProcessInfo {
t.Helper()
deadline := time.Now().Add(15 * time.Second)
var last process.ProcessInfo
for time.Now().Before(deadline) {
rec := processRequest(t, srv, http.MethodGet, "/api/v1/processes/"+id+"?include_output=true", nil)
if rec.Code != http.StatusOK {
t.Fatalf("get process = %d, want 200 — the process was retired before its output could be read (body %s)",
rec.Code, rec.Body.String())
}
if err := json.Unmarshal(rec.Body.Bytes(), &last); err != nil {
t.Fatalf("decode process info: %v", err)
}
if strings.Contains(processOutputText(last), marker) {
return last
}
time.Sleep(10 * time.Millisecond)
}
t.Fatalf("process %s never emitted %q (last snapshot %+v)", id, marker, last)
return last
}
// awaitProcessRetired polls until the process is gone from the runner. Exiting
// and being reaped are one step as far as the HTTP surface is concerned: there
// is no window in which a finished process is still fetchable, so this is the
// only terminal state a caller can observe over REST.
func awaitProcessRetired(t *testing.T, srv *Server, id string) {
t.Helper()
deadline := time.Now().Add(15 * time.Second)
for time.Now().Before(deadline) {
if rec := processRequest(t, srv, http.MethodGet, "/api/v1/processes/"+id, nil); rec.Code == http.StatusNotFound {
return
}
time.Sleep(10 * time.Millisecond)
}
t.Fatalf("process %s was still fetchable after it should have exited and been reaped", id)
}
func processOutputText(info process.ProcessInfo) string {
var builder strings.Builder
for _, chunk := range info.Output {
builder.WriteString(chunk.Data)
}
return builder.String()
}
// TestHandleStartProcess_Rejections covers each 400: an unparseable body gets a
// fixed message (the handler deliberately does not echo the parse error), while
// the runner's own required-field errors are forwarded verbatim.
func TestHandleStartProcess_Rejections(t *testing.T) {
srv := newTestServer(t)
cases := []struct {
name string
body any
wantError string
}{
{"malformed body", "{not json", "invalid request body"},
{"missing session id", process.StartProcessRequest{Command: "true"}, "session_id is required"},
{"missing command", process.StartProcessRequest{SessionID: "s1"}, "command is required"},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
rec := processRequest(t, srv, http.MethodPost, "/api/v1/processes/start", tc.body)
if rec.Code != http.StatusBadRequest {
t.Fatalf("status = %d, want 400 (body %s)", rec.Code, rec.Body.String())
}
var body startProcessResponse
if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
t.Fatalf("decode response: %v", err)
}
if body.Process != nil {
t.Errorf("a process was returned alongside the refusal: %+v", body.Process)
}
if body.Error != tc.wantError {
t.Errorf("error = %q, want %q", body.Error, tc.wantError)
}
})
}
}
// TestProcessLifecycle_StartListGetCapturesOutput drives a real command through
// every read endpoint: the start response, the session-scoped list, and the
// per-process fetch with buffered output. Asserting the captured stdout is what
// proves the output plumbing is wired, not just the status field.
//
// The command prints and then blocks. A command that exits immediately cannot be
// read back at all — the runner reaps a finished process out of its map, so the
// fetch races the exit and answers 404 as soon as the machine is quick enough
// (which is exactly how this test first failed in CI but not locally).
func TestProcessLifecycle_StartListGetCapturesOutput(t *testing.T) {
srv := newTestServer(t)
start := processRequest(t, srv, http.MethodPost, "/api/v1/processes/start", process.StartProcessRequest{
SessionID: "session-a",
Kind: types.ProcessKindCustom,
ScriptName: "marker",
Command: "printf 'kandev-marker\\n'; sleep 120",
})
if start.Code != http.StatusOK {
t.Fatalf("start status = %d (body %s)", start.Code, start.Body.String())
}
var started startProcessResponse
if err := json.Unmarshal(start.Body.Bytes(), &started); err != nil {
t.Fatalf("decode start response: %v", err)
}
if started.Process == nil || started.Process.ID == "" {
t.Fatalf("start response carries no process: %s", start.Body.String())
}
if started.Process.SessionID != "session-a" || started.Process.ScriptName != "marker" {
t.Errorf("process = %+v, want the requested session and script name", started.Process)
}
stopProcessOnCleanup(t, srv, started.Process.ID)
listed := processRequest(t, srv, http.MethodGet, "/api/v1/processes?session_id=session-a", nil)
if listed.Code != http.StatusOK {
t.Fatalf("list status = %d (body %s)", listed.Code, listed.Body.String())
}
var infos []process.ProcessInfo
if err := json.Unmarshal(listed.Body.Bytes(), &infos); err != nil {
t.Fatalf("decode list: %v", err)
}
if len(infos) != 1 || infos[0].ID != started.Process.ID {
t.Errorf("list for session-a = %+v, want exactly the started process", infos)
}
other := processRequest(t, srv, http.MethodGet, "/api/v1/processes?session_id=session-b", nil)
var otherInfos []process.ProcessInfo
if err := json.Unmarshal(other.Body.Bytes(), &otherInfos); err != nil {
t.Fatalf("decode other list: %v", err)
}
if len(otherInfos) != 0 {
t.Errorf("list for session-b = %+v, want no processes; the filter is not applied", otherInfos)
}
live := awaitProcessOutput(t, srv, started.Process.ID, "kandev-marker")
if live.Status != types.ProcessStatusRunning {
t.Errorf("status = %q, want %q while the command is still blocked", live.Status, types.ProcessStatusRunning)
}
if live.ExitCode != nil {
t.Errorf("exit_code = %v, want nil for a running process", *live.ExitCode)
}
if live.Command != "printf 'kandev-marker\\n'; sleep 120" {
t.Errorf("command = %q, want the command as submitted", live.Command)
}
}
// TestHandleGetProcess_OmitsOutputByDefault pins the include_output query
// parameter. Buffered output can be megabytes, so the list-facing fetch must
// not carry it unless asked — and must carry it when it is.
func TestHandleGetProcess_OmitsOutputByDefault(t *testing.T) {
srv := newTestServer(t)
id := startTestProcess(t, srv, "session-c", "printf 'kandev-marker\\n'; sleep 120")
awaitProcessOutput(t, srv, id, "kandev-marker")
rec := processRequest(t, srv, http.MethodGet, "/api/v1/processes/"+id, nil)
if rec.Code != http.StatusOK {
t.Fatalf("status = %d (body %s)", rec.Code, rec.Body.String())
}
var info process.ProcessInfo
if err := json.Unmarshal(rec.Body.Bytes(), &info); err != nil {
t.Fatalf("decode process info: %v", err)
}
if len(info.Output) != 0 {
t.Errorf("output = %+v, want none without include_output=true", info.Output)
}
if info.ID != id {
t.Errorf("id = %q, want %q", info.ID, id)
}
}
// TestProcessLifecycle_ExitedProcessIsRetired pins the reaping contract that
// makes the two tests above use a blocking command: once a process exits, the
// runner removes it, so REST has no "exited" state to report — the process
// simply stops existing. Anything that needs the exit code must observe the
// `process_status` event instead.
func TestProcessLifecycle_ExitedProcessIsRetired(t *testing.T) {
srv := newTestServer(t)
id := startTestProcess(t, srv, "session-e", "printf 'done\\n'")
awaitProcessRetired(t, srv, id)
listed := processRequest(t, srv, http.MethodGet, "/api/v1/processes?session_id=session-e", nil)
var remaining []process.ProcessInfo
if err := json.Unmarshal(listed.Body.Bytes(), &remaining); err != nil {
t.Fatalf("decode list: %v", err)
}
if len(remaining) != 0 {
t.Errorf("list after exit = %+v, want it emptied", remaining)
}
}
// TestHandleGetProcess_UnknownIDIs404 covers the miss branch.
func TestHandleGetProcess_UnknownIDIs404(t *testing.T) {
srv := newTestServer(t)
rec := processRequest(t, srv, http.MethodGet, "/api/v1/processes/no-such-process", nil)
if rec.Code != http.StatusNotFound {
t.Fatalf("status = %d, want 404 (body %s)", rec.Code, rec.Body.String())
}
if got := decodeProcessError(t, rec); got != "process not found" {
t.Errorf("error = %q, want %q", got, "process not found")
}
}
// TestHandleStopProcess_Rejections covers the two 400 branches ahead of the
// runner call.
func TestHandleStopProcess_Rejections(t *testing.T) {
srv := newTestServer(t)
cases := []struct {
name string
body any
wantError string
}{
{"malformed body", "{not json", "invalid request body"},
{"missing process id", process.StopProcessRequest{}, "process_id is required"},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
rec := processRequest(t, srv, http.MethodPost, "/api/v1/processes/stop", tc.body)
if rec.Code != http.StatusBadRequest {
t.Fatalf("status = %d, want 400 (body %s)", rec.Code, rec.Body.String())
}
var body stopProcessResponse
if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
t.Fatalf("decode response: %v", err)
}
if body.Success {
t.Errorf("success = true, want false")
}
if body.Error != tc.wantError {
t.Errorf("error = %q, want %q", body.Error, tc.wantError)
}
})
}
}
// TestHandleStopProcess_UnknownIDIsIdempotentSuccess pins the deliberate
// asymmetry with the fetch endpoint: stopping something already gone is the
// caller's desired end state, so it answers success rather than 404. The UI
// stop button relies on that to stay usable after a process exits on its own.
func TestHandleStopProcess_UnknownIDIsIdempotentSuccess(t *testing.T) {
srv := newTestServer(t)
rec := processRequest(t, srv, http.MethodPost, "/api/v1/processes/stop", process.StopProcessRequest{
ProcessID: "no-such-process",
})
if rec.Code != http.StatusOK {
t.Fatalf("status = %d, want 200 (body %s)", rec.Code, rec.Body.String())
}
var body stopProcessResponse
if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
t.Fatalf("decode response: %v", err)
}
if !body.Success || body.Error != "" {
t.Errorf("response = %+v, want an unqualified success", body)
}
}
// TestHandleStopProcess_RetiresRunningProcess asserts the stop reaches a
// long-running command: the call returns success and the process is retired
// from both the per-session list and the per-id fetch. A `sleep 120` that was
// merely marked stopped would still be listed.
func TestHandleStopProcess_RetiresRunningProcess(t *testing.T) {
srv := newTestServer(t)
id := startTestProcess(t, srv, "session-d", "sleep 120")
listed := processRequest(t, srv, http.MethodGet, "/api/v1/processes?session_id=session-d", nil)
var before []process.ProcessInfo
if err := json.Unmarshal(listed.Body.Bytes(), &before); err != nil {
t.Fatalf("decode list: %v", err)
}
if len(before) != 1 {
t.Fatalf("list before stop = %+v, want the running process", before)
}
rec := processRequest(t, srv, http.MethodPost, "/api/v1/processes/stop", process.StopProcessRequest{ProcessID: id})
if rec.Code != http.StatusOK {
t.Fatalf("stop status = %d (body %s)", rec.Code, rec.Body.String())
}
var body stopProcessResponse
if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
t.Fatalf("decode stop response: %v", err)
}
if !body.Success || body.Error != "" {
t.Fatalf("stop reported failure: %+v", body)
}
after := processRequest(t, srv, http.MethodGet, "/api/v1/processes?session_id=session-d", nil)
var remaining []process.ProcessInfo
if err := json.Unmarshal(after.Body.Bytes(), &remaining); err != nil {
t.Fatalf("decode list: %v", err)
}
if len(remaining) != 0 {
t.Errorf("list after stop = %+v, want it emptied", remaining)
}
if got := processRequest(t, srv, http.MethodGet, "/api/v1/processes/"+id, nil); got.Code != http.StatusNotFound {
t.Errorf("get after stop status = %d, want 404 (body %s)", got.Code, got.Body.String())
}
}
func startTestProcess(t *testing.T, srv *Server, sessionID, command string) string {
t.Helper()
rec := processRequest(t, srv, http.MethodPost, "/api/v1/processes/start", process.StartProcessRequest{
SessionID: sessionID,
Kind: types.ProcessKindCustom,
Command: command,
})
if rec.Code != http.StatusOK {
t.Fatalf("start status = %d (body %s)", rec.Code, rec.Body.String())
}
var started startProcessResponse
if err := json.Unmarshal(rec.Body.Bytes(), &started); err != nil {
t.Fatalf("decode start response: %v", err)
}
if started.Process == nil {
t.Fatalf("start response carries no process: %s", rec.Body.String())
}
stopProcessOnCleanup(t, srv, started.Process.ID)
return started.Process.ID
}
// stopProcessOnCleanup reaps the subprocess when the test ends, including on an
// early t.Fatal. Several of these tests deliberately start a command that blocks
// for two minutes; without this the process — and the runner goroutines waiting
// on it — outlive the test and trip goleak. Stopping an already-retired process
// is a no-op success, so this is safe for every caller.
func stopProcessOnCleanup(t *testing.T, srv *Server, id string) {
t.Helper()
t.Cleanup(func() {
rec := processRequest(t, srv, http.MethodPost, "/api/v1/processes/stop", process.StopProcessRequest{
ProcessID: id,
})
if rec.Code != http.StatusOK {
t.Errorf("cleanup stop of %s = %d (body %s)", id, rec.Code, rec.Body.String())
}
})
}
@@ -0,0 +1,308 @@
package api
import (
"encoding/json"
"net/http"
"net/http/httptest"
"strings"
"testing"
"time"
"github.com/kandev/kandev/internal/agentctl/server/config"
"github.com/kandev/kandev/internal/agentctl/server/process"
)
func serverGet(t *testing.T, srv *Server, path string) *httptest.ResponseRecorder {
t.Helper()
rec := httptest.NewRecorder()
srv.Router().ServeHTTP(rec, httptest.NewRequest(http.MethodGet, path, nil))
return rec
}
func serverPost(t *testing.T, srv *Server, path string) *httptest.ResponseRecorder {
t.Helper()
rec := httptest.NewRecorder()
srv.Router().ServeHTTP(rec, httptest.NewRequest(http.MethodPost, path, strings.NewReader("{}")))
return rec
}
// TestHandleHealth_ReportsOKWithTimestamp pins the liveness probe. It is the
// one route exempted from bearer auth, so an executor's readiness check depends
// on both the fixed status string and a parseable RFC3339 timestamp.
func TestHandleHealth_ReportsOKWithTimestamp(t *testing.T) {
srv := newTestServer(t)
rec := serverGet(t, srv, "/health")
if rec.Code != http.StatusOK {
t.Fatalf("status = %d (body %s)", rec.Code, rec.Body.String())
}
var body HealthResponse
if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
t.Fatalf("decode health: %v", err)
}
if body.Status != "ok" {
t.Errorf("status = %q, want %q", body.Status, "ok")
}
if _, err := time.Parse(time.RFC3339, body.Timestamp); err != nil {
t.Errorf("timestamp %q is not RFC3339: %v", body.Timestamp, err)
}
}
// TestHandleInfo_EchoesInstanceConfig asserts the endpoint reports this
// instance's own configuration. The backend uses it to confirm it is talking to
// the agentctl it just launched, so a hardcoded or stale value is a real bug.
func TestHandleInfo_EchoesInstanceConfig(t *testing.T) {
log := newTestLogger()
workDir := t.TempDir()
cfg := &config.InstanceConfig{Port: 45321, WorkDir: workDir, AgentCommand: "claude-agent-acp --stdio"}
srv := NewServer(cfg, process.NewManager(cfg, log), nil, nil, log)
rec := serverGet(t, srv, "/api/v1/info")
if rec.Code != http.StatusOK {
t.Fatalf("status = %d (body %s)", rec.Code, rec.Body.String())
}
var body InfoResponse
if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
t.Fatalf("decode info: %v", err)
}
if body.WorkDir != workDir {
t.Errorf("work_dir = %q, want %q", body.WorkDir, workDir)
}
if body.Port != 45321 {
t.Errorf("port = %d, want %d", body.Port, 45321)
}
if body.AgentCommand != "claude-agent-acp --stdio" {
t.Errorf("agent_command = %q, want the configured command", body.AgentCommand)
}
if body.Version == "" {
t.Errorf("version is empty")
}
}
// TestHandleStatus_ReportsIdleAgent covers the status endpoint before anything
// has been started: the agent status has to be a real value from the manager
// and the process info map must be present rather than null.
func TestHandleStatus_ReportsIdleAgent(t *testing.T) {
srv := newTestServer(t)
rec := serverGet(t, srv, "/api/v1/status")
if rec.Code != http.StatusOK {
t.Fatalf("status = %d (body %s)", rec.Code, rec.Body.String())
}
var body StatusResponse
if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
t.Fatalf("decode status: %v", err)
}
if body.AgentStatus != string(srv.procMgr.Status()) {
t.Errorf("agent_status = %q, want the manager's %q", body.AgentStatus, srv.procMgr.Status())
}
if body.ProcessInfo == nil {
t.Errorf("process_info is null; the field must always be an object")
}
}
// TestHandleStart_WithoutConfiguredCommandIs500 covers the failure branch of
// the start endpoint. Nothing has called /agent/configure, so the manager has
// no command to launch and the reason must reach the caller.
func TestHandleStart_WithoutConfiguredCommandIs500(t *testing.T) {
srv := newTestServer(t)
rec := serverPost(t, srv, "/api/v1/start")
if rec.Code != http.StatusInternalServerError {
t.Fatalf("status = %d, want 500 (body %s)", rec.Code, rec.Body.String())
}
var body StartResponse
if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
t.Fatalf("decode start response: %v", err)
}
if body.Success {
t.Errorf("success = true, want false")
}
if body.Error == "" {
t.Errorf("error is empty; the launch failure must reach the caller")
}
}
// TestHandleStop_WhenNothingRunning asserts stopping an idle instance is a
// success, not an error — the backend calls it unconditionally during teardown.
func TestHandleStop_WhenNothingRunning(t *testing.T) {
srv := newTestServer(t)
rec := serverPost(t, srv, "/api/v1/stop")
if rec.Code != http.StatusOK {
t.Fatalf("status = %d, want 200 (body %s)", rec.Code, rec.Body.String())
}
var body StopResponse
if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
t.Fatalf("decode stop response: %v", err)
}
if !body.Success || body.Message != "agent stopped" {
t.Errorf("stop response = %+v, want an unqualified success", body)
}
}
// TestShellEndpoints_WithoutShell pins the two different no-shell answers.
// Status reports availability inside a 200 so the UI can render a disabled
// terminal pane, while the buffer read is a 503 because there is nothing to
// return at all.
func TestShellEndpoints_WithoutShell(t *testing.T) {
srv := newTestServer(t)
status := serverGet(t, srv, "/api/v1/shell/status")
if status.Code != http.StatusOK {
t.Fatalf("shell status = %d, want 200 (body %s)", status.Code, status.Body.String())
}
var statusBody ShellStatusResponse
if err := json.Unmarshal(status.Body.Bytes(), &statusBody); err != nil {
t.Fatalf("decode shell status: %v", err)
}
if statusBody.Available {
t.Errorf("available = true with no shell configured")
}
if statusBody.Error != "shell not available" {
t.Errorf("error = %q, want %q", statusBody.Error, "shell not available")
}
buffer := serverGet(t, srv, "/api/v1/shell/buffer")
if buffer.Code != http.StatusServiceUnavailable {
t.Fatalf("shell buffer = %d, want 503 (body %s)", buffer.Code, buffer.Body.String())
}
var bufferBody map[string]string
if err := json.Unmarshal(buffer.Body.Bytes(), &bufferBody); err != nil {
t.Fatalf("decode shell buffer: %v", err)
}
if bufferBody["error"] != "shell not available" {
t.Errorf("error = %q, want %q", bufferBody["error"], "shell not available")
}
}
// TestShellEndpoints_AfterExplicitStart covers the passthrough-mode path: the
// shell is started without the agent, and both read endpoints then describe a
// live PTY. Asserting the pid and shell path is what distinguishes a genuinely
// spawned process from a status struct that merely says Running.
func TestShellEndpoints_AfterExplicitStart(t *testing.T) {
log := newTestLogger()
workDir := t.TempDir()
cfg := &config.InstanceConfig{WorkDir: workDir, ShellEnabled: true}
procMgr := process.NewManager(cfg, log)
srv := NewServer(cfg, procMgr, nil, nil, log)
t.Cleanup(func() {
if shell := procMgr.Shell(); shell != nil {
if err := shell.Stop(); err != nil {
t.Errorf("stop shell: %v", err)
}
}
})
start := serverPost(t, srv, "/api/v1/shell/start")
if start.Code != http.StatusOK {
t.Fatalf("shell start = %d (body %s)", start.Code, start.Body.String())
}
var startBody map[string]string
if err := json.Unmarshal(start.Body.Bytes(), &startBody); err != nil {
t.Fatalf("decode shell start: %v", err)
}
if startBody["status"] != "shell started" {
t.Errorf("status = %q, want %q", startBody["status"], "shell started")
}
status := serverGet(t, srv, "/api/v1/shell/status")
if status.Code != http.StatusOK {
t.Fatalf("shell status = %d (body %s)", status.Code, status.Body.String())
}
var statusBody ShellStatusResponse
if err := json.Unmarshal(status.Body.Bytes(), &statusBody); err != nil {
t.Fatalf("decode shell status: %v", err)
}
if !statusBody.Available || !statusBody.Running {
t.Fatalf("shell status = %+v, want an available, running shell", statusBody)
}
if statusBody.Pid <= 0 {
t.Errorf("pid = %d, want a real process id", statusBody.Pid)
}
if statusBody.Shell == "" {
t.Errorf("shell is empty; the status must name the spawned program")
}
if statusBody.Cwd != workDir {
t.Errorf("cwd = %q, want the workspace root %q", statusBody.Cwd, workDir)
}
// Drive a marker through the PTY and read it back, so the buffer assertion
// is about captured output rather than merely a 200 with valid JSON. The
// shell echoes its input, so this does not depend on a command running.
const marker = "kandev-shell-marker"
if _, err := procMgr.Shell().Write([]byte("echo " + marker + "\r")); err != nil {
t.Fatalf("write to shell: %v", err)
}
buffered := awaitShellBuffer(t, srv, marker)
if !strings.Contains(buffered, marker) {
t.Errorf("shell buffer = %q, want it to contain %q", buffered, marker)
}
}
// awaitShellBuffer polls the buffer endpoint until it carries marker. The PTY
// delivers its prompt and the echoed keystrokes asynchronously, so the marker —
// not a fixed wait — is the synchronisation point; the deadline only detects
// failure.
func awaitShellBuffer(t *testing.T, srv *Server, marker string) string {
t.Helper()
deadline := time.Now().Add(10 * time.Second)
var last string
for time.Now().Before(deadline) {
rec := serverGet(t, srv, "/api/v1/shell/buffer")
if rec.Code != http.StatusOK {
t.Fatalf("shell buffer = %d, want 200 (body %s)", rec.Code, rec.Body.String())
}
var body ShellBufferResponse
if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
t.Fatalf("decode shell buffer: %v", err)
}
last = body.Data
if strings.Contains(last, marker) {
return last
}
time.Sleep(10 * time.Millisecond)
}
return last
}
// TestPprofRoutes_GatedOnEnv pins the debug surface behind its environment
// switch. pprof exposes goroutine stacks and heap contents, so registering it
// unconditionally would leak them from every shipped executor.
func TestPprofRoutes_GatedOnEnv(t *testing.T) {
t.Run("disabled by default", func(t *testing.T) {
t.Setenv("KANDEV_DEBUG_PPROF_ENABLED", "")
srv := newTestServer(t)
for _, path := range []string{"/debug/pprof/", "/debug/pprof/goroutine", "/api/v1/debug/memory"} {
if rec := serverGet(t, srv, path); rec.Code != http.StatusNotFound {
t.Errorf("%s status = %d, want 404 while pprof is disabled", path, rec.Code)
}
}
})
t.Run("enabled by env", func(t *testing.T) {
t.Setenv("KANDEV_DEBUG_PPROF_ENABLED", "true")
srv := newTestServer(t)
for _, path := range []string{"/debug/pprof/", "/debug/pprof/goroutine?debug=1", "/debug/pprof/cmdline"} {
if rec := serverGet(t, srv, path); rec.Code != http.StatusOK {
t.Errorf("%s status = %d, want 200 while pprof is enabled", path, rec.Code)
}
}
rec := serverGet(t, srv, "/api/v1/debug/memory")
if rec.Code != http.StatusOK {
t.Fatalf("memory status = %d (body %s)", rec.Code, rec.Body.String())
}
var memory map[string]any
if err := json.Unmarshal(rec.Body.Bytes(), &memory); err != nil {
t.Fatalf("decode memory stats: %v", err)
}
for _, key := range []string{"heap_alloc_mb", "heap_objects", "goroutines", "num_gc", "sys_mb"} {
if _, ok := memory[key]; !ok {
t.Errorf("memory stats are missing %q: %v", key, memory)
}
}
})
}
@@ -0,0 +1,207 @@
package api
import (
"bytes"
"encoding/json"
"net/http"
"net/http/httptest"
"strings"
"testing"
"time"
"github.com/gorilla/websocket"
)
func shellTerminalRequest(t *testing.T, srv *Server, method, path string, body any) *httptest.ResponseRecorder {
t.Helper()
var payload []byte
switch v := body.(type) {
case nil:
case string:
payload = []byte(v)
default:
encoded, err := json.Marshal(v)
if err != nil {
t.Fatalf("marshal body: %v", err)
}
payload = encoded
}
req := httptest.NewRequest(method, path, bytes.NewReader(payload))
req.Header.Set("Content-Type", "application/json")
rec := httptest.NewRecorder()
srv.Router().ServeHTTP(rec, req)
return rec
}
func decodeShellTerminalBody(t *testing.T, rec *httptest.ResponseRecorder) map[string]string {
t.Helper()
body := map[string]string{}
if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
t.Fatalf("decode %q: %v", rec.Body.String(), err)
}
return body
}
// TestHandleShellTerminalStart_Rejections covers both guards ahead of the PTY
// spawn. A blank terminal_id would otherwise register a session nothing can
// address again.
func TestHandleShellTerminalStart_Rejections(t *testing.T) {
srv := newTestServer(t)
cases := []struct {
name string
body any
wantError string
}{
{"malformed body", "{not json", "invalid request: "},
{"missing terminal id", shellTerminalStartRequest{Cols: 80, Rows: 24}, "terminal_id is required"},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
rec := shellTerminalRequest(t, srv, http.MethodPost, "/api/v1/shell/terminal/start", tc.body)
if rec.Code != http.StatusBadRequest {
t.Fatalf("status = %d, want 400 (body %s)", rec.Code, rec.Body.String())
}
if got := decodeShellTerminalBody(t, rec)["error"]; !strings.Contains(got, tc.wantError) {
t.Errorf("error = %q, want it to contain %q", got, tc.wantError)
}
})
}
}
// TestShellTerminalEndpoints_UnknownTerminal pins what each endpoint does for a
// terminal that was never started. The asymmetry is deliberate and load-bearing
// for the UI: reads 404 so a stale tab can detect its terminal is gone, while
// stop succeeds so closing that tab is not an error.
func TestShellTerminalEndpoints_UnknownTerminal(t *testing.T) {
srv := newTestServer(t)
buffer := shellTerminalRequest(t, srv, http.MethodGet, "/api/v1/shell/terminal/ghost/buffer", nil)
if buffer.Code != http.StatusNotFound {
t.Errorf("buffer status = %d, want 404 (body %s)", buffer.Code, buffer.Body.String())
}
if got := decodeShellTerminalBody(t, buffer)["error"]; !strings.Contains(got, "not found") {
t.Errorf("buffer error = %q, want a not-found report", got)
}
stream := shellTerminalRequest(t, srv, http.MethodGet, "/api/v1/shell/terminal/ghost/stream", nil)
if stream.Code != http.StatusNotFound {
t.Errorf("stream status = %d, want 404 (body %s)", stream.Code, stream.Body.String())
}
if got := decodeShellTerminalBody(t, stream)["error"]; got != "terminal not found" {
t.Errorf("stream error = %q, want %q", got, "terminal not found")
}
stop := shellTerminalRequest(t, srv, http.MethodDelete, "/api/v1/shell/terminal/ghost", nil)
if stop.Code != http.StatusOK {
t.Fatalf("stop status = %d, want 200 (body %s)", stop.Code, stop.Body.String())
}
if got := decodeShellTerminalBody(t, stop); got["status"] != "stopped" || got["terminal_id"] != "ghost" {
t.Errorf("stop body = %+v, want a stopped acknowledgement for `ghost`", got)
}
}
// TestShellTerminalLifecycle drives a real PTY session end to end: start,
// stream input over the binary WebSocket protocol, observe it echoed back,
// resize through the 0x01-prefixed control frame, read the replayed buffer over
// HTTP, then stop. The echo is the only observation that proves the socket
// bytes reach the PTY rather than being swallowed by the read loop.
func TestShellTerminalLifecycle(t *testing.T) {
srv := newTestServer(t)
const terminalID = "term-1"
start := shellTerminalRequest(t, srv, http.MethodPost, "/api/v1/shell/terminal/start", shellTerminalStartRequest{
TerminalID: terminalID,
Cols: 100,
Rows: 30,
})
// Registered the moment the PTY can exist — before the assertions below,
// any of which can t.Fatal and would otherwise leave the shell and its
// goroutines running into goleak's check.
t.Cleanup(func() {
if err := srv.procMgr.ShellManager().StopAll(); err != nil {
t.Errorf("stop all terminals: %v", err)
}
})
if start.Code != http.StatusOK {
t.Fatalf("start status = %d (body %s)", start.Code, start.Body.String())
}
if got := decodeShellTerminalBody(t, start); got["status"] != "started" || got["terminal_id"] != terminalID {
t.Fatalf("start body = %+v", got)
}
httpServer := httptest.NewServer(srv.Router())
defer httpServer.Close()
conn, _, err := websocket.DefaultDialer.Dial(
"ws"+strings.TrimPrefix(httpServer.URL, "http")+"/api/v1/shell/terminal/"+terminalID+"/stream", nil)
if err != nil {
t.Fatalf("dial terminal stream: %v", err)
}
defer func() { _ = conn.Close() }()
// A resize control frame must be consumed as a command, never written to
// the PTY — otherwise its JSON would land in the user's command line.
resize, err := json.Marshal(map[string]uint16{"cols": 132, "rows": 43})
if err != nil {
t.Fatalf("marshal resize: %v", err)
}
if err := conn.WriteMessage(websocket.BinaryMessage, append([]byte{shellResizeByte}, resize...)); err != nil {
t.Fatalf("write resize frame: %v", err)
}
const marker = "kandev-terminal-marker"
if err := conn.WriteMessage(websocket.BinaryMessage, []byte("echo "+marker+"\r")); err != nil {
t.Fatalf("write terminal input: %v", err)
}
streamed := readShellTerminalUntil(t, conn, marker)
if strings.Contains(streamed, `"cols"`) {
t.Errorf("resize control frame was forwarded to the PTY: %q", streamed)
}
buffer := shellTerminalRequest(t, srv, http.MethodGet, "/api/v1/shell/terminal/"+terminalID+"/buffer", nil)
if buffer.Code != http.StatusOK {
t.Fatalf("buffer status = %d (body %s)", buffer.Code, buffer.Body.String())
}
var replayed ShellBufferResponse
if err := json.Unmarshal(buffer.Body.Bytes(), &replayed); err != nil {
t.Fatalf("decode buffer: %v", err)
}
if !strings.Contains(replayed.Data, marker) {
t.Errorf("buffered output = %q, want it to contain the streamed marker", replayed.Data)
}
stop := shellTerminalRequest(t, srv, http.MethodDelete, "/api/v1/shell/terminal/"+terminalID, nil)
if stop.Code != http.StatusOK {
t.Fatalf("stop status = %d (body %s)", stop.Code, stop.Body.String())
}
after := shellTerminalRequest(t, srv, http.MethodGet, "/api/v1/shell/terminal/"+terminalID+"/buffer", nil)
if after.Code != http.StatusNotFound {
t.Errorf("buffer after stop = %d, want 404 (body %s)", after.Code, after.Body.String())
}
}
// readShellTerminalUntil accumulates binary frames until the marker appears.
// The PTY emits its prompt and the echoed keystrokes in an unpredictable number
// of frames, so the marker — not a frame count — is the synchronisation point.
func readShellTerminalUntil(t *testing.T, conn *websocket.Conn, marker string) string {
t.Helper()
var seen strings.Builder
deadline := time.Now().Add(wsTestTimeout)
for time.Now().Before(deadline) {
_ = conn.SetReadDeadline(deadline)
messageType, data, err := conn.ReadMessage()
if err != nil {
t.Fatalf("read terminal frame (seen %q): %v", seen.String(), err)
}
if messageType != websocket.BinaryMessage {
t.Fatalf("frame type = %d, want a binary frame", messageType)
}
seen.Write(data)
if strings.Contains(seen.String(), marker) {
return seen.String()
}
}
t.Fatalf("marker %q never arrived; saw %q", marker, seen.String())
return ""
}
@@ -0,0 +1,146 @@
package api
import (
"context"
"encoding/json"
"net/http"
"strings"
"testing"
)
// publishStagingAt creates and pushes `staging` at the given ref, giving the
// fixture a second live upstream branch to compare against. Without a second
// branch, selecting a base branch is indistinguishable from the default.
func (f *gitAPIFixture) publishStagingAt(t *testing.T, ref string) string {
t.Helper()
runGitAPI(t, f.repo, "branch", "staging", ref)
runGitAPI(t, f.repo, "push", "origin", "staging")
return strings.TrimSpace(runGitAPI(t, f.repo, "rev-parse", "staging"))
}
// joinDetachedBaseBranchRefresh blocks until the goroutine UpdateBaseBranches
// spawns has finished. That goroutine runs RefreshGitStatus with
// context.Background — it does not stop when the request ends — and it shells
// out to git inside the fixture's t.TempDir(), so a test that returned without
// joining it would race its own directory removal.
//
// RefreshGitStatus takes the tracker's updateMu for the whole call, so calling
// it here cannot return until the detached one has released it. That makes it a
// join, not a wait.
func joinDetachedBaseBranchRefresh(t *testing.T, srv *Server) {
t.Helper()
srv.procMgr.GetWorkspaceTracker().RefreshGitStatus(context.Background())
}
func gitStatusBaseCommit(t *testing.T, srv *Server) string {
t.Helper()
rec := getGitAPI(t, srv, "/api/v1/git/status?fresh=true")
if rec.Code != http.StatusOK {
t.Fatalf("git status = %d (body %s)", rec.Code, rec.Body.String())
}
var status GitStatusResult
if err := json.Unmarshal(rec.Body.Bytes(), &status); err != nil {
t.Fatalf("decode git status: %v", err)
}
if !status.Success {
t.Fatalf("git status failed: %+v", status)
}
return status.BaseCommit
}
// TestHandleSetBaseBranches_RetargetsComparison asserts the endpoint's actual
// effect: after selecting `staging`, the tracker's reported base commit moves
// to the merge-base with that branch. Returning ok:true without re-stamping the
// tracker would leave the changes panel comparing against the old branch until
// the session restarts, which is the bug this endpoint exists to prevent.
func TestHandleSetBaseBranches_RetargetsComparison(t *testing.T) {
fixture := newGitAPIFixture(t)
stagingTip := fixture.publishStagingAt(t, "HEAD~1")
defaultBase := gitStatusBaseCommit(t, fixture.server)
if defaultBase == stagingTip {
t.Fatalf("fixture is degenerate: the default base already equals staging's tip %q", stagingTip)
}
rec := postGitAPI(t, fixture.server, "/api/v1/workspace/base-branches", SetBaseBranchesRequest{
BaseBranches: map[string]string{"": "staging"},
})
if rec.Code != http.StatusOK {
t.Fatalf("status = %d (body %s)", rec.Code, rec.Body.String())
}
var body map[string]bool
if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
t.Fatalf("decode response: %v", err)
}
if !body["ok"] {
t.Errorf("response = %v, want ok:true", body)
}
joinDetachedBaseBranchRefresh(t, fixture.server)
if got := gitStatusBaseCommit(t, fixture.server); got != stagingTip {
t.Errorf("base_commit = %q, want the merge-base with staging %q", got, stagingTip)
}
}
// TestHandleSetBaseBranches_DropsUnsafeRefs is the sanitiser test. Each of
// these refs is interpolated straight into `git` arguments downstream, so the
// handler must drop them — observable as the tracker keeping the default
// comparison base instead of adopting the rejected ref.
func TestHandleSetBaseBranches_DropsUnsafeRefs(t *testing.T) {
for _, unsafe := range []string{"staging;whoami", "staging..HEAD", "--upload-pack=touch", "/etc/passwd", "staging.lock"} {
t.Run(unsafe, func(t *testing.T) {
fixture := newGitAPIFixture(t)
stagingTip := fixture.publishStagingAt(t, "HEAD~1")
defaultBase := gitStatusBaseCommit(t, fixture.server)
rec := postGitAPI(t, fixture.server, "/api/v1/workspace/base-branches", SetBaseBranchesRequest{
BaseBranches: map[string]string{"": unsafe},
})
if rec.Code != http.StatusOK {
t.Fatalf("status = %d, want 200 (body %s)", rec.Code, rec.Body.String())
}
joinDetachedBaseBranchRefresh(t, fixture.server)
got := gitStatusBaseCommit(t, fixture.server)
if got == stagingTip {
t.Fatalf("base_commit moved to staging's tip; %q was accepted as a ref", unsafe)
}
if got != defaultBase {
t.Errorf("base_commit = %q, want the untouched default %q", got, defaultBase)
}
})
}
}
// TestHandleSetBaseBranches_AcceptsOriginPrefixedRefs pins the one shape the
// allowlist has to special-case: `origin/<branch>` is split before validation,
// because the underlying validator rejects a leading path separator.
func TestHandleSetBaseBranches_AcceptsOriginPrefixedRefs(t *testing.T) {
fixture := newGitAPIFixture(t)
stagingTip := fixture.publishStagingAt(t, "HEAD~1")
rec := postGitAPI(t, fixture.server, "/api/v1/workspace/base-branches", SetBaseBranchesRequest{
BaseBranches: map[string]string{"": "origin/staging"},
})
if rec.Code != http.StatusOK {
t.Fatalf("status = %d (body %s)", rec.Code, rec.Body.String())
}
joinDetachedBaseBranchRefresh(t, fixture.server)
if got := gitStatusBaseCommit(t, fixture.server); got != stagingTip {
t.Errorf("base_commit = %q, want the merge-base with origin/staging %q", got, stagingTip)
}
}
// TestHandleSetBaseBranches_RejectsMalformedBody covers the binding guard.
func TestHandleSetBaseBranches_RejectsMalformedBody(t *testing.T) {
fixture := newGitAPIFixture(t)
rec := postGitAPI(t, fixture.server, "/api/v1/workspace/base-branches", "{not json")
if rec.Code != http.StatusBadRequest {
t.Fatalf("status = %d, want 400 (body %s)", rec.Code, rec.Body.String())
}
var body map[string]string
if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
t.Fatalf("decode response: %v", err)
}
if body[errKey] != "invalid JSON body" {
t.Errorf("error = %q, want %q", body[errKey], "invalid JSON body")
}
}
@@ -0,0 +1,552 @@
package api
import (
"bytes"
"encoding/json"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"strings"
"testing"
"github.com/kandev/kandev/internal/agentctl/server/config"
"github.com/kandev/kandev/internal/agentctl/server/process"
"github.com/kandev/kandev/internal/agentctl/types/streams"
"github.com/kandev/kandev/internal/common/logger"
)
// newWorkspaceFileServer builds a server over a plain (non-git) workspace
// seeded with one file and one nested directory. File handlers never touch
// git, so keeping the fixture git-free makes the assertions about the
// filesystem alone.
func newWorkspaceFileServer(t *testing.T) (*Server, string) {
t.Helper()
workDir := t.TempDir()
if err := os.WriteFile(filepath.Join(workDir, "one.txt"), []byte("one\n"), 0o644); err != nil {
t.Fatalf("seed one.txt: %v", err)
}
if err := os.Mkdir(filepath.Join(workDir, "nested"), 0o755); err != nil {
t.Fatalf("mkdir nested: %v", err)
}
if err := os.WriteFile(filepath.Join(workDir, "nested", "two.txt"), []byte("two\n"), 0o644); err != nil {
t.Fatalf("seed nested/two.txt: %v", err)
}
log, _ := logger.NewLogger(logger.LoggingConfig{Level: "error"})
cfg := &config.InstanceConfig{WorkDir: workDir}
return NewServer(cfg, process.NewManager(cfg, log), nil, nil, log), workDir
}
func workspaceRequest(t *testing.T, srv *Server, method, path string, body any) *httptest.ResponseRecorder {
t.Helper()
var reader *bytes.Reader
switch v := body.(type) {
case nil:
reader = bytes.NewReader(nil)
case string:
reader = bytes.NewReader([]byte(v))
default:
encoded, err := json.Marshal(v)
if err != nil {
t.Fatalf("marshal body: %v", err)
}
reader = bytes.NewReader(encoded)
}
req := httptest.NewRequest(method, path, reader)
req.Header.Set("Content-Type", "application/json")
rec := httptest.NewRecorder()
srv.Router().ServeHTTP(rec, req)
return rec
}
func decodeWorkspaceBody[T any](t *testing.T, rec *httptest.ResponseRecorder) T {
t.Helper()
var body T
if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
t.Fatalf("decode %q: %v", rec.Body.String(), err)
}
return body
}
// TestHandleFileTree_ReturnsRequestedDepth pins the depth query parameter:
// depth=1 must stop at the directory entry, depth=2 must descend into it. A
// handler that ignored the parameter would still return a plausible tree.
func TestHandleFileTree_ReturnsRequestedDepth(t *testing.T) {
srv, _ := newWorkspaceFileServer(t)
shallow := workspaceRequest(t, srv, http.MethodGet, "/api/v1/workspace/tree?depth=1", nil)
if shallow.Code != http.StatusOK {
t.Fatalf("depth=1 status = %d (body %s)", shallow.Code, shallow.Body.String())
}
root := decodeWorkspaceBody[streams.FileTreeResponse](t, shallow).Root
if root == nil {
t.Fatalf("depth=1 returned no root: %s", shallow.Body.String())
}
nested := findTreeChild(root, "nested")
if nested == nil {
t.Fatalf("depth=1 tree has no `nested` entry: %+v", childNames(root))
}
if len(nested.Children) != 0 {
t.Errorf("depth=1 descended into `nested`: %+v", childNames(nested))
}
deep := workspaceRequest(t, srv, http.MethodGet, "/api/v1/workspace/tree?depth=2", nil)
if deep.Code != http.StatusOK {
t.Fatalf("depth=2 status = %d (body %s)", deep.Code, deep.Body.String())
}
deepNested := findTreeChild(decodeWorkspaceBody[streams.FileTreeResponse](t, deep).Root, "nested")
if deepNested == nil || findTreeChild(deepNested, "two.txt") == nil {
t.Errorf("depth=2 did not descend into `nested`: %+v", deepNested)
}
}
// TestHandleFileTree_RejectsEscapingPath covers the 400 branch: the tracker
// refuses a path outside the workspace and the handler forwards the reason.
func TestHandleFileTree_RejectsEscapingPath(t *testing.T) {
srv, _ := newWorkspaceFileServer(t)
rec := workspaceRequest(t, srv, http.MethodGet, "/api/v1/workspace/tree?path=../..", nil)
if rec.Code != http.StatusBadRequest {
t.Fatalf("status = %d, want 400 (body %s)", rec.Code, rec.Body.String())
}
if got := decodeWorkspaceBody[streams.FileTreeResponse](t, rec); got.Error == "" {
t.Errorf("error is empty; the refusal reason must reach the caller")
}
}
func findTreeChild(node *streams.FileTreeNode, name string) *streams.FileTreeNode {
if node == nil {
return nil
}
for _, child := range node.Children {
if child.Name == name {
return child
}
}
return nil
}
func childNames(node *streams.FileTreeNode) []string {
names := make([]string, 0, len(node.Children))
for _, child := range node.Children {
names = append(names, child.Name)
}
return names
}
// TestHandleFileContent_ReturnsFileBytes asserts the content endpoint answers
// with the file's real bytes and size, and echoes the caller's repo-relative
// path rather than the resolved absolute one.
func TestHandleFileContent_ReturnsFileBytes(t *testing.T) {
srv, _ := newWorkspaceFileServer(t)
rec := workspaceRequest(t, srv, http.MethodGet, "/api/v1/workspace/file/content?path=nested/two.txt", nil)
if rec.Code != http.StatusOK {
t.Fatalf("status = %d (body %s)", rec.Code, rec.Body.String())
}
got := decodeWorkspaceBody[streams.FileContentResponse](t, rec)
if got.Content != "two\n" {
t.Errorf("content = %q, want %q", got.Content, "two\n")
}
if got.Path != "nested/two.txt" {
t.Errorf("path = %q, want the requested repo-relative path", got.Path)
}
if got.Size != int64(len("two\n")) {
t.Errorf("size = %d, want %d", got.Size, len("two\n"))
}
if got.IsBinary {
t.Errorf("is_binary = true for a text file")
}
}
// TestHandleFileContent_Rejections covers every 400 branch of the read path.
func TestHandleFileContent_Rejections(t *testing.T) {
srv, _ := newWorkspaceFileServer(t)
cases := []struct {
name string
query string
wantError string
}{
{"missing path", "", "path is required"},
{"unresolvable repo", "?path=one.txt&repo=nope", "repo subpath not found"},
{"missing file", "?path=absent.txt", "no such file"},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
rec := workspaceRequest(t, srv, http.MethodGet, "/api/v1/workspace/file/content"+tc.query, nil)
if rec.Code != http.StatusBadRequest {
t.Fatalf("status = %d, want 400 (body %s)", rec.Code, rec.Body.String())
}
got := decodeWorkspaceBody[streams.FileContentResponse](t, rec)
if !strings.Contains(got.Error, tc.wantError) {
t.Errorf("error = %q, want it to contain %q", got.Error, tc.wantError)
}
})
}
}
// TestHandleFileUpdate_AppliesDiff asserts the patch actually lands on disk and
// that the returned hash is the hash of the new content, which is what the
// editor sends back as OriginalHash on the next save.
func TestHandleFileUpdate_AppliesDiff(t *testing.T) {
srv, workDir := newWorkspaceFileServer(t)
rec := workspaceRequest(t, srv, http.MethodPost, "/api/v1/workspace/file/content", streams.FileUpdateRequest{
Path: "one.txt",
Diff: "--- one.txt\n+++ one.txt\n@@ -1 +1 @@\n-one\n+patched\n",
})
if rec.Code != http.StatusOK {
t.Fatalf("status = %d (body %s)", rec.Code, rec.Body.String())
}
got := decodeWorkspaceBody[streams.FileUpdateResponse](t, rec)
if !got.Success {
t.Fatalf("update failed: %+v", got)
}
if got.NewHash == "" {
t.Errorf("new_hash is empty; the editor needs it for the next conflict check")
}
content, err := os.ReadFile(filepath.Join(workDir, "one.txt"))
if err != nil {
t.Fatalf("read one.txt: %v", err)
}
if string(content) != "patched\n" {
t.Errorf("one.txt = %q, want %q", string(content), "patched\n")
}
}
// TestHandleFileUpdate_ReportsHashConflict covers the optimistic-concurrency
// branch: a stale OriginalHash with no desired-content fallback must be
// refused rather than silently overwriting a concurrent edit.
func TestHandleFileUpdate_ReportsHashConflict(t *testing.T) {
srv, workDir := newWorkspaceFileServer(t)
rec := workspaceRequest(t, srv, http.MethodPost, "/api/v1/workspace/file/content", streams.FileUpdateRequest{
Path: "one.txt",
Diff: "--- one.txt\n+++ one.txt\n@@ -1 +1 @@\n-one\n+patched\n",
OriginalHash: "0000000000000000000000000000000000000000000000000000000000000000",
})
if rec.Code != http.StatusBadRequest {
t.Fatalf("status = %d, want 400 (body %s)", rec.Code, rec.Body.String())
}
got := decodeWorkspaceBody[streams.FileUpdateResponse](t, rec)
if got.Success {
t.Errorf("success = true, want false")
}
if !strings.Contains(got.Error, "conflict detected") {
t.Errorf("error = %q, want a conflict report", got.Error)
}
content, err := os.ReadFile(filepath.Join(workDir, "one.txt"))
if err != nil {
t.Fatalf("read one.txt: %v", err)
}
if string(content) != "one\n" {
t.Errorf("one.txt = %q; the refused update must not have been written", string(content))
}
}
// TestHandleFileUpdate_Rejections covers the pre-flight guards, which run
// before anything reads the file.
func TestHandleFileUpdate_Rejections(t *testing.T) {
srv, _ := newWorkspaceFileServer(t)
cases := []struct {
name string
body any
wantError string
}{
{"malformed body", "{not json", "invalid request: "},
{"missing path", streams.FileUpdateRequest{Diff: "d"}, "path is required"},
{"missing diff", streams.FileUpdateRequest{Path: "one.txt"}, "diff is required"},
{
"unresolvable repo",
streams.FileUpdateRequest{Path: "one.txt", Diff: "d", Repo: "nope"},
"repo subpath not found",
},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
rec := workspaceRequest(t, srv, http.MethodPost, "/api/v1/workspace/file/content", tc.body)
if rec.Code != http.StatusBadRequest {
t.Fatalf("status = %d, want 400 (body %s)", rec.Code, rec.Body.String())
}
got := decodeWorkspaceBody[streams.FileUpdateResponse](t, rec)
if !strings.Contains(got.Error, tc.wantError) {
t.Errorf("error = %q, want it to contain %q", got.Error, tc.wantError)
}
})
}
}
// TestHandleFileCreate_CreatesEmptyFile asserts the created file exists and is
// empty, and that creating over an existing path is refused.
func TestHandleFileCreate_CreatesEmptyFile(t *testing.T) {
srv, workDir := newWorkspaceFileServer(t)
rec := workspaceRequest(t, srv, http.MethodPost, "/api/v1/workspace/file/create", streams.FileCreateRequest{
Path: "nested/created.txt",
})
if rec.Code != http.StatusOK {
t.Fatalf("status = %d (body %s)", rec.Code, rec.Body.String())
}
if got := decodeWorkspaceBody[streams.FileCreateResponse](t, rec); !got.Success || got.Path != "nested/created.txt" {
t.Fatalf("create response = %+v", got)
}
info, err := os.Stat(filepath.Join(workDir, "nested", "created.txt"))
if err != nil {
t.Fatalf("stat created file: %v", err)
}
if info.Size() != 0 {
t.Errorf("created file size = %d, want 0", info.Size())
}
again := workspaceRequest(t, srv, http.MethodPost, "/api/v1/workspace/file/create", streams.FileCreateRequest{
Path: "one.txt",
})
if again.Code != http.StatusBadRequest {
t.Fatalf("re-create status = %d, want 400 (body %s)", again.Code, again.Body.String())
}
if got := decodeWorkspaceBody[streams.FileCreateResponse](t, again); got.Success || got.Error == "" {
t.Errorf("re-create response = %+v, want a refusal with a reason", got)
}
}
// TestHandleFileCreate_Rejections covers the guards ahead of the filesystem.
func TestHandleFileCreate_Rejections(t *testing.T) {
srv, _ := newWorkspaceFileServer(t)
cases := []struct {
name string
body any
wantError string
}{
{"malformed body", "{not json", "invalid request: "},
{"missing path", streams.FileCreateRequest{}, "path is required"},
{"unresolvable repo", streams.FileCreateRequest{Path: "x.txt", Repo: "nope"}, "repo subpath not found"},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
rec := workspaceRequest(t, srv, http.MethodPost, "/api/v1/workspace/file/create", tc.body)
if rec.Code != http.StatusBadRequest {
t.Fatalf("status = %d, want 400 (body %s)", rec.Code, rec.Body.String())
}
got := decodeWorkspaceBody[streams.FileCreateResponse](t, rec)
if !strings.Contains(got.Error, tc.wantError) {
t.Errorf("error = %q, want it to contain %q", got.Error, tc.wantError)
}
})
}
}
// TestHandleFileDelete_RemovesFile asserts the file is gone from disk, and
// that a second delete of the same path is refused rather than reported as a
// success the UI would render as a removed row.
func TestHandleFileDelete_RemovesFile(t *testing.T) {
srv, workDir := newWorkspaceFileServer(t)
rec := workspaceRequest(t, srv, http.MethodDelete, "/api/v1/workspace/file?path=nested/two.txt", nil)
if rec.Code != http.StatusOK {
t.Fatalf("status = %d (body %s)", rec.Code, rec.Body.String())
}
if got := decodeWorkspaceBody[streams.FileDeleteResponse](t, rec); !got.Success || got.Path != "nested/two.txt" {
t.Fatalf("delete response = %+v", got)
}
if _, err := os.Stat(filepath.Join(workDir, "nested", "two.txt")); !os.IsNotExist(err) {
t.Errorf("nested/two.txt still exists (stat err = %v)", err)
}
again := workspaceRequest(t, srv, http.MethodDelete, "/api/v1/workspace/file?path=nested/two.txt", nil)
if again.Code != http.StatusBadRequest {
t.Errorf("second delete status = %d, want 400 (body %s)", again.Code, again.Body.String())
}
}
// TestHandleFileDelete_Rejections covers the query-parameter guards.
func TestHandleFileDelete_Rejections(t *testing.T) {
srv, _ := newWorkspaceFileServer(t)
cases := []struct {
name string
query string
wantError string
}{
{"missing path", "", "path is required"},
{"unresolvable repo", "?path=one.txt&repo=nope", "repo subpath not found"},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
rec := workspaceRequest(t, srv, http.MethodDelete, "/api/v1/workspace/file"+tc.query, nil)
if rec.Code != http.StatusBadRequest {
t.Fatalf("status = %d, want 400 (body %s)", rec.Code, rec.Body.String())
}
got := decodeWorkspaceBody[streams.FileDeleteResponse](t, rec)
if !strings.Contains(got.Error, tc.wantError) {
t.Errorf("error = %q, want it to contain %q", got.Error, tc.wantError)
}
})
}
}
// TestHandleFileRename_MovesFile asserts both ends of the move: the old path is
// gone and the new path carries the original bytes.
func TestHandleFileRename_MovesFile(t *testing.T) {
srv, workDir := newWorkspaceFileServer(t)
rec := workspaceRequest(t, srv, http.MethodPost, "/api/v1/workspace/file/rename", streams.FileRenameRequest{
OldPath: "one.txt",
NewPath: "nested/renamed.txt",
})
if rec.Code != http.StatusOK {
t.Fatalf("status = %d (body %s)", rec.Code, rec.Body.String())
}
got := decodeWorkspaceBody[streams.FileRenameResponse](t, rec)
if !got.Success || got.OldPath != "one.txt" || got.NewPath != "nested/renamed.txt" {
t.Fatalf("rename response = %+v", got)
}
if _, err := os.Stat(filepath.Join(workDir, "one.txt")); !os.IsNotExist(err) {
t.Errorf("one.txt still exists after rename (stat err = %v)", err)
}
content, err := os.ReadFile(filepath.Join(workDir, "nested", "renamed.txt"))
if err != nil {
t.Fatalf("read renamed file: %v", err)
}
if string(content) != "one\n" {
t.Errorf("renamed file = %q, want the original %q", string(content), "one\n")
}
}
// TestHandleFileRename_Rejections covers each guard, including the two
// separate repo-scoping joins the handler performs (old and new path).
func TestHandleFileRename_Rejections(t *testing.T) {
srv, _ := newWorkspaceFileServer(t)
cases := []struct {
name string
body any
wantError string
}{
{"malformed body", "{not json", "invalid request: "},
{"missing old path", streams.FileRenameRequest{NewPath: "b.txt"}, "old_path is required"},
{"missing new path", streams.FileRenameRequest{OldPath: "one.txt"}, "new_path is required"},
{
"unresolvable repo",
streams.FileRenameRequest{OldPath: "one.txt", NewPath: "b.txt", Repo: "nope"},
"repo subpath not found",
},
{"missing source", streams.FileRenameRequest{OldPath: "absent.txt", NewPath: "b.txt"}, ""},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
rec := workspaceRequest(t, srv, http.MethodPost, "/api/v1/workspace/file/rename", tc.body)
if rec.Code != http.StatusBadRequest {
t.Fatalf("status = %d, want 400 (body %s)", rec.Code, rec.Body.String())
}
got := decodeWorkspaceBody[streams.FileRenameResponse](t, rec)
if got.Success {
t.Errorf("success = true, want false")
}
if got.Error == "" {
t.Fatalf("error is empty; the refusal reason must reach the caller")
}
if !strings.Contains(got.Error, tc.wantError) {
t.Errorf("error = %q, want it to contain %q", got.Error, tc.wantError)
}
})
}
}
// TestMustParseInt covers the query-number helper the tree and search handlers
// share. It answers 0 (not an error) for anything unparseable, which is why
// both callers guard on the result being positive.
func TestMustParseInt(t *testing.T) {
cases := map[string]int{
"7": 7,
"0": 0,
"-3": -3,
"": 0,
"seven": 0,
"1.5": 0,
"9e9": 0,
}
for input, want := range cases {
if got := mustParseInt(input); got != want {
t.Errorf("mustParseInt(%q) = %d, want %d", input, got, want)
}
}
}
// TestHandleFileContentAtRef_ReadsCommittedBytes asserts the endpoint reads
// from git rather than the working tree: the file is edited on disk and the
// response must still carry the committed content for the requested ref.
func TestHandleFileContentAtRef_ReadsCommittedBytes(t *testing.T) {
fixture := newGitAPIFixture(t)
writeFileAPI(t, fixture.repo, "one.txt", "dirty working tree\n")
rec := getGitAPI(t, fixture.server, "/api/v1/workspace/file/content-at-ref?path=one.txt&ref=HEAD")
if rec.Code != http.StatusOK {
t.Fatalf("status = %d (body %s)", rec.Code, rec.Body.String())
}
got := decodeWorkspaceBody[streams.FileContentResponse](t, rec)
if got.Content != "one\n" {
t.Errorf("content = %q, want the committed %q", got.Content, "one\n")
}
if got.Path != "one.txt" {
t.Errorf("path = %q, want %q", got.Path, "one.txt")
}
}
// TestHandleFileContentAtRef_Rejections covers every guard, including the
// ref that predates the file — a miss inside git, not a bad request shape.
func TestHandleFileContentAtRef_Rejections(t *testing.T) {
fixture := newGitAPIFixture(t)
cases := []struct {
name string
query string
wantError string
}{
{"missing path", "?ref=HEAD", "path is required"},
{"missing ref", "?path=one.txt", "ref is required"},
{"unresolvable repo", "?path=one.txt&ref=HEAD&repo=nope", "repo subpath not found"},
{"ref predating the file", "?path=one.txt&ref=main", ""},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
rec := getGitAPI(t, fixture.server, "/api/v1/workspace/file/content-at-ref"+tc.query)
if rec.Code != http.StatusBadRequest {
t.Fatalf("status = %d, want 400 (body %s)", rec.Code, rec.Body.String())
}
got := decodeWorkspaceBody[streams.FileContentResponse](t, rec)
if got.Error == "" {
t.Fatalf("error is empty; the refusal reason must reach the caller")
}
if !strings.Contains(got.Error, tc.wantError) {
t.Errorf("error = %q, want it to contain %q", got.Error, tc.wantError)
}
})
}
}
// TestHandleFileContentAtRef_RequiresRepoOnMultiRepoWorkspace pins the
// multi-repo guard. Without an explicit repo the read would land on the task
// root, which is not itself a git repository, and every ref lookup there fails
// for a reason that has nothing to do with the file the user asked for.
func TestHandleFileContentAtRef_RequiresRepoOnMultiRepoWorkspace(t *testing.T) {
srv, repoNames := newMultiRepoStatusServer(t)
rec := getGitAPI(t, srv, "/api/v1/workspace/file/content-at-ref?path=README.md&ref=HEAD")
if rec.Code != http.StatusBadRequest {
t.Fatalf("status = %d, want 400 (body %s)", rec.Code, rec.Body.String())
}
if got := decodeWorkspaceBody[streams.FileContentResponse](t, rec); got.Error != "repo is required for multi-repo workspace" {
t.Errorf("error = %q, want the multi-repo refusal", got.Error)
}
scoped := getGitAPI(t, srv, "/api/v1/workspace/file/content-at-ref?path=README.md&ref=HEAD&repo="+repoNames[0])
if scoped.Code != http.StatusOK {
t.Fatalf("scoped status = %d (body %s)", scoped.Code, scoped.Body.String())
}
if got := decodeWorkspaceBody[streams.FileContentResponse](t, scoped); got.Content != repoNames[0]+"\n" {
t.Errorf("content = %q, want %q", got.Content, repoNames[0]+"\n")
}
}
@@ -0,0 +1,277 @@
package api
import (
"io"
"net/http"
"net/http/httptest"
"strings"
"sync"
"testing"
"time"
"github.com/gorilla/websocket"
"github.com/kandev/kandev/internal/agentctl/types"
)
const wsTestTimeout = 10 * time.Second
// recordingShell stands in for the PTY-backed shell the workspace stream
// forwards `shell_input` to. Reads are synchronised because the input loop
// writes from the server goroutine while the test asserts from its own.
type recordingShell struct {
mu sync.Mutex
written []byte
got chan struct{}
}
func newRecordingShell() *recordingShell {
return &recordingShell{got: make(chan struct{}, 8)}
}
func (r *recordingShell) Write(p []byte) (int, error) {
r.mu.Lock()
r.written = append(r.written, p...)
r.mu.Unlock()
r.got <- struct{}{}
return len(p), nil
}
func (r *recordingShell) snapshot() string {
r.mu.Lock()
defer r.mu.Unlock()
return string(r.written)
}
func (r *recordingShell) awaitWrite(t *testing.T) {
t.Helper()
select {
case <-r.got:
case <-time.After(wsTestTimeout):
t.Fatal("timed out waiting for the input loop to forward shell input")
}
}
// dialWorkspaceInputLoop runs handleWorkspaceStreamInput behind a real
// WebSocket so the read path, the JSON decoding, and the pong write are all
// exercised end to end. Cleanup closes the client, joins the loop, and shuts
// the server down, which is what keeps goleak quiet.
func dialWorkspaceInputLoop(t *testing.T, shell io.Writer) *websocket.Conn {
t.Helper()
srv := newTestServer(t)
loopReturned := make(chan struct{})
done := make(chan struct{})
httpServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
conn, err := srv.upgrader.Upgrade(w, r, nil)
if err != nil {
t.Errorf("upgrade: %v", err)
close(loopReturned)
return
}
defer func() { _ = conn.Close() }()
srv.handleWorkspaceStreamInput(conn, shell, done)
close(loopReturned)
}))
conn, _, err := websocket.DefaultDialer.Dial("ws"+strings.TrimPrefix(httpServer.URL, "http"), nil)
if err != nil {
httpServer.Close()
t.Fatalf("dial workspace input loop: %v", err)
}
t.Cleanup(func() {
_ = conn.Close()
select {
case <-loopReturned:
case <-time.After(wsTestTimeout):
t.Error("workspace stream input loop did not return after the client disconnected")
}
close(done)
httpServer.Close()
})
return conn
}
func readWorkspaceMessage(t *testing.T, conn *websocket.Conn) types.WorkspaceStreamMessage {
t.Helper()
_ = conn.SetReadDeadline(time.Now().Add(wsTestTimeout))
var msg types.WorkspaceStreamMessage
if err := conn.ReadJSON(&msg); err != nil {
t.Fatalf("read workspace message: %v", err)
}
return msg
}
func writeWorkspaceMessage(t *testing.T, conn *websocket.Conn, msg types.WorkspaceStreamMessage) {
t.Helper()
if err := conn.WriteJSON(msg); err != nil {
t.Fatalf("write workspace message: %v", err)
}
}
// TestHandleWorkspaceStreamInput_ForwardsShellInput asserts the bytes reach the
// shell verbatim — no framing, no newline added — because the terminal is a raw
// byte pipe and any decoration would show up as garbage keystrokes.
func TestHandleWorkspaceStreamInput_ForwardsShellInput(t *testing.T) {
shell := newRecordingShell()
conn := dialWorkspaceInputLoop(t, shell)
writeWorkspaceMessage(t, conn, types.WorkspaceStreamMessage{
Type: types.WorkspaceMessageTypeShellInput,
Data: "ls -la\r",
})
shell.awaitWrite(t)
if got := shell.snapshot(); got != "ls -la\r" {
t.Errorf("shell received %q, want %q", got, "ls -la\r")
}
}
// TestHandleWorkspaceStreamInput_AnswersPing pins the keepalive: a ping must
// produce a pong on the same connection. The frontend closes and re-dials the
// workspace stream when the pong stops arriving.
func TestHandleWorkspaceStreamInput_AnswersPing(t *testing.T) {
conn := dialWorkspaceInputLoop(t, newRecordingShell())
writeWorkspaceMessage(t, conn, types.WorkspaceStreamMessage{Type: types.WorkspaceMessageTypePing})
got := readWorkspaceMessage(t, conn)
if got.Type != types.WorkspaceMessageTypePong {
t.Errorf("reply type = %q, want %q", got.Type, types.WorkspaceMessageTypePong)
}
if got.Timestamp == 0 {
t.Errorf("pong carries no timestamp")
}
}
// TestHandleWorkspaceStreamInput_IgnoresNonInputMessages proves resize and
// unknown message types are consumed without being forwarded to the shell.
// Routing a resize into the PTY as keystrokes would inject its JSON into the
// user's command line.
func TestHandleWorkspaceStreamInput_IgnoresNonInputMessages(t *testing.T) {
shell := newRecordingShell()
conn := dialWorkspaceInputLoop(t, shell)
writeWorkspaceMessage(t, conn, types.WorkspaceStreamMessage{
Type: types.WorkspaceMessageTypeShellResize,
Cols: 120,
Rows: 40,
})
writeWorkspaceMessage(t, conn, types.WorkspaceStreamMessage{Type: "totally-unknown", Data: "ignored"})
// The ping is ordered after both, and the loop is single-threaded, so its
// pong proves the two earlier messages were fully processed.
writeWorkspaceMessage(t, conn, types.WorkspaceStreamMessage{Type: types.WorkspaceMessageTypePing})
if got := readWorkspaceMessage(t, conn); got.Type != types.WorkspaceMessageTypePong {
t.Fatalf("reply type = %q, want %q", got.Type, types.WorkspaceMessageTypePong)
}
if got := shell.snapshot(); got != "" {
t.Errorf("shell received %q; only shell_input may be forwarded", got)
}
}
// TestHandleWorkspaceStreamWS_ForwardsTrackerEvents drives the full endpoint:
// the greeting frame, then a workspace event published by the tracker while the
// client is attached. The event has to arrive tagged as git_commit with its
// payload intact — this is the fan-out the Commits panel is built on.
//
// The teardown is the interesting part. The forwarding loop only notices a
// departed client on its next write, so after closing the connection the test
// keeps publishing until the handler returns; the channel, not a fixed sleep,
// is what the test waits on.
func TestHandleWorkspaceStreamWS_ForwardsTrackerEvents(t *testing.T) {
srv := newTestServer(t)
handlerReturned := make(chan struct{})
// sync.Once: a second request to this server — a retry, or a future edit
// that dials twice — would otherwise close an already-closed channel and
// panic on a server goroutine, taking down the whole test binary.
var returnedOnce sync.Once
httpServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
defer returnedOnce.Do(func() { close(handlerReturned) })
srv.Router().ServeHTTP(w, r)
}))
conn, _, err := websocket.DefaultDialer.Dial(
"ws"+strings.TrimPrefix(httpServer.URL, "http")+"/api/v1/workspace/stream", nil)
if err != nil {
httpServer.Close()
t.Fatalf("dial workspace stream: %v", err)
}
// Registered before any assertion below can t.Fatal. httpServer.Close waits
// for the handler, so it must run after the shutdown loop has released it —
// cleanups run last-registered-first, hence this ordering.
t.Cleanup(httpServer.Close)
t.Cleanup(func() {
_ = conn.Close()
waitForWorkspaceStreamShutdown(t, srv.procMgr.GetWorkspaceTracker().NotifyGitCommit, handlerReturned)
})
if got := readWorkspaceMessage(t, conn); got.Type != types.WorkspaceMessageTypeConnected {
t.Fatalf("first frame type = %q, want %q", got.Type, types.WorkspaceMessageTypeConnected)
}
tracker := srv.procMgr.GetWorkspaceTracker()
tracker.NotifyGitCommit(&types.GitCommitNotification{
CommitSHA: "1111111111111111111111111111111111111111",
ParentSHA: "2222222222222222222222222222222222222222",
Message: "streamed commit",
})
event := readWorkspaceMessage(t, conn)
if event.Type != types.WorkspaceMessageTypeGitCommit {
t.Fatalf("event type = %q, want %q", event.Type, types.WorkspaceMessageTypeGitCommit)
}
if event.GitCommit == nil {
t.Fatalf("git_commit payload is missing: %+v", event)
}
if event.GitCommit.CommitSHA != "1111111111111111111111111111111111111111" {
t.Errorf("commit_sha = %q, want the published sha", event.GitCommit.CommitSHA)
}
if event.GitCommit.Message != "streamed commit" {
t.Errorf("message = %q, want %q", event.GitCommit.Message, "streamed commit")
}
// Deliberately no ping here: the input goroutine answers a ping by writing
// the pong onto this same connection, while the forwarding loop above is
// also writing to it, and a gorilla *Conn permits only one concurrent
// writer. Ping/pong is covered against the input loop in isolation by
// TestHandleWorkspaceStreamInput_AnswersPing.
}
// waitForWorkspaceStreamShutdown republishes until the handler's forwarding
// loop attempts a write on the closed connection and returns. The first write
// after a peer close usually succeeds (it lands in the kernel buffer), so one
// event is not enough to observe the disconnect.
func waitForWorkspaceStreamShutdown(
t *testing.T,
publish func(*types.GitCommitNotification),
handlerReturned <-chan struct{},
) {
t.Helper()
deadline := time.After(wsTestTimeout)
// One timer, reset per iteration: time.After in a loop leaks a timer per
// pass that the runtime cannot collect until it fires.
retry := time.NewTimer(0)
defer retry.Stop()
if !retry.Stop() {
<-retry.C
}
for {
select {
case <-handlerReturned:
return
case <-deadline:
t.Fatal("workspace stream handler did not return after the client disconnected")
default:
}
publish(&types.GitCommitNotification{CommitSHA: "3333333333333333333333333333333333333333"})
retry.Reset(5 * time.Millisecond)
select {
case <-handlerReturned:
if !retry.Stop() {
<-retry.C
}
return
case <-retry.C:
}
}
}