417 lines
13 KiB
Go
417 lines
13 KiB
Go
package web
|
|
|
|
import (
|
|
"context"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"antidrift/internal/ai"
|
|
"antidrift/internal/domain"
|
|
"antidrift/internal/evidence"
|
|
"antidrift/internal/knowledge"
|
|
"antidrift/internal/session"
|
|
"antidrift/internal/tasks"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
)
|
|
|
|
func newTestServer(t *testing.T) *Server {
|
|
t.Helper()
|
|
gin.SetMode(gin.TestMode)
|
|
path := filepath.Join(t.TempDir(), "state.json")
|
|
ctrl, err := session.New(path)
|
|
if err != nil {
|
|
t.Fatalf("controller: %v", err)
|
|
}
|
|
return NewServer(ctrl)
|
|
}
|
|
|
|
func post(t *testing.T, r http.Handler, path, body string) *httptest.ResponseRecorder {
|
|
t.Helper()
|
|
req := httptest.NewRequest(http.MethodPost, path, strings.NewReader(body))
|
|
req.Header.Set("Content-Type", "application/json")
|
|
w := httptest.NewRecorder()
|
|
r.ServeHTTP(w, req)
|
|
return w
|
|
}
|
|
|
|
func TestPlanningThenCommitmentReachesActive(t *testing.T) {
|
|
s := newTestServer(t)
|
|
r := s.Router()
|
|
|
|
if w := post(t, r, "/planning", ""); w.Code != http.StatusOK {
|
|
t.Fatalf("/planning code %d", w.Code)
|
|
}
|
|
body := `{"next_action":"Build web","success_condition":"web tests pass","timebox_secs":1500}`
|
|
if w := post(t, r, "/commitment", body); w.Code != http.StatusOK {
|
|
t.Fatalf("/commitment code %d body %s", w.Code, w.Body.String())
|
|
}
|
|
if s.ctrl.State().RuntimeState != domain.RuntimeActive {
|
|
t.Fatalf("expected Active, got %s", s.ctrl.State().RuntimeState)
|
|
}
|
|
}
|
|
|
|
func TestCommitmentRejectsInvalidInput(t *testing.T) {
|
|
s := newTestServer(t)
|
|
r := s.Router()
|
|
_ = post(t, r, "/planning", "")
|
|
body := `{"next_action":"","success_condition":"x","timebox_secs":1500}`
|
|
w := post(t, r, "/commitment", body)
|
|
if w.Code != http.StatusBadRequest {
|
|
t.Fatalf("expected 400, got %d", w.Code)
|
|
}
|
|
}
|
|
|
|
func TestIllegalTransitionReturns409(t *testing.T) {
|
|
s := newTestServer(t)
|
|
r := s.Router()
|
|
// /complete from Locked is illegal.
|
|
w := post(t, r, "/complete", "")
|
|
if w.Code != http.StatusConflict {
|
|
t.Fatalf("expected 409, got %d", w.Code)
|
|
}
|
|
}
|
|
|
|
func TestActiveStatePayloadCarriesEvidence(t *testing.T) {
|
|
s := newTestServer(t)
|
|
r := s.Router()
|
|
_ = post(t, r, "/planning", "")
|
|
body := `{"next_action":"Build web","success_condition":"web tests pass","timebox_secs":1500}`
|
|
if w := post(t, r, "/commitment", body); w.Code != http.StatusOK {
|
|
t.Fatalf("/commitment code %d body %s", w.Code, w.Body.String())
|
|
}
|
|
// A focus update should appear in the serialized state.
|
|
s.ctrl.RecordWindow(evidence.WindowSnapshot{Class: "code", Title: "antidrift", Health: evidence.EvidenceHealth{Available: true}})
|
|
|
|
js := s.stateJSON()
|
|
if !strings.Contains(js, `"evidence"`) {
|
|
t.Fatalf("payload missing evidence object: %s", js)
|
|
}
|
|
if !strings.Contains(js, `"class":"code"`) {
|
|
t.Fatalf("payload missing current window: %s", js)
|
|
}
|
|
}
|
|
|
|
func TestLockedStateHasNullEvidence(t *testing.T) {
|
|
s := newTestServer(t)
|
|
js := s.stateJSON()
|
|
if !strings.Contains(js, `"evidence":null`) {
|
|
t.Fatalf("locked payload should have null evidence: %s", js)
|
|
}
|
|
}
|
|
|
|
type stubCoach struct {
|
|
prop ai.Proposal
|
|
err error
|
|
}
|
|
|
|
func (s stubCoach) Coach(ctx context.Context, intent, grounding string) (ai.Proposal, error) {
|
|
return s.prop, s.err
|
|
}
|
|
|
|
func TestCoachRouteHappyPath(t *testing.T) {
|
|
s := newTestServer(t)
|
|
s.ctrl.SetCoach(stubCoach{prop: ai.Proposal{NextAction: "Do X", SuccessCondition: "done", TimeboxSecs: 1500}})
|
|
r := s.Router()
|
|
_ = post(t, r, "/planning", "")
|
|
if w := post(t, r, "/coach", `{"intent":"do something"}`); w.Code != http.StatusOK {
|
|
t.Fatalf("/coach code %d body %s", w.Code, w.Body.String())
|
|
}
|
|
deadline := time.Now().Add(2 * time.Second)
|
|
for time.Now().Before(deadline) {
|
|
if cv := s.ctrl.State().Coach; cv != nil && cv.Status == "ready" {
|
|
return
|
|
}
|
|
time.Sleep(5 * time.Millisecond)
|
|
}
|
|
t.Fatalf("coach never reached ready: %+v", s.ctrl.State().Coach)
|
|
}
|
|
|
|
func TestCoachRouteOutsidePlanning(t *testing.T) {
|
|
s := newTestServer(t)
|
|
s.ctrl.SetCoach(stubCoach{})
|
|
r := s.Router()
|
|
if w := post(t, r, "/coach", `{"intent":"x"}`); w.Code != http.StatusBadRequest {
|
|
t.Fatalf("expected 400, got %d", w.Code)
|
|
}
|
|
}
|
|
|
|
func TestCoachRouteInvalidJSON(t *testing.T) {
|
|
s := newTestServer(t)
|
|
r := s.Router()
|
|
_ = post(t, r, "/planning", "")
|
|
if w := post(t, r, "/coach", `not json`); w.Code != http.StatusBadRequest {
|
|
t.Fatalf("expected 400, got %d", w.Code)
|
|
}
|
|
}
|
|
|
|
func TestCoachRouteUnavailableDegrades(t *testing.T) {
|
|
s := newTestServer(t) // no SetCoach
|
|
r := s.Router()
|
|
_ = post(t, r, "/planning", "")
|
|
if w := post(t, r, "/coach", `{"intent":"x"}`); w.Code != http.StatusOK {
|
|
t.Fatalf("unavailable coach should still 200, got %d", w.Code)
|
|
}
|
|
if cv := s.ctrl.State().Coach; cv == nil || cv.Status != "error" {
|
|
t.Fatalf("want error status, got %+v", cv)
|
|
}
|
|
}
|
|
|
|
func TestRefocusAndOnTaskOutsideActiveIs400(t *testing.T) {
|
|
s := newTestServer(t)
|
|
r := s.Router()
|
|
if w := post(t, r, "/refocus", ""); w.Code != http.StatusBadRequest {
|
|
t.Fatalf("refocus outside Active: want 400, got %d", w.Code)
|
|
}
|
|
if w := post(t, r, "/ontask", ""); w.Code != http.StatusBadRequest {
|
|
t.Fatalf("ontask outside Active: want 400, got %d", w.Code)
|
|
}
|
|
}
|
|
|
|
type stubNudger struct{ msg string }
|
|
|
|
func (s stubNudger) Nudge(ctx context.Context, commitment string, recentTitles []string) (string, error) {
|
|
return s.msg, nil
|
|
}
|
|
|
|
func TestActiveStatePayloadCarriesNudge(t *testing.T) {
|
|
s := newTestServer(t)
|
|
s.ctrl.SetNudge(stubNudger{msg: "drifted to unrelated work"})
|
|
r := s.Router()
|
|
_ = post(t, r, "/planning", "")
|
|
body := `{"next_action":"Build web","success_condition":"web tests pass","timebox_secs":1500,"allowed_window_classes":["code"]}`
|
|
if w := post(t, r, "/commitment", body); w.Code != http.StatusOK {
|
|
t.Fatalf("/commitment code %d body %s", w.Code, w.Body.String())
|
|
}
|
|
// Two distinct on-task titles trip the nudge (history >= 2; first call has no
|
|
// debounce to wait on).
|
|
s.ctrl.RecordWindow(evidence.WindowSnapshot{Class: "code", Title: "a.go", Health: evidence.EvidenceHealth{Available: true}})
|
|
s.ctrl.RecordWindow(evidence.WindowSnapshot{Class: "code", Title: "b.go", Health: evidence.EvidenceHealth{Available: true}})
|
|
|
|
deadline := time.Now().Add(2 * time.Second)
|
|
for time.Now().Before(deadline) {
|
|
if d := s.ctrl.State().Drift; d != nil && d.Nudge != "" {
|
|
break
|
|
}
|
|
time.Sleep(5 * time.Millisecond)
|
|
}
|
|
js := s.stateJSON()
|
|
if !strings.Contains(js, `"nudge":"drifted to unrelated work"`) {
|
|
t.Fatalf("payload missing nudge: %s", js)
|
|
}
|
|
}
|
|
|
|
func TestServesStaticAssets(t *testing.T) {
|
|
s := newTestServer(t)
|
|
r := s.Router()
|
|
|
|
cases := []struct {
|
|
path string
|
|
ctSubstr string
|
|
}{
|
|
{"/app.css", "css"},
|
|
{"/app.js", "javascript"},
|
|
{"/favicon.ico", "image"},
|
|
{"/favicon.png", "image"},
|
|
}
|
|
for _, tc := range cases {
|
|
req := httptest.NewRequest(http.MethodGet, tc.path, nil)
|
|
w := httptest.NewRecorder()
|
|
r.ServeHTTP(w, req)
|
|
if w.Code != http.StatusOK {
|
|
t.Errorf("GET %s code = %d, want 200", tc.path, w.Code)
|
|
}
|
|
if ct := w.Header().Get("Content-Type"); !strings.Contains(ct, tc.ctSubstr) {
|
|
t.Errorf("GET %s Content-Type = %q, want substring %q", tc.path, ct, tc.ctSubstr)
|
|
}
|
|
if w.Body.Len() == 0 {
|
|
t.Errorf("GET %s body is empty", tc.path)
|
|
}
|
|
}
|
|
}
|
|
|
|
type stubProvider struct {
|
|
list []tasks.Task
|
|
}
|
|
|
|
func (s stubProvider) Today(ctx context.Context) ([]tasks.Task, error) {
|
|
return s.list, nil
|
|
}
|
|
|
|
func TestPlanningStatePayloadCarriesTasks(t *testing.T) {
|
|
s := newTestServer(t)
|
|
s.ctrl.SetTasks(stubProvider{list: []tasks.Task{{ID: "a", Title: "Write the spec", Day: "2026-05-31"}}})
|
|
r := s.Router()
|
|
if w := post(t, r, "/planning", ""); w.Code != http.StatusOK {
|
|
t.Fatalf("/planning code %d", w.Code)
|
|
}
|
|
deadline := time.Now().Add(2 * time.Second)
|
|
for time.Now().Before(deadline) {
|
|
if tv := s.ctrl.State().Tasks; tv != nil && tv.Status == "ready" {
|
|
break
|
|
}
|
|
time.Sleep(5 * time.Millisecond)
|
|
}
|
|
js := s.stateJSON()
|
|
if !strings.Contains(js, `"tasks"`) {
|
|
t.Fatalf("planning payload missing tasks object: %s", js)
|
|
}
|
|
if !strings.Contains(js, `"title":"Write the spec"`) {
|
|
t.Fatalf("planning payload missing task title: %s", js)
|
|
}
|
|
}
|
|
|
|
func TestCommitmentCarriesAllowedClassesAndRoutesWork(t *testing.T) {
|
|
s := newTestServer(t)
|
|
r := s.Router()
|
|
_ = post(t, r, "/planning", "")
|
|
body := `{"next_action":"a","success_condition":"b","timebox_secs":1500,"allowed_window_classes":["code"]}`
|
|
if w := post(t, r, "/commitment", body); w.Code != http.StatusOK {
|
|
t.Fatalf("commitment: want 200, got %d (%s)", w.Code, w.Body.String())
|
|
}
|
|
if got := s.ctrl.AllowedClassesForTest(); len(got) != 1 || got[0] != "code" {
|
|
t.Fatalf("commitment did not carry allowed classes: %#v", got)
|
|
}
|
|
// Now Active: overrides succeed.
|
|
if w := post(t, r, "/ontask", ""); w.Code != http.StatusOK {
|
|
t.Fatalf("ontask while Active: want 200, got %d", w.Code)
|
|
}
|
|
if w := post(t, r, "/refocus", ""); w.Code != http.StatusOK {
|
|
t.Fatalf("refocus while Active: want 200, got %d", w.Code)
|
|
}
|
|
}
|
|
|
|
type stubSource struct {
|
|
profile knowledge.Profile
|
|
}
|
|
|
|
func (s stubSource) Load(ctx context.Context, path string) (knowledge.Profile, error) {
|
|
if path != "" {
|
|
return knowledge.Profile{Text: "from " + path, Path: path}, nil
|
|
}
|
|
return s.profile, nil
|
|
}
|
|
|
|
func TestPlanningStatePayloadCarriesKnowledge(t *testing.T) {
|
|
s := newTestServer(t)
|
|
s.ctrl.SetKnowledge(stubSource{profile: knowledge.Profile{Text: "I value small diffs.", Path: "/home/u/.antidrift/knowledge.md"}})
|
|
r := s.Router()
|
|
if w := post(t, r, "/planning", ""); w.Code != http.StatusOK {
|
|
t.Fatalf("/planning code %d", w.Code)
|
|
}
|
|
deadline := time.Now().Add(2 * time.Second)
|
|
for time.Now().Before(deadline) {
|
|
if kv := s.ctrl.State().Knowledge; kv != nil && kv.Status == "ready" {
|
|
break
|
|
}
|
|
time.Sleep(5 * time.Millisecond)
|
|
}
|
|
js := s.stateJSON()
|
|
if !strings.Contains(js, `"knowledge"`) || !strings.Contains(js, `"status":"ready"`) {
|
|
t.Fatalf("planning payload missing knowledge object: %s", js)
|
|
}
|
|
if strings.Contains(js, "small diffs") {
|
|
t.Fatalf("profile text must NOT cross the wire: %s", js)
|
|
}
|
|
}
|
|
|
|
type stubReviewer struct {
|
|
refl ai.Reflection
|
|
}
|
|
|
|
func (s stubReviewer) Review(ctx context.Context, finished, history string) (ai.Reflection, error) {
|
|
return s.refl, nil
|
|
}
|
|
|
|
func TestReflectionFlowsToReviewThenPlanning(t *testing.T) {
|
|
s := newTestServer(t)
|
|
s.ctrl.SetReviewer(stubReviewer{refl: ai.Reflection{Recap: "held focus well", CarryForward: "start in the editor"}})
|
|
r := s.Router()
|
|
_ = post(t, r, "/planning", "")
|
|
body := `{"next_action":"a","success_condition":"b","timebox_secs":1500}`
|
|
if w := post(t, r, "/commitment", body); w.Code != http.StatusOK {
|
|
t.Fatalf("/commitment code %d body %s", w.Code, w.Body.String())
|
|
}
|
|
if w := post(t, r, "/complete", ""); w.Code != http.StatusOK {
|
|
t.Fatalf("/complete code %d", w.Code)
|
|
}
|
|
deadline := time.Now().Add(2 * time.Second)
|
|
for time.Now().Before(deadline) {
|
|
if rv := s.ctrl.State().Reflection; rv != nil && rv.Status == "ready" {
|
|
break
|
|
}
|
|
time.Sleep(5 * time.Millisecond)
|
|
}
|
|
js := s.stateJSON()
|
|
if !strings.Contains(js, `"recap":"held focus well"`) {
|
|
t.Fatalf("review payload missing recap: %s", js)
|
|
}
|
|
|
|
// End -> Locked -> Planning: the carry-forward should surface on planning.
|
|
if w := post(t, r, "/end", ""); w.Code != http.StatusOK {
|
|
t.Fatalf("/end code %d", w.Code)
|
|
}
|
|
if w := post(t, r, "/planning", ""); w.Code != http.StatusOK {
|
|
t.Fatalf("/planning code %d", w.Code)
|
|
}
|
|
js2 := s.stateJSON()
|
|
if !strings.Contains(js2, `"carry_forward":"start in the editor"`) {
|
|
t.Fatalf("planning payload missing carry-forward: %s", js2)
|
|
}
|
|
}
|
|
|
|
type stubJudge struct{ verdict ai.Verdict }
|
|
|
|
func (j stubJudge) JudgeDrift(ctx context.Context, commitment, class, title string) (ai.Verdict, error) {
|
|
return j.verdict, nil
|
|
}
|
|
|
|
func TestEnforceTogglePutsEnforcedOnTheWire(t *testing.T) {
|
|
s := newTestServer(t)
|
|
r := s.Router()
|
|
s.ctrl.SetDriftJudge(stubJudge{verdict: ai.Verdict{OnTask: false, Reason: "off-task"}})
|
|
|
|
if w := post(t, r, "/planning", ""); w.Code != http.StatusOK {
|
|
t.Fatalf("/planning code %d", w.Code)
|
|
}
|
|
body := `{"next_action":"a","success_condition":"b","timebox_secs":1500,"allowed_window_classes":["code"],"enforce":true}`
|
|
if w := post(t, r, "/commitment", body); w.Code != http.StatusOK {
|
|
t.Fatalf("/commitment code %d body %s", w.Code, w.Body.String())
|
|
}
|
|
|
|
s.ctrl.RecordWindow(evidence.WindowSnapshot{Class: "firefox", Title: "YouTube", Health: evidence.EvidenceHealth{Available: true}})
|
|
|
|
deadline := time.Now().Add(2 * time.Second)
|
|
for time.Now().Before(deadline) {
|
|
if strings.Contains(s.stateJSON(), `"enforced":true`) {
|
|
return
|
|
}
|
|
time.Sleep(5 * time.Millisecond)
|
|
}
|
|
t.Fatalf("state never reported enforced:true; last: %s", s.stateJSON())
|
|
}
|
|
|
|
func TestKnowledgePathSelectionReloads(t *testing.T) {
|
|
s := newTestServer(t)
|
|
s.ctrl.SetKnowledge(stubSource{profile: knowledge.Profile{Path: "/default"}})
|
|
r := s.Router()
|
|
if w := post(t, r, "/planning", ""); w.Code != http.StatusOK {
|
|
t.Fatalf("/planning code %d", w.Code)
|
|
}
|
|
if w := post(t, r, "/knowledge/path", `{"path":"/custom/profile.md"}`); w.Code != http.StatusOK {
|
|
t.Fatalf("/knowledge/path code %d body %s", w.Code, w.Body.String())
|
|
}
|
|
deadline := time.Now().Add(2 * time.Second)
|
|
for time.Now().Before(deadline) {
|
|
if kv := s.ctrl.State().Knowledge; kv != nil && kv.Path == "/custom/profile.md" {
|
|
return
|
|
}
|
|
time.Sleep(5 * time.Millisecond)
|
|
}
|
|
t.Fatalf("path selection did not reload: %+v", s.ctrl.State().Knowledge)
|
|
}
|