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

   1 package main
   2
   3 import (
   4         "bufio"
   5         "encoding/json"
   6         "fmt"
   7         "io"
   8         "net/http"
   9         "net/http/httptest"
  10         "os"
  11         "path/filepath"
  12         "sync"
  13         "testing"
  14         "time"
  15
  16         "github.com/stretchr/testify/require"
  17 )
  18
  19 // testKey is a fake API key.
  20 const testKey = "sk-test-not-a-real-key"
  21
  22 func TestClientSendsTheFixedRequestFields(t *testing.T) {
  23         server := newFakeResponses(t)
  24         client := newTestClient(t, server)
  25
  26         _, err := client.Create(t.Context(), Request{
  27                 Model:        "gpt-test",
  28                 Effort:       "high",
  29                 Instructions: "You are a test.",
  30                 Tools: []Tool{{
  31                         Type:       "function",
  32                         Name:       "date",
  33                         Parameters: map[string]any{"type": "object"},
  34                 }},
  35                 Input: []any{userMessage("<chat>\n</chat>\n", "hello")},
  36         })
  37         require.NoError(t, err)
  38
  39         call := server.Call(0)
  40         require.Equal(t, "Bearer "+testKey, call.header.Get("Authorization"))
  41         require.Equal(t, "text/event-stream", call.header.Get("Accept"))
  42         require.Equal(t, "application/json", call.header.Get("Content-Type"))
  43
  44         body := call.body
  45         require.Equal(t, "gpt-test", body["model"])
  46         require.Equal(t, "You are a test.", body["instructions"])
  47         require.Equal(t, false, body["store"])
  48         require.Equal(t, true, body["stream"])
  49         require.Equal(t, []any{"reasoning.encrypted_content"}, body["include"])
  50         require.Equal(t, "agent-key", body["prompt_cache_key"])
  51         require.Equal(t, map[string]any{"effort": "high"}, body["reasoning"])
  52         require.NotContains(t, body, "max_output_tokens")
  53         require.NotContains(t, body, "metadata")
  54         require.Equal(t, []any{map[string]any{
  55                 "role": "user",
  56                 "content": []any{
  57                         map[string]any{"type": "input_text", "text": "<chat>\n</chat>\n"},
  58                         map[string]any{"type": "input_text", "text": "hello"},
  59                 },
  60         }}, body["input"])
  61         require.Len(t, body["tools"], 1)
  62 }
  63
  64 func TestClientSendsTheSessionHeaderToChatGPT(t *testing.T) {
  65         login := newFakeAuth(t)
  66         auth := newTestAuth(t, login)
  67         writeTestTokens(t, auth, login.token(time.Hour), "refresh-0")
  68
  69         testCases := []struct {
  70                 name string
  71                 auth authorizer
  72                 want string
  73         }{
  74                 {
  75                         name: "ChatGPT backend",
  76                         auth: auth,
  77                         want: "agent-key",
  78                 },
  79                 {
  80                         name: "OpenAI API",
  81                         auth: apiKey(testKey),
  82                         want: "",
  83                 },
  84         }
  85
  86         for _, tc := range testCases {
  87                 t.Run(tc.name, func(t *testing.T) {
  88                         server := newFakeResponses(t)
  89                         client := newClient(server.URL, tc.auth, "agent-key", filepath.Join(t.TempDir(), "usage.jsonl"))
  90                         _, err := client.Create(t.Context(), testRequest())
  91                         require.NoError(t, err)
  92
  93                         call := server.Call(0)
  94                         require.Equal(t, tc.want, call.header.Get("session_id"))
  95                         require.Equal(t, "agent-key", call.body["prompt_cache_key"])
  96                 })
  97         }
  98 }
  99
 100 func TestClientReadsTheStream(t *testing.T) {
 101         server := newFakeResponses(t)
 102         server.reply = func(w http.ResponseWriter, call fakeCall) {
 103                 writeEvents(w,
 104                         map[string]any{"type": "response.created", "response": map[string]any{}},
 105                         map[string]any{"type": "response.output_item.done", "item": map[string]any{"type": "reasoning", "encrypted_content": "opaque"}},
 106                         map[string]any{"type": "response.output_text.delta", "delta": "Hel"},
 107                         map[string]any{"type": "response.output_item.done", "item": messageItem("Hello")},
 108                         map[string]any{"type": "response.output_item.done", "item": messageItem(" world")},
 109                         completedEvent(nil, 1200, 1024, 30),
 110                 )
 111         }
 112
 113         response, err := newTestClient(t, server).Create(t.Context(), testRequest())
 114         require.NoError(t, err)
 115         require.Equal(t, "Hello world", response.Text)
 116         require.Len(t, response.Output, 3)
 117         require.JSONEq(t, `{"type": "reasoning", "encrypted_content": "opaque"}`, string(response.Output[0]))
 118         require.Equal(t, Usage{
 119                 Input:  1200,
 120                 Cached: 1024,
 121                 Output: 30,
 122         }, response.Usage)
 123 }
 124
 125 func TestClientTakesTheOutputOfTheCompletedResponse(t *testing.T) {
 126         server := newFakeResponses(t)
 127         server.reply = func(w http.ResponseWriter, call fakeCall) {
 128                 writeEvents(w, completedEvent([]any{messageItem("only here")}, 10, 0, 2))
 129         }
 130
 131         response, err := newTestClient(t, server).Create(t.Context(), testRequest())
 132         require.NoError(t, err)
 133         require.Equal(t, "only here", response.Text)
 134 }
 135
 136 func TestClientRecordsEachCall(t *testing.T) {
 137         server := newFakeResponses(t)
 138         server.reply = func(w http.ResponseWriter, call fakeCall) {
 139                 w.Header().Set("X-Codex-Primary-Used-Percent", "12")
 140                 w.Header().Set("X-Codex-Plan-Type", "plus")
 141                 w.Header().Set("X-Other", "not quota")
 142                 w.Header().Set("X-Codex-Turn-State", "opaque state")
 143                 if call.number == 1 {
 144                         w.WriteHeader(http.StatusTooManyRequests)
 145                         _, _ = io.WriteString(w, `{"detail": "slow down"}`)
 146
 147                         return
 148                 }
 149
 150                 writeEvents(w, completedEvent([]any{messageItem("ok")}, 500, 400, 7))
 151         }
 152
 153         client := newTestClient(t, server)
 154         request := testRequest()
 155         request.Node = &nodeKey{2, 5}
 156         _, err := client.Create(t.Context(), request)
 157         require.NoError(t, err)
 158         require.NotContains(t, server.Call(0).body, "node")
 159         require.NotContains(t, string(server.Call(0).raw), "[2,5]")
 160
 161         _, err = client.Create(t.Context(), testRequest())
 162         require.ErrorContains(t, err, "HTTP 429")
 163         require.ErrorContains(t, err, "slow down")
 164
 165         records := readUsage(t, client.usage.path)
 166         require.Len(t, records, 2)
 167
 168         quota := map[string]string{
 169                 "x-codex-primary-used-percent": "12",
 170                 "x-codex-plan-type":            "plus",
 171         }
 172         require.Equal(t, "gpt-test", records[0].Model)
 173         require.Equal(t, http.StatusOK, records[0].Status)
 174         require.Equal(t, 500, records[0].InputTokens)
 175         require.Equal(t, 400, records[0].CachedTokens)
 176         require.Equal(t, 7, records[0].OutputTokens)
 177         require.Equal(t, quota, records[0].Quota)
 178         require.Equal(t, &[2]int{2, 5}, records[0].Node)
 179         require.Equal(t, len("ok"), records[0].TextBytes)
 180         require.Greater(t, records[0].Seconds, 0.0)
 181         require.Empty(t, records[0].Error)
 182         require.NotEmpty(t, records[0].Date)
 183
 184         require.Nil(t, records[1].Node)
 185         require.Zero(t, records[1].TextBytes)
 186
 187         require.Equal(t, http.StatusTooManyRequests, records[1].Status)
 188         require.Equal(t, quota, records[1].Quota)
 189         require.Contains(t, records[1].Error, "HTTP 429")
 190
 191         data, err := os.ReadFile(client.usage.path)
 192         require.NoError(t, err)
 193         require.NotContains(t, string(data), testKey)
 194
 195         info, err := os.Stat(client.usage.path)
 196         require.NoError(t, err)
 197         require.Equal(t, os.FileMode(0o600), info.Mode().Perm())
 198 }
 199
 200 func TestClientStopsAtTheFirstOutputItem(t *testing.T) {
 201         server := newFakeResponses(t)
 202         server.reply = func(w http.ResponseWriter, call fakeCall) {
 203                 writeEvents(w,
 204                         map[string]any{"type": "response.created"},
 205                         map[string]any{"type": "response.output_item.added", "item": messageItem("")},
 206                 )
 207         }
 208
 209         client := newTestClient(t, server)
 210         request := testRequest()
 211         request.StopAtOutput = true
 212         request.Turn = "warmup"
 213         response, err := client.Create(t.Context(), request)
 214         require.NoError(t, err)
 215         require.Empty(t, response.Output)
 216
 217         request.StopAtOutput = false
 218         _, err = client.Create(t.Context(), request)
 219         require.ErrorContains(t, err, "event stream ended before the response completed")
 220 }
 221
 222 func TestClientRefusesCallsOverTheLimit(t *testing.T) {
 223         server := newFakeResponses(t)
 224         client := newTestClient(t, server)
 225         client.LimitCalls(2)
 226
 227         for range 2 {
 228                 require.False(t, client.LimitReached())
 229                 _, err := client.Create(t.Context(), testRequest())
 230                 require.NoError(t, err)
 231         }
 232
 233         require.True(t, client.LimitReached())
 234         _, err := client.Create(t.Context(), testRequest())
 235         require.ErrorIs(t, err, errCallLimit)
 236         require.Equal(t, 2, server.Calls())
 237         require.Len(t, readUsage(t, client.usage.path), 2)
 238 }
 239
 240 func TestClientFailsWhenTheResponseFails(t *testing.T) {
 241         testCases := []struct {
 242                 name   string
 243                 events []any
 244                 want   string
 245         }{
 246                 {
 247                         name:   "failed response",
 248                         events: []any{map[string]any{"type": "response.failed", "response": map[string]any{"error": map[string]any{"code": "server_error", "message": "busy"}}}},
 249                         want:   "server_error: busy",
 250                 },
 251                 {
 252                         name:   "incomplete response",
 253                         events: []any{map[string]any{"type": "response.incomplete", "response": map[string]any{"incomplete_details": map[string]any{"reason": "content_filter"}}}},
 254                         want:   "content_filter",
 255                 },
 256                 {
 257                         name:   "error event",
 258                         events: []any{map[string]any{"type": "error", "code": "rate_limit", "message": "too many"}},
 259                         want:   "rate_limit: too many",
 260                 },
 261                 {
 262                         name:   "stream ends early",
 263                         events: []any{map[string]any{"type": "response.output_item.done", "item": messageItem("cut")}},
 264                         want:   "ended before the response completed",
 265                 },
 266         }
 267
 268         for _, tc := range testCases {
 269                 t.Run(tc.name, func(t *testing.T) {
 270                         server := newFakeResponses(t)
 271                         server.reply = func(w http.ResponseWriter, call fakeCall) {
 272                                 writeEvents(w, tc.events...)
 273                         }
 274
 275                         client := newTestClient(t, server)
 276                         _, err := client.Create(t.Context(), testRequest())
 277                         require.ErrorContains(t, err, tc.want)
 278
 279                         records := readUsage(t, client.usage.path)
 280                         require.Len(t, records, 1)
 281                         require.Contains(t, records[0].Error, tc.want)
 282                 })
 283         }
 284 }
 285
 286 // fakeResponses is an httptest Responses endpoint. It keeps each call, and
 287 // reply writes the response. The default reply is one short message.
 288 type fakeResponses struct {
 289         *httptest.Server
 290         mutex sync.Mutex
 291         calls []fakeCall
 292         reply func(http.ResponseWriter, fakeCall)
 293 }
 294
 295 // fakeCall is one call to a fake endpoint, numbered from 0.
 296 type fakeCall struct {
 297         number int
 298         header http.Header
 299         raw    []byte
 300         body   map[string]any
 301 }
 302
 303 func newFakeResponses(t *testing.T) *fakeResponses {
 304         t.Helper()
 305
 306         f := &fakeResponses{
 307                 reply: func(w http.ResponseWriter, call fakeCall) {
 308                         writeEvents(w, completedEvent([]any{messageItem("a line")}, 100, 0, 5))
 309                 },
 310         }
 311
 312         f.Server = httptest.NewServer(http.HandlerFunc(f.serve))
 313         t.Cleanup(f.Close)
 314
 315         return f
 316 }
 317
 318 func (f *fakeResponses) serve(w http.ResponseWriter, r *http.Request) {
 319         raw, err := io.ReadAll(r.Body)
 320         if err != nil {
 321                 http.Error(w, err.Error(), http.StatusBadRequest)
 322                 return
 323         }
 324
 325         call := fakeCall{
 326                 header: r.Header.Clone(),
 327                 raw:    raw,
 328         }
 329
 330         err = json.Unmarshal(raw, &call.body)
 331         if err != nil {
 332                 http.Error(w, err.Error(), http.StatusBadRequest)
 333                 return
 334         }
 335
 336         f.mutex.Lock()
 337         call.number = len(f.calls)
 338         f.calls = append(f.calls, call)
 339         reply := f.reply
 340         f.mutex.Unlock()
 341
 342         reply(w, call)
 343 }
 344
 345 // Call returns call number n.
 346 func (f *fakeResponses) Call(n int) fakeCall {
 347         f.mutex.Lock()
 348         defer f.mutex.Unlock()
 349
 350         return f.calls[n]
 351 }
 352
 353 // Calls returns the number of calls.
 354 func (f *fakeResponses) Calls() int {
 355         f.mutex.Lock()
 356         defer f.mutex.Unlock()
 357
 358         return len(f.calls)
 359 }
 360
 361 func newTestClient(t *testing.T, server *fakeResponses) *Client {
 362         t.Helper()
 363
 364         return newClient(server.URL, apiKey(testKey), "agent-key", filepath.Join(t.TempDir(), "usage.jsonl"))
 365 }
 366
 367 func testRequest() Request {
 368         return Request{
 369                 Model:  "gpt-test",
 370                 Effort: "low",
 371                 Input:  []any{userMessage("hello")},
 372         }
 373 }
 374
 375 // writeEvents writes events as a server-sent event stream.
 376 func writeEvents(w http.ResponseWriter, events ...any) {
 377         w.Header().Set("Content-Type", "text/event-stream")
 378         for _, event := range events {
 379                 data, err := json.Marshal(event)
 380                 if err != nil {
 381                         panic(err)
 382                 }
 383
 384                 _, err = fmt.Fprintf(w, "event: %s\ndata: %s\n\n", event.(map[string]any)["type"], data)
 385                 if err != nil {
 386                         panic(err)
 387                 }
 388         }
 389 }
 390
 391 func messageItem(text string) map[string]any {
 392         return map[string]any{
 393                 "type": "message",
 394                 "role": "assistant",
 395                 "content": []any{
 396                         map[string]any{"type": "output_text", "text": text},
 397                 },
 398         }
 399 }
 400
 401 func completedEvent(output []any, input, cached, out int) map[string]any {
 402         if output == nil {
 403                 output = []any{}
 404         }
 405
 406         return map[string]any{
 407                 "type": "response.completed",
 408                 "response": map[string]any{
 409                         "output": output,
 410                         "usage": map[string]any{
 411                                 "input_tokens":         input,
 412                                 "input_tokens_details": map[string]any{"cached_tokens": cached},
 413                                 "output_tokens":        out,
 414                         },
 415                 },
 416         }
 417 }
 418
 419 func readUsage(t *testing.T, path string) []usageRecord {
 420         t.Helper()
 421
 422         file, err := os.Open(path)
 423         require.NoError(t, err)
 424
 425         defer func() {
 426                 require.NoError(t, file.Close())
 427         }()
 428
 429         var records []usageRecord
 430         scanner := bufio.NewScanner(file)
 431         for scanner.Scan() {
 432                 var record usageRecord
 433                 require.NoError(t, json.Unmarshal(scanner.Bytes(), &record))
 434                 records = append(records, record)
 435         }
 436
 437         require.NoError(t, scanner.Err())
 438
 439         return records
 440 }