modelWriteEvents(w, modelCompletedEvent([]any{modelMessageItem("It said hi.")}, 120, 100, 5))
}
- test := newTestLoop(t, server)
+ test := newTestTurnLoop(t, server)
_, err := test.loop.Submit(terminalSource, "Run echo hi.")
require.NoError(t, err)
test.events.WaitFor(t, "idle", 1)
func TestFirstRequestHoldsTheViewTheStateAndTheMessage(t *testing.T) {
server := newModelFake(t)
- test := newTestLoop(t, server)
+ test := newTestTurnLoop(t, server)
_, err := test.memory.Append("user", "an earlier message")
require.NoError(t, err)
"<chat>\n0+1|user: an earlier message\n",
"</chat>\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) {
modelWriteEvents(w, modelCompletedEvent([]any{modelMessageItem("done")}, 100, 0, 5))
}
- test := newTestLoop(t, server)
+ test := newTestTurnLoop(t, server)
_, err := test.loop.Submit(terminalSource, "first")
require.NoError(t, err)
modelWriteEvents(w, modelCompletedEvent([]any{modelMessageItem("answer")}, 100, 0, 5))
}
- test := newTestLoop(t, server)
+ test := newTestTurnLoop(t, server)
_, err := test.loop.Submit(terminalSource, "first")
require.NoError(t, err)
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")
}
server := newModelFake(t)
summarizer := newFakeSummarizer()
summarizer.gate = make(chan struct{})
- test := newTestLoopWith(t, server, summarizer)
+ test := newTestTurnLoopWith(t, server, summarizer)
_, err := test.memory.Append("echo", strings.Repeat("long output ", 100))
require.NoError(t, err)
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) {
modelWriteEvents(w, modelCompletedEvent([]any{modelMessageItem("answer")}, 100, 0, 5))
}
- test := newTestLoop(t, server)
+ test := newTestTurnLoop(t, server)
_, err := test.loop.Submit(terminalSource, "a long task")
require.NoError(t, err)
http.Error(w, "busy", http.StatusServiceUnavailable)
}
- test := newTestLoop(t, server)
+ test := newTestTurnLoop(t, server)
_, err := test.loop.Submit(terminalSource, "hello")
require.NoError(t, err)
test.events.WaitFor(t, "idle", 1)
func TestViewMessagesOnlyGrowBetweenTurns(t *testing.T) {
server := newModelFake(t)
- test := newTestLoop(t, server)
+ test := newTestTurnLoop(t, server)
for n, text := range []string{"one", "two", "three"} {
_, err := test.loop.Submit(terminalSource, text)
require.NoError(t, err)
"2+1|user: two\n3+1|reply: a line\n",
"</chat>\n\nNow: Thursday 2026-01-01 12:00 +00:00",
"three",
- }, inputTexts(t, server.Call(2)))
+ }, 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
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
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()
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 {
}
// 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) {
+func (r *TurnEventRecorder) Add(event Event) {
+ r.mutex.Lock()
+ defer r.mutex.Unlock()
+
+ r.events = append(r.events, event)
+}
+
+func newTestTurnLoop(t *testing.T, server *ModelFake) *TurnTestLoop {
t.Helper()
- require.Eventually(t, func() bool {
- return r.Count(kind) >= count
- }, 10*time.Second, time.Millisecond)
+ return newTestTurnLoopWith(t, server, newFakeSummarizer())
}
-func newTestLoop(t *testing.T, server *ModelFake) *testLoop {
+// turnInputTexts returns the text of each user message of the input of call.
+func turnInputTexts(t *testing.T, call ModelFakeCall) []string {
t.Helper()
- return newTestLoopWith(t, server, newFakeSummarizer())
+ var body struct {
+ Input []struct {
+ Role string `json:"role"`
+ Content []struct {
+ Text string `json:"text"`
+ } `json:"content"`
+ } `json:"input"`
+ }
+
+ require.NoError(t, json.Unmarshal(call.raw, &body))
+
+ var texts []string
+ for _, item := range body.Input {
+ if item.Role != "user" {
+ continue
+ }
+
+ var text strings.Builder
+ for _, part := range item.Content {
+ text.WriteString(part.Text)
+ }
+
+ texts = append(texts, text.String())
+ }
+
+ return texts
}
-// newTestLoopWith returns a running loop on a new agent whose builds use
+// newTestTurnLoopWith returns a running loop on a new agent whose builds use
// summarizer and whose commands run in a temporary directory.
-func newTestLoopWith(t *testing.T, server *ModelFake, summarizer Summarizer) *testLoop {
+func newTestTurnLoopWith(t *testing.T, server *ModelFake, summarizer Summarizer) *TurnTestLoop {
t.Helper()
agent, err := openAgent(t.TempDir())
memory, err := openMemory(t.Context(), t.TempDir(), clock.Now, summarizer)
require.NoError(t, err)
- test := &testLoop{
+ test := &TurnTestLoop{
agent: agent,
memory: memory,
- events: &eventRecorder{},
+ events: &TurnEventRecorder{},
usagePath: filepath.Join(t.TempDir(), "usage.jsonl"),
}
client := newModelClient(server.URL, ModelAPIKey(modelTestKey), agent.CacheKey(), test.usagePath)
- test.loop, err = newLoop(agent, memory, client, clock.Now, test.events.Add)
+ test.loop, err = newTurnLoop(agent, memory, newTestSubagents(t), client, clock.Now, test.events.Add)
require.NoError(t, err)
ctx, cancel := context.WithCancel(t.Context())
done := make(chan error)
return test
}
-
-// inputTexts returns the text of each user message of the input of call.
-func inputTexts(t *testing.T, call ModelFakeCall) []string {
- t.Helper()
-
- var body struct {
- Input []struct {
- Role string `json:"role"`
- Content []struct {
- Text string `json:"text"`
- } `json:"content"`
- } `json:"input"`
- }
-
- require.NoError(t, json.Unmarshal(call.raw, &body))
-
- var texts []string
- for _, item := range body.Input {
- if item.Role != "user" {
- continue
- }
-
- var text strings.Builder
- for _, part := range item.Content {
- text.WriteString(part.Text)
- }
-
- texts = append(texts, text.String())
- }
-
- return texts
-}
projects / onechat / blobdiff