249 lines
7.4 KiB
Go
249 lines
7.4 KiB
Go
package offscreen
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"keel/internal/ai"
|
|
"keel/internal/harness"
|
|
"keel/internal/memory"
|
|
"keel/internal/tasks"
|
|
)
|
|
|
|
// stubBackend is a local fake ai.Backend; ai's package-internal fake is not
|
|
// reachable from this package, so we define our own here.
|
|
type stubBackend struct {
|
|
out string
|
|
err error
|
|
}
|
|
|
|
func (b stubBackend) Name() string { return "stub" }
|
|
func (b stubBackend) Run(context.Context, string) (string, error) {
|
|
return b.out, b.err
|
|
}
|
|
|
|
type fakeTasks struct {
|
|
created []string
|
|
}
|
|
|
|
func (f *fakeTasks) Today(context.Context) ([]tasks.Task, error) { return nil, nil }
|
|
func (f *fakeTasks) Create(_ context.Context, t tasks.Task) error {
|
|
f.created = append(f.created, t.Title)
|
|
return nil
|
|
}
|
|
|
|
func newTestMode(t *testing.T, ft *fakeTasks, backend ai.Backend) *Mode {
|
|
t.Helper()
|
|
svc := harness.Services{
|
|
AI: ai.NewService(backend),
|
|
Tasks: ft,
|
|
Clock: func() time.Time { return time.Unix(0, 0) },
|
|
Notify: func() {},
|
|
}
|
|
return New(svc)
|
|
}
|
|
|
|
// waitStatus polls the mode's View until status reaches want, or fails after 2s.
|
|
func waitStatus(t *testing.T, m *Mode, want string) {
|
|
t.Helper()
|
|
deadline := time.Now().Add(2 * time.Second)
|
|
for time.Now().Before(deadline) {
|
|
v, _ := m.View().(map[string]any)
|
|
if v != nil && v["status"] == want {
|
|
return
|
|
}
|
|
time.Sleep(5 * time.Millisecond)
|
|
}
|
|
t.Fatalf("status never reached %q (last view: %+v)", want, m.View())
|
|
}
|
|
|
|
func okBackend() stubBackend {
|
|
return stubBackend{out: `{"next_action":"call mum","rationale":"people goal"}`}
|
|
}
|
|
|
|
func TestConfirmFilesExactlyOneTask(t *testing.T) {
|
|
ft := &fakeTasks{}
|
|
m := newTestMode(t, ft, okBackend())
|
|
if err := m.Command(context.Background(), "start", nil); err != nil {
|
|
t.Fatalf("start: %v", err)
|
|
}
|
|
waitStatus(t, m, statusProposed)
|
|
|
|
if err := m.Command(context.Background(), "confirm", nil); err != nil {
|
|
t.Fatalf("confirm: %v", err)
|
|
}
|
|
if len(ft.created) != 1 {
|
|
t.Fatalf("created %d tasks, want 1", len(ft.created))
|
|
}
|
|
if ft.created[0] != "call mum" {
|
|
t.Fatalf("created task title = %q, want %q", ft.created[0], "call mum")
|
|
}
|
|
if m.Active() {
|
|
t.Fatal("mode should be done after confirm")
|
|
}
|
|
}
|
|
|
|
func TestDismissWritesNothing(t *testing.T) {
|
|
ft := &fakeTasks{}
|
|
m := newTestMode(t, ft, okBackend())
|
|
if err := m.Command(context.Background(), "start", nil); err != nil {
|
|
t.Fatalf("start: %v", err)
|
|
}
|
|
waitStatus(t, m, statusProposed)
|
|
|
|
if err := m.Command(context.Background(), "dismiss", nil); err != nil {
|
|
t.Fatalf("dismiss: %v", err)
|
|
}
|
|
if len(ft.created) != 0 {
|
|
t.Fatalf("dismiss created %d tasks, want 0", len(ft.created))
|
|
}
|
|
if m.Active() {
|
|
t.Fatal("mode should be done after dismiss")
|
|
}
|
|
}
|
|
|
|
func TestProposeErrorSurfacesInView(t *testing.T) {
|
|
ft := &fakeTasks{}
|
|
m := newTestMode(t, ft, stubBackend{err: errors.New("boom")})
|
|
if err := m.Command(context.Background(), "start", nil); err != nil {
|
|
t.Fatalf("start: %v", err)
|
|
}
|
|
waitStatus(t, m, statusError)
|
|
|
|
v, _ := m.View().(map[string]any)
|
|
if v == nil || v["error"] == nil || v["error"] == "" {
|
|
t.Fatalf("expected error field in view, got %+v", v)
|
|
}
|
|
if !m.Active() {
|
|
t.Fatal("mode should stay active on error so the user can retry or dismiss")
|
|
}
|
|
}
|
|
|
|
func TestConfirmWithoutProposalErrors(t *testing.T) {
|
|
ft := &fakeTasks{}
|
|
m := newTestMode(t, ft, okBackend())
|
|
// No start → no proposal.
|
|
if err := m.Command(context.Background(), "confirm", nil); err == nil {
|
|
t.Fatal("confirm without a proposal should error")
|
|
}
|
|
if len(ft.created) != 0 {
|
|
t.Fatalf("confirm without proposal created %d tasks, want 0", len(ft.created))
|
|
}
|
|
}
|
|
|
|
func TestUnknownCommandErrors(t *testing.T) {
|
|
m := newTestMode(t, &fakeTasks{}, okBackend())
|
|
if err := m.Command(context.Background(), "bogus", nil); err == nil {
|
|
t.Fatal("unknown command should error")
|
|
}
|
|
}
|
|
|
|
// newTestModeMem is newTestMode with an injected in-memory Store.
|
|
func newTestModeMem(t *testing.T, ft *fakeTasks, backend ai.Backend, mem *memory.Fake) *Mode {
|
|
t.Helper()
|
|
svc := harness.Services{
|
|
AI: ai.NewService(backend),
|
|
Tasks: ft,
|
|
Memory: mem,
|
|
Clock: func() time.Time { return time.Unix(1000, 0) },
|
|
Notify: func() {},
|
|
}
|
|
return New(svc)
|
|
}
|
|
|
|
// waitEvent polls the fake until an event of kind appears, or fails after 2s.
|
|
func waitEvent(t *testing.T, f *memory.Fake, kind string) memory.Event {
|
|
t.Helper()
|
|
deadline := time.Now().Add(2 * time.Second)
|
|
for time.Now().Before(deadline) {
|
|
for _, e := range f.Events() {
|
|
if e.Kind == kind {
|
|
return e
|
|
}
|
|
}
|
|
time.Sleep(5 * time.Millisecond)
|
|
}
|
|
t.Fatalf("event %q never recorded (events: %+v)", kind, f.Events())
|
|
return memory.Event{}
|
|
}
|
|
|
|
func TestProposeRecordsProposalMade(t *testing.T) {
|
|
mem := memory.NewFake()
|
|
m := newTestModeMem(t, &fakeTasks{}, okBackend(), mem)
|
|
if err := m.Command(context.Background(), "start", nil); err != nil {
|
|
t.Fatalf("start: %v", err)
|
|
}
|
|
waitStatus(t, m, statusProposed)
|
|
|
|
ev := waitEvent(t, mem, "proposal_made")
|
|
if ev.Data["next_action"] != "call mum" || ev.Data["proposal_id"] == "" {
|
|
t.Fatalf("proposal_made data = %+v", ev.Data)
|
|
}
|
|
}
|
|
|
|
func TestConfirmRecordsActionTakenWithSameID(t *testing.T) {
|
|
mem := memory.NewFake()
|
|
m := newTestModeMem(t, &fakeTasks{}, okBackend(), mem)
|
|
_ = m.Command(context.Background(), "start", nil)
|
|
waitStatus(t, m, statusProposed)
|
|
made := waitEvent(t, mem, "proposal_made")
|
|
|
|
if err := m.Command(context.Background(), "confirm", nil); err != nil {
|
|
t.Fatalf("confirm: %v", err)
|
|
}
|
|
taken := waitEvent(t, mem, "action_taken")
|
|
if taken.Data["proposal_id"] != made.Data["proposal_id"] {
|
|
t.Fatalf("action_taken id %v != proposal_made id %v", taken.Data["proposal_id"], made.Data["proposal_id"])
|
|
}
|
|
}
|
|
|
|
func TestDismissRecordsProposalDismissed(t *testing.T) {
|
|
mem := memory.NewFake()
|
|
m := newTestModeMem(t, &fakeTasks{}, okBackend(), mem)
|
|
_ = m.Command(context.Background(), "start", nil)
|
|
waitStatus(t, m, statusProposed)
|
|
_ = waitEvent(t, mem, "proposal_made")
|
|
|
|
if err := m.Command(context.Background(), "dismiss", nil); err != nil {
|
|
t.Fatalf("dismiss: %v", err)
|
|
}
|
|
_ = waitEvent(t, mem, "proposal_dismissed")
|
|
}
|
|
|
|
func TestBriefIncludesRecentProposalsWithOutcome(t *testing.T) {
|
|
mem := memory.NewFake()
|
|
ctx := context.Background()
|
|
// at = the test clock (Unix 1000); confirmed walk, dismissed stretch.
|
|
_ = mem.Record(ctx, memory.Event{Kind: "proposal_made", At: time.Unix(1000, 0),
|
|
Data: map[string]any{"proposal_id": "w", "next_action": "walk"}})
|
|
_ = mem.Record(ctx, memory.Event{Kind: "action_taken", At: time.Unix(1000, 0),
|
|
Data: map[string]any{"proposal_id": "w"}})
|
|
_ = mem.Record(ctx, memory.Event{Kind: "proposal_made", At: time.Unix(1000, 0),
|
|
Data: map[string]any{"proposal_id": "s", "next_action": "stretch"}})
|
|
_ = mem.Record(ctx, memory.Event{Kind: "proposal_dismissed", At: time.Unix(1000, 0),
|
|
Data: map[string]any{"proposal_id": "s"}})
|
|
|
|
m := newTestModeMem(t, &fakeTasks{}, okBackend(), mem)
|
|
brief := m.assembleBrief()
|
|
|
|
if !strings.Contains(brief, "Recently proposed") {
|
|
t.Fatalf("brief missing history section:\n%s", brief)
|
|
}
|
|
if !strings.Contains(brief, "walk") || !strings.Contains(brief, "confirmed") {
|
|
t.Fatalf("brief missing confirmed walk:\n%s", brief)
|
|
}
|
|
if !strings.Contains(brief, "stretch") || !strings.Contains(brief, "dismissed") {
|
|
t.Fatalf("brief missing dismissed stretch:\n%s", brief)
|
|
}
|
|
}
|
|
|
|
func TestBriefOmitsHistoryWhenNoMemory(t *testing.T) {
|
|
m := newTestMode(t, &fakeTasks{}, okBackend()) // no Memory injected
|
|
if strings.Contains(m.assembleBrief(), "Recently proposed") {
|
|
t.Fatal("history section should be absent without memory")
|
|
}
|
|
}
|