X-Git-Url: https://git.giacomolli.uk/onechat/blobdiff_plain/e0ab6220b6fd35f7e92a04e4bf149940185713ab..d7a967f43fae27bcabc6072da3b5a2f923d47764:/turn_test.go?ds=inline
diff --git a/turn_test.go b/turn_test.go
index b8c92dc..9bb0e99 100644
--- a/turn_test.go
+++ b/turn_test.go
@@ -4,6 +4,7 @@ import (
"context"
"encoding/json"
"errors"
+ "log"
"net/http"
"path/filepath"
"strings"
@@ -15,22 +16,22 @@ import (
)
func TestTurnRunsToolsUntilTheFinalAnswer(t *testing.T) {
- server := newFakeResponses(t)
- server.reply = func(w http.ResponseWriter, call fakeCall) {
+ server := newModelFake(t)
+ server.reply = func(w http.ResponseWriter, call ModelFakeCall) {
if call.number == 0 {
- writeEvents(w, completedEvent([]any{
- reasoningItem("rs_1", "opaque thought"),
- functionCallItem("fc_1", "call_1", "shell", `{"command":"echo hi"}`),
+ modelWriteEvents(w, modelCompletedEvent([]any{
+ modelReasoningItem("rs_1", "opaque thought"),
+ modelFunctionCallItem("fc_1", "call_1", "shell", `{"command":"echo hi"}`),
}, 100, 0, 5))
return
}
- writeEvents(w, completedEvent([]any{messageItem("It said hi.")}, 120, 100, 5))
+ modelWriteEvents(w, modelCompletedEvent([]any{modelMessageItem("It said hi.")}, 120, 100, 5))
}
- test := newTestLoop(t, server)
- _, err := test.loop.Submit("Run echo hi.")
+ test := newTestTurnLoop(t, server)
+ _, err := test.loop.Submit(terminalSource, "Run echo hi.")
require.NoError(t, err)
test.events.WaitFor(t, "idle", 1)
require.Equal(t, 2, server.Calls())
@@ -59,15 +60,22 @@ func TestTurnRunsToolsUntilTheFinalAnswer(t *testing.T) {
"reply: It said hi.",
}, test.Log(t))
require.Equal(t, []string{"user", "busy", "tool", "echo", "reply", "idle"}, test.events.Kinds())
+
+ var turns []string
+ for _, record := range modelReadUsage(t, test.usagePath) {
+ turns = append(turns, record.Turn)
+ }
+
+ require.Equal(t, []string{"first", "next"}, turns)
}
func TestFirstRequestHoldsTheViewTheStateAndTheMessage(t *testing.T) {
- server := newFakeResponses(t)
- test := newTestLoop(t, server)
+ server := newModelFake(t)
+ test := newTestTurnLoop(t, server)
_, err := test.memory.Append("user", "an earlier message")
require.NoError(t, err)
- _, err = test.loop.Submit("The new message.")
+ _, err = test.loop.Submit(terminalSource, "The new message.")
require.NoError(t, err)
test.events.WaitFor(t, "idle", 1)
@@ -75,31 +83,31 @@ func TestFirstRequestHoldsTheViewTheStateAndTheMessage(t *testing.T) {
"\n0+1|user: an earlier message\n",
"\n\nNow: Thursday 2026-01-01 12:00 +00:00",
"The new message.",
- }, inputTexts(t, server.Call(0)))
+ }, turnInputTexts(t, server.Call(0)))
}
func TestMessageDuringATurnJoinsTheNextRequest(t *testing.T) {
- server := newFakeResponses(t)
+ server := newModelFake(t)
arrived := make(chan struct{})
release := make(chan struct{})
- server.reply = func(w http.ResponseWriter, call fakeCall) {
+ server.reply = func(w http.ResponseWriter, call ModelFakeCall) {
if call.number == 0 {
close(arrived)
<-release
- writeEvents(w, completedEvent([]any{functionCallItem("fc_1", "call_1", "date", `{"id":0}`)}, 100, 0, 5))
+ modelWriteEvents(w, modelCompletedEvent([]any{modelFunctionCallItem("fc_1", "call_1", "date", `{"id":0}`)}, 100, 0, 5))
return
}
- writeEvents(w, completedEvent([]any{messageItem("done")}, 100, 0, 5))
+ modelWriteEvents(w, modelCompletedEvent([]any{modelMessageItem("done")}, 100, 0, 5))
}
- test := newTestLoop(t, server)
- _, err := test.loop.Submit("first")
+ test := newTestTurnLoop(t, server)
+ _, err := test.loop.Submit(terminalSource, "first")
require.NoError(t, err)
<-arrived
- _, err = test.loop.Submit("second, during the turn")
+ _, err = test.loop.Submit(terminalSource, "second, during the turn")
require.NoError(t, err)
close(release)
@@ -116,45 +124,45 @@ func TestMessageDuringATurnJoinsTheNextRequest(t *testing.T) {
}
func TestMessageDuringTheFinalRequestStartsANewTurn(t *testing.T) {
- server := newFakeResponses(t)
+ server := newModelFake(t)
arrived := make(chan struct{})
release := make(chan struct{})
- server.reply = func(w http.ResponseWriter, call fakeCall) {
+ server.reply = func(w http.ResponseWriter, call ModelFakeCall) {
if call.number == 0 {
close(arrived)
<-release
}
- writeEvents(w, completedEvent([]any{messageItem("answer")}, 100, 0, 5))
+ modelWriteEvents(w, modelCompletedEvent([]any{modelMessageItem("answer")}, 100, 0, 5))
}
- test := newTestLoop(t, server)
- _, err := test.loop.Submit("first")
+ test := newTestTurnLoop(t, server)
+ _, err := test.loop.Submit(terminalSource, "first")
require.NoError(t, err)
<-arrived
- _, err = test.loop.Submit("second")
+ _, err = test.loop.Submit(terminalSource, "second")
require.NoError(t, err)
close(release)
test.events.WaitFor(t, "idle", 2)
require.Equal(t, 2, server.Calls())
- texts := inputTexts(t, server.Call(1))
+ texts := turnInputTexts(t, server.Call(1))
require.Equal(t, "second", texts[len(texts)-1])
require.Contains(t, strings.Join(texts, ""), "|reply: answer\n")
}
func TestTurnWaitsForTheSummaries(t *testing.T) {
- server := newFakeResponses(t)
+ server := newModelFake(t)
summarizer := newFakeSummarizer()
summarizer.gate = make(chan struct{})
- test := newTestLoopWith(t, server, summarizer, false)
+ test := newTestTurnLoopWith(t, server, summarizer)
_, err := test.memory.Append("echo", strings.Repeat("long output ", 100))
require.NoError(t, err)
- _, err = test.loop.Submit("go on")
+ _, err = test.loop.Submit(terminalSource, "go on")
require.NoError(t, err)
time.Sleep(50 * time.Millisecond)
@@ -163,24 +171,24 @@ func TestTurnWaitsForTheSummaries(t *testing.T) {
close(summarizer.gate)
test.events.WaitFor(t, "idle", 1)
require.Equal(t, 1, server.Calls())
- require.NotContains(t, inputTexts(t, server.Call(0))[0], pending)
+ require.NotContains(t, turnInputTexts(t, server.Call(0))[0], viewPending)
}
func TestInterruptEndsTheTurn(t *testing.T) {
- server := newFakeResponses(t)
+ server := newModelFake(t)
arrived := make(chan struct{})
release := make(chan struct{})
- server.reply = func(w http.ResponseWriter, call fakeCall) {
+ server.reply = func(w http.ResponseWriter, call ModelFakeCall) {
if call.number == 0 {
close(arrived)
<-release
}
- writeEvents(w, completedEvent([]any{messageItem("answer")}, 100, 0, 5))
+ modelWriteEvents(w, modelCompletedEvent([]any{modelMessageItem("answer")}, 100, 0, 5))
}
- test := newTestLoop(t, server)
- _, err := test.loop.Submit("a long task")
+ test := newTestTurnLoop(t, server)
+ _, err := test.loop.Submit(terminalSource, "a long task")
require.NoError(t, err)
<-arrived
@@ -192,33 +200,38 @@ func TestInterruptEndsTheTurn(t *testing.T) {
require.Equal(t, []string{"user: a long task"}, test.Log(t))
require.False(t, test.loop.Interrupt())
- _, err = test.loop.Submit("again")
+ _, err = test.loop.Submit(terminalSource, "again")
require.NoError(t, err)
test.events.WaitFor(t, "idle", 2)
require.Equal(t, "reply: answer", test.Log(t)[2])
+ require.Empty(t, test.logs.String())
}
func TestFailedCallEndsTheTurnWithoutARetry(t *testing.T) {
- server := newFakeResponses(t)
- server.reply = func(w http.ResponseWriter, call fakeCall) {
+ server := newModelFake(t)
+ server.reply = func(w http.ResponseWriter, call ModelFakeCall) {
http.Error(w, "busy", http.StatusServiceUnavailable)
}
- test := newTestLoop(t, server)
- _, err := test.loop.Submit("hello")
+ test := newTestTurnLoop(t, server)
+ _, err := test.loop.Submit(terminalSource, "hello")
require.NoError(t, err)
test.events.WaitFor(t, "idle", 1)
time.Sleep(50 * time.Millisecond)
require.Equal(t, 1, server.Calls())
require.Contains(t, test.events.Last("error"), "HTTP 503")
+ require.Equal(t, 1, strings.Count(test.logs.String(), "\n"))
+ require.Contains(t, test.logs.String(), "turn failed: ")
+ require.Contains(t, test.logs.String(), "HTTP 503")
+ require.NotContains(t, test.logs.String(), "hello")
}
func TestViewMessagesOnlyGrowBetweenTurns(t *testing.T) {
- server := newFakeResponses(t)
- test := newTestLoop(t, server)
+ server := newModelFake(t)
+ test := newTestTurnLoop(t, server)
for n, text := range []string{"one", "two", "three"} {
- _, err := test.loop.Submit(text)
+ _, err := test.loop.Submit(terminalSource, text)
require.NoError(t, err)
test.events.WaitFor(t, "idle", n+1)
}
@@ -234,66 +247,21 @@ func TestViewMessagesOnlyGrowBetweenTurns(t *testing.T) {
"2+1|user: two\n3+1|reply: a line\n",
"\n\nNow: Thursday 2026-01-01 12:00 +00:00",
"three",
- }, inputTexts(t, server.Call(2)))
-}
-
-func TestWarmUpEndsWhereTheNextTurnReadsTheCache(t *testing.T) {
- server := newFakeResponses(t)
- server.reply = func(w http.ResponseWriter, call fakeCall) {
- if call.number == 1 {
- writeEvents(w, map[string]any{"type": "response.output_item.added", "item": reasoningItem("rs_1", "")})
- return
- }
-
- writeEvents(w, completedEvent([]any{messageItem("answer")}, 100, 0, 5))
- }
-
- test := newTestLoopWith(t, server, newFakeSummarizer(), true)
- _, err := test.loop.Submit("one")
- require.NoError(t, err)
- require.Eventually(t, func() bool {
- return server.Calls() == 2
- }, 10*time.Second, time.Millisecond)
-
- _, err = test.loop.Submit("two")
- require.NoError(t, err)
- test.events.WaitFor(t, "idle", 2)
- require.Eventually(t, func() bool {
- return server.Calls() == 4
- }, 10*time.Second, time.Millisecond)
-
- warmUp := server.Call(1).body
- require.Equal(t, server.Call(0).body["instructions"], warmUp["instructions"])
- require.Equal(t, server.Call(0).body["tools"], warmUp["tools"])
- require.Equal(t, []string{"\n", "0+1|user: one\n1+1|reply: answer\n"}, inputTexts(t, server.Call(1)))
-
- // The next turn begins with the whole warm-up, so its message end after
- // the view is the end of the warm-up entry.
- warmInput := warmUp["input"].([]any)
- turnInput := server.Call(2).body["input"].([]any)
- require.Equal(t, warmInput, turnInput[:len(warmInput)])
- require.Equal(t, "\n\nNow: Thursday 2026-01-01 12:00 +00:00", inputTexts(t, server.Call(2))[len(warmInput)])
-
- turns := []string{}
- for _, record := range readUsage(t, test.usagePath) {
- turns = append(turns, record.Turn)
- }
-
- require.Equal(t, []string{"first", "warmup", "first", "warmup"}, turns)
- require.Equal(t, []string{"user: one", "reply: answer", "user: two", "reply: answer"}, test.Log(t))
+ }, turnInputTexts(t, server.Call(2)))
}
-// testLoop is a loop that runs in the background of a test, with its parts.
-type testLoop struct {
+// TurnTestLoop is a loop that runs in the background of a test, with its parts.
+type TurnTestLoop struct {
agent *Agent
memory *Memory
- loop *loop
- events *eventRecorder
+ loop *TurnLoop
+ events *TurnEventRecorder
+ logs *SyncBuffer
usagePath string
}
// Log returns the logged messages as "kind: text".
-func (l *testLoop) Log(t *testing.T) []string {
+func (l *TurnTestLoop) Log(t *testing.T) []string {
t.Helper()
var lines []string
@@ -307,20 +275,22 @@ func (l *testLoop) Log(t *testing.T) []string {
return lines
}
-// eventRecorder keeps the events of a loop.
-type eventRecorder struct {
+// TurnEventRecorder keeps the events of a loop.
+type TurnEventRecorder struct {
mutex sync.Mutex
events []Event
}
-func (r *eventRecorder) Add(event Event) {
- r.mutex.Lock()
- defer r.mutex.Unlock()
+// WaitFor waits until count events of kind came.
+func (r *TurnEventRecorder) WaitFor(t *testing.T, kind string, count int) {
+ t.Helper()
- r.events = append(r.events, event)
+ require.Eventually(t, func() bool {
+ return r.Count(kind) >= count
+ }, 10*time.Second, time.Millisecond)
}
-func (r *eventRecorder) Kinds() []string {
+func (r *TurnEventRecorder) Kinds() []string {
r.mutex.Lock()
defer r.mutex.Unlock()
@@ -332,7 +302,7 @@ func (r *eventRecorder) Kinds() []string {
return kinds
}
-func (r *eventRecorder) Count(kind string) int {
+func (r *TurnEventRecorder) Count(kind string) int {
count := 0
for _, each := range r.Kinds() {
if each == kind {
@@ -344,77 +314,39 @@ func (r *eventRecorder) Count(kind string) int {
}
// Last returns the text of the last event of kind.
-func (r *eventRecorder) Last(kind string) string {
+func (r *TurnEventRecorder) Last(kind string) string {
+ return r.LastEvent(kind).Text
+}
+
+// LastEvent returns the last event of kind.
+func (r *TurnEventRecorder) LastEvent(kind string) Event {
r.mutex.Lock()
defer r.mutex.Unlock()
for n := len(r.events) - 1; n >= 0; n-- {
if r.events[n].Kind == kind {
- return r.events[n].Text
+ return r.events[n]
}
}
- return ""
+ return Event{}
}
-// WaitFor waits until count events of kind came.
-func (r *eventRecorder) WaitFor(t *testing.T, kind string, count int) {
- t.Helper()
-
- require.Eventually(t, func() bool {
- return r.Count(kind) >= count
- }, 10*time.Second, time.Millisecond)
-}
-
-func newTestLoop(t *testing.T, server *fakeResponses) *testLoop {
- t.Helper()
+func (r *TurnEventRecorder) Add(event Event) {
+ r.mutex.Lock()
+ defer r.mutex.Unlock()
- return newTestLoopWith(t, server, newFakeSummarizer(), false)
+ r.events = append(r.events, event)
}
-// newTestLoopWith returns a running loop on a new agent whose builds use
-// summarizer and whose commands run in a temporary directory. warmUp turns the
-// warm-up on.
-func newTestLoopWith(t *testing.T, server *fakeResponses, summarizer Summarizer, warmUp bool) *testLoop {
+func newTestTurnLoop(t *testing.T, server *ModelFake) *TurnTestLoop {
t.Helper()
- agent, err := openAgent(t.TempDir())
- require.NoError(t, err)
-
- agent.config.Workdir = t.TempDir()
- clock := newTestClock()
- memory, err := openMemory(t.Context(), t.TempDir(), clock.Now, summarizer)
- require.NoError(t, err)
-
- test := &testLoop{
- agent: agent,
- memory: memory,
- events: &eventRecorder{},
- usagePath: filepath.Join(t.TempDir(), "usage.jsonl"),
- }
-
- client := newClient(server.URL, apiKey(testKey), agent.CacheKey(), test.usagePath)
- test.loop, err = newLoop(agent, memory, client, clock.Now, test.events.Add)
- require.NoError(t, err)
-
- test.loop.warmUp = warmUp
- ctx, cancel := context.WithCancel(t.Context())
- done := make(chan error)
- go func() {
- done <- test.loop.Run(ctx)
- }()
-
- t.Cleanup(func() {
- cancel()
- require.True(t, errors.Is(<-done, context.Canceled))
- require.NoError(t, memory.Close())
- })
-
- return test
+ return newTestTurnLoopWith(t, server, newFakeSummarizer())
}
-// inputTexts returns the text of each user message of the input of call.
-func inputTexts(t *testing.T, call fakeCall) []string {
+// turnInputTexts returns the text of each user message of the input of call.
+func turnInputTexts(t *testing.T, call ModelFakeCall) []string {
t.Helper()
var body struct {
@@ -445,21 +377,42 @@ func inputTexts(t *testing.T, call fakeCall) []string {
return texts
}
-func reasoningItem(id, encrypted string) map[string]any {
- return map[string]any{
- "type": "reasoning",
- "id": id,
- "encrypted_content": encrypted,
- "summary": []any{},
- }
-}
+// newTestTurnLoopWith returns a running loop on a new agent whose builds use
+// summarizer and whose commands run in a temporary directory.
+func newTestTurnLoopWith(t *testing.T, server *ModelFake, summarizer Summarizer) *TurnTestLoop {
+ t.Helper()
-func functionCallItem(id, callID, name, arguments string) map[string]any {
- return map[string]any{
- "type": "function_call",
- "id": id,
- "call_id": callID,
- "name": name,
- "arguments": arguments,
+ agent, err := openAgent(t.TempDir())
+ require.NoError(t, err)
+
+ agent.config.Workdir = t.TempDir()
+ clock := newTestClock()
+ memory, err := openMemory(t.Context(), t.TempDir(), clock.Now, summarizer, discardLog())
+ require.NoError(t, err)
+
+ test := &TurnTestLoop{
+ agent: agent,
+ memory: memory,
+ events: &TurnEventRecorder{},
+ logs: &SyncBuffer{},
+ usagePath: filepath.Join(t.TempDir(), "usage.jsonl"),
}
+
+ client := newModelClient(server.URL, ModelAPIKey(modelTestKey), agent.CacheKey(), test.usagePath)
+ whatsapp, _, _ := whatsappStartTest(t, t.TempDir(), clock)
+ test.loop, err = newTurnLoop(agent, memory, newTestSubagents(t), whatsapp, newTestSchedules(t, clock.Now), client, clock.Now, log.New(test.logs, "", 0), test.events.Add)
+ require.NoError(t, err)
+ ctx, cancel := context.WithCancel(t.Context())
+ done := make(chan error)
+ go func() {
+ done <- test.loop.Run(ctx)
+ }()
+
+ t.Cleanup(func() {
+ cancel()
+ require.True(t, errors.Is(<-done, context.Canceled))
+ require.NoError(t, memory.Close())
+ })
+
+ return test
}