Check the socket path before the daemon writes

[onechat] / turn_test.go

diff --git a/turn_test.go b/turn_test.go
index 1b179406b72bb087fcfce2db11f39ccac1970006..f1295e938a54f25fc2b79ff3e8765c7cb360b43c 100644 (file)
--- a/turn_test.go
+++ b/turn_test.go
@@ -2,8 +2,10 @@ package main
 
 import (
        "context"
+       "encoding/json"
        "errors"
        "net/http"
+       "path/filepath"
        "strings"
        "sync"
        "testing"
@@ -57,6 +59,13 @@ 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 readUsage(t, test.usagePath) {
+               turns = append(turns, record.Turn)
+       }
+
+       require.Equal(t, []string{"first", "next"}, turns)
 }
 
 func TestFirstRequestHoldsTheViewTheStateAndTheMessage(t *testing.T) {
@@ -70,10 +79,10 @@ func TestFirstRequestHoldsTheViewTheStateAndTheMessage(t *testing.T) {
        test.events.WaitFor(t, "idle", 1)
 
        require.Equal(t, []string{
-               "<chat>\n0+1|user: an earlier message\n</chat>\n",
-               "Now: Thursday 2026-01-01 12:00 +00:00\n",
+               "<chat>\n0+1|user: an earlier message\n",
+               "</chat>\n\nNow: Thursday 2026-01-01 12:00 +00:00",
                "The new message.",
-       }, inputParts(t, server.Call(0)))
+       }, inputTexts(t, server.Call(0)))
 }
 
 func TestMessageDuringATurnJoinsTheNextRequest(t *testing.T) {
@@ -138,9 +147,9 @@ func TestMessageDuringTheFinalRequestStartsANewTurn(t *testing.T) {
        test.events.WaitFor(t, "idle", 2)
        require.Equal(t, 2, server.Calls())
 
-       parts := inputParts(t, server.Call(1))
-       require.Equal(t, "second", parts[len(parts)-1])
-       require.Contains(t, parts[0], "|reply: answer\n")
+       texts := inputTexts(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) {
@@ -161,7 +170,7 @@ func TestTurnWaitsForTheSummaries(t *testing.T) {
        close(summarizer.gate)
        test.events.WaitFor(t, "idle", 1)
        require.Equal(t, 1, server.Calls())
-       require.NotContains(t, inputParts(t, server.Call(0))[0], pending)
+       require.NotContains(t, inputTexts(t, server.Call(0))[0], pending)
 }
 
 func TestInterruptEndsTheTurn(t *testing.T) {
@@ -212,12 +221,36 @@ func TestFailedCallEndsTheTurnWithoutARetry(t *testing.T) {
        require.Contains(t, test.events.Last("error"), "HTTP 503")
 }
 
+func TestViewMessagesOnlyGrowBetweenTurns(t *testing.T) {
+       server := newFakeResponses(t)
+       test := newTestLoop(t, server)
+       for n, text := range []string{"one", "two", "three"} {
+               _, err := test.loop.Submit(text)
+               require.NoError(t, err)
+               test.events.WaitFor(t, "idle", n+1)
+       }
+
+       first := server.Call(1).body["input"].([]any)
+       second := server.Call(2).body["input"].([]any)
+       require.Len(t, first, 4)
+       require.Len(t, second, 5)
+       require.Equal(t, first[:2], second[:2])
+       require.Equal(t, []string{
+               "<chat>\n",
+               "0+1|user: one\n1+1|reply: a line\n",
+               "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)))
+}
+
 // testLoop is a loop that runs in the background of a test, with its parts.
 type testLoop struct {
-       agent  *Agent
-       memory *Memory
-       loop   *loop
-       events *eventRecorder
+       agent     *Agent
+       memory    *Memory
+       loop      *loop
+       events    *eventRecorder
+       usagePath string
 }
 
 // Log returns the logged messages as "kind: text".
@@ -314,12 +347,15 @@ func newTestLoopWith(t *testing.T, server *fakeResponses, summarizer Summarizer)
        require.NoError(t, err)
 
        test := &testLoop{
-               agent:  agent,
-               memory: memory,
-               events: &eventRecorder{},
+               agent:     agent,
+               memory:    memory,
+               events:    &eventRecorder{},
+               usagePath: filepath.Join(t.TempDir(), "usage.jsonl"),
        }
 
-       test.loop = newLoop(agent, memory, newTestClient(t, server), clock.Now, test.events.Add)
+       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)
        ctx, cancel := context.WithCancel(t.Context())
        done := make(chan error)
        go func() {
@@ -335,6 +371,38 @@ func newTestLoopWith(t *testing.T, server *fakeResponses, summarizer Summarizer)
        return test
 }
 
+// inputTexts returns the text of each user message of the input of call.
+func inputTexts(t *testing.T, call fakeCall) []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
+}
+
 func reasoningItem(id, encrypted string) map[string]any {
        return map[string]any{
                "type":              "reasoning",