git.giacomolli.uk - onechat/blob - daemon_test.go

   1 package main
   2
   3 import (
   4         "encoding/json"
   5         "io"
   6         "net"
   7         "net/http"
   8         "os"
   9         "path/filepath"
  10         "strings"
  11         "testing"
  12         "time"
  13
  14         "github.com/stretchr/testify/require"
  15 )
  16
  17 func TestNotificationReceiptIsPrivateToItsSubmittingSocket(t *testing.T) {
  18         server := newModelFake(t)
  19         socket := daemonStartTest(t, server)
  20         observer, err := net.Dial("unix", socket)
  21         require.NoError(t, err)
  22         require.NoError(t, observer.SetDeadline(time.Now().Add(10*time.Second)))
  23
  24         decoder := json.NewDecoder(observer)
  25
  26         var event Event
  27
  28         require.NoError(t, decoder.Decode(&event))
  29         require.Equal(t, "ready", event.Kind)
  30
  31         submitter, err := net.Dial("unix", socket)
  32         require.NoError(t, err)
  33         require.NoError(t, submitter.SetDeadline(time.Now().Add(10*time.Second)))
  34         require.NoError(t, json.NewEncoder(submitter).Encode(SocketRequest{
  35                 Type: "notify",
  36                 Notify: &NotifyInput{
  37                         Source: "check",
  38                         ID:     "1",
  39                         Text:   "A new result.",
  40                 },
  41         }))
  42
  43         accepted := false
  44         answer := json.NewDecoder(submitter)
  45         for !accepted {
  46                 require.NoError(t, answer.Decode(&event))
  47
  48                 accepted = event.Kind == "notify"
  49         }
  50
  51         require.Equal(t, "accepted", event.Status)
  52
  53         for {
  54                 require.NoError(t, decoder.Decode(&event))
  55                 require.NotEqual(t, "notify", event.Kind)
  56
  57                 if event.Kind == "idle" {
  58                         break
  59                 }
  60         }
  61
  62         require.NoError(t, submitter.Close())
  63         require.NoError(t, observer.Close())
  64 }
  65
  66 func TestNotificationSocketRejectsMissingOrInvalidData(t *testing.T) {
  67         server := newModelFake(t)
  68         socket := daemonStartTest(t, server)
  69         conn, err := net.Dial("unix", socket)
  70         require.NoError(t, err)
  71         require.NoError(t, conn.SetDeadline(time.Now().Add(10*time.Second)))
  72
  73         decoder := json.NewDecoder(conn)
  74         encoder := json.NewEncoder(conn)
  75
  76         var event Event
  77
  78         require.NoError(t, decoder.Decode(&event))
  79         require.Equal(t, "ready", event.Kind)
  80
  81         testCases := []*NotifyInput{
  82                 nil,
  83                 {
  84                         Source: "invalid source",
  85                         ID:     "1",
  86                         Text:   "data",
  87                 },
  88         }
  89
  90         for _, tc := range testCases {
  91                 require.NoError(t, encoder.Encode(SocketRequest{
  92                         Type:   "notify",
  93                         Notify: tc,
  94                 }))
  95                 require.NoError(t, decoder.Decode(&event))
  96                 require.Equal(t, "error", event.Kind)
  97                 require.NotContains(t, event.Text, "invalid source")
  98         }
  99
 100         _, err = io.WriteString(conn, `{"type":"notify","agent":"Garden","notify":{"source":"check","id":"1","text":"data"}}`+"\n")
 101         require.NoError(t, err)
 102         require.NoError(t, decoder.Decode(&event))
 103         require.Equal(t, "error", event.Kind)
 104
 105         require.Zero(t, server.Calls())
 106         require.NoError(t, conn.Close())
 107 }
 108
 109 func TestClientsSeeTheTurnAsItHappens(t *testing.T) {
 110         server := newModelFake(t)
 111         server.reply = func(w http.ResponseWriter, call ModelFakeCall) {
 112                 if call.number == 0 {
 113                         modelWriteEvents(w, modelCompletedEvent([]any{modelFunctionCallItem("fc_1", "call_1", "shell", `{"command":"echo hi"}`)}, 100, 0, 5))
 114
 115                         return
 116                 }
 117
 118                 modelWriteEvents(w, modelCompletedEvent([]any{modelMessageItem("It said hi.")}, 100, 0, 5))
 119         }
 120
 121         socket := daemonStartTest(t, server)
 122         first := terminalStartTestClient(t, socket)
 123         second := terminalStartTestClient(t, socket)
 124         first.WaitFor(t, "[connected to OneChat]")
 125         second.WaitFor(t, "[connected to OneChat]")
 126
 127         first.Type("Run echo hi.")
 128
 129         for _, client := range []*TerminalTestClient{first, second} {
 130                 client.WaitFor(t, "[done]")
 131                 require.Equal(t, "[connected to OneChat]\n[working]\n[tool] shell {\"command\":\"echo hi\"}\n[result] hi\nIt said hi.\n[done]\n", client.Output())
 132         }
 133
 134         first.Type(stopCommand)
 135         first.WaitFor(t, "[error] no turn runs")
 136         first.Type(stopCommand + " BlueFox")
 137         first.WaitFor(t, "[error] stop subagent: no subagent BlueFox runs")
 138         require.NotContains(t, second.Output(), "no turn runs")
 139         require.NoError(t, first.Close())
 140 }
 141
 142 func TestStopInterruptsTheTurn(t *testing.T) {
 143         server := newModelFake(t)
 144         arrived := make(chan struct{})
 145         release := make(chan struct{})
 146         t.Cleanup(func() {
 147                 close(release)
 148         })
 149
 150         server.reply = func(_ http.ResponseWriter, _ ModelFakeCall) {
 151                 close(arrived)
 152                 <-release
 153         }
 154
 155         socket := daemonStartTest(t, server)
 156         client := terminalStartTestClient(t, socket)
 157         client.Type("a long task")
 158         <-arrived
 159
 160         late := terminalStartTestClient(t, socket)
 161         late.WaitFor(t, "[connected to OneChat]\n[working]")
 162
 163         client.Type(stopCommand)
 164         client.WaitFor(t, "[error] interrupted\n[done]")
 165 }
 166
 167 func TestListenSocketReplacesAnOldSocketFile(t *testing.T) {
 168         path := filepath.Join(t.TempDir(), socketFileName)
 169         require.NoError(t, os.WriteFile(path, nil, 0o600))
 170
 171         listener, err := daemonListenSocket(path)
 172         require.NoError(t, err)
 173
 174         info, err := os.Stat(path)
 175         require.NoError(t, err)
 176         require.Equal(t, os.ModeSocket, info.Mode().Type())
 177         require.Equal(t, os.FileMode(0o600), info.Mode().Perm())
 178         require.NoError(t, listener.Close())
 179 }
 180
 181 func TestListenSocketRefusesALongPath(t *testing.T) {
 182         _, err := daemonListenSocket(filepath.Join(t.TempDir(), strings.Repeat("d", 100), socketFileName))
 183         require.ErrorContains(t, err, "set ONECHAT_DIR to a shorter path")
 184 }
 185
 186 func TestDaemonWritesNoFileForALongSocketPath(t *testing.T) {
 187         dir := filepath.Join(t.TempDir(), strings.Repeat("d", 100))
 188         t.Setenv("ONECHAT_DIR", dir)
 189
 190         err := daemon(t.Context(), io.Discard)
 191         require.ErrorContains(t, err, "set ONECHAT_DIR to a shorter path")
 192
 193         entries, err := os.ReadDir(dir)
 194         require.NoError(t, err)
 195         require.Empty(t, entries)
 196 }
 197
 198 func TestDaemonLogHasATimeStampOnlyOutsideTheJournal(t *testing.T) {
 199         testCases := []struct {
 200                 name    string
 201                 journal string
 202                 line    string
 203         }{
 204                 {
 205                         name:    "the journal adds the time itself",
 206                         journal: "8:12345",
 207                         line:    `^<6>onechat: the agent is ready\n$`,
 208                 },
 209                 {
 210                         name:    "a terminal gets the time in the line",
 211                         journal: "",
 212                         line:    `^\d{4}/\d\d/\d\d \d\d:\d\d:\d\d INFO onechat: the agent is ready\n$`,
 213                 },
 214         }
 215
 216         for _, tc := range testCases {
 217                 t.Run(tc.name, func(t *testing.T) {
 218                         t.Setenv("JOURNAL_STREAM", tc.journal)
 219
 220                         var out strings.Builder
 221
 222                         daemonLogger(&out, "onechat: ").Info("the agent is ready")
 223                         require.Regexp(t, tc.line, out.String())
 224                 })
 225         }
 226 }
 227
 228 // daemonStartTest serves a new agent on a socket in a temporary directory and
 229 // returns the socket path. The commands of the agent run in a temporary
 230 // directory.
 231 func daemonStartTest(t *testing.T, server *ModelFake) string {
 232         t.Helper()
 233
 234         return daemonStartTestWithBot(t, server, nil)
 235 }