Write private data archives with safe extraction

[onechat] / model_test.go

diff --git a/model_test.go b/model_test.go
index 16946a061dfe25447e34bded0128e079732d0523..90d0e93366d7226bf37e0bb795f48fbcd08ba749 100644 (file)
--- a/model_test.go
+++ b/model_test.go
@@ -85,13 +85,26 @@ func TestClientSendsTheSessionHeaderToChatGPT(t *testing.T) {
                        call := server.Call(0)
                        require.Equal(t, tc.want, call.header.Get("session_id"))
                        require.Equal(t, "agent-key", call.body["prompt_cache_key"])
                        call := server.Call(0)
                        require.Equal(t, tc.want, call.header.Get("session_id"))
                        require.Equal(t, "agent-key", call.body["prompt_cache_key"])

+
+                       // A subagent has its own key.
+                       request := modelTestRequest()
+                       request.Agent = "GreenOtter"
+                       _, err = client.Create(t.Context(), request)
+                       require.NoError(t, err)
+
+                       call = server.Call(1)
+                       if tc.want != "" {
+                               require.Equal(t, "agent-key-GreenOtter", call.header.Get("session_id"))
+                       }
+
+                       require.Equal(t, "agent-key-GreenOtter", call.body["prompt_cache_key"])

                })
        }
 }
 
 func TestClientReadsTheStream(t *testing.T) {
        server := newModelFake(t)
                })
        }
 }
 
 func TestClientReadsTheStream(t *testing.T) {
        server := newModelFake(t)

-       server.reply = func(w http.ResponseWriter, call ModelFakeCall) {
+       server.reply = func(w http.ResponseWriter, _ ModelFakeCall) {

                modelWriteEvents(w,
                        map[string]any{"type": "response.created", "response": map[string]any{}},
                        map[string]any{"type": "response.output_item.done", "item": map[string]any{"type": "reasoning", "encrypted_content": "opaque"}},
                modelWriteEvents(w,
                        map[string]any{"type": "response.created", "response": map[string]any{}},
                        map[string]any{"type": "response.output_item.done", "item": map[string]any{"type": "reasoning", "encrypted_content": "opaque"}},


@@ -116,7 +129,7 @@ func TestClientReadsTheStream(t *testing.T) {
 
 func TestClientTakesTheOutputOfTheCompletedResponse(t *testing.T) {
        server := newModelFake(t)
 
 func TestClientTakesTheOutputOfTheCompletedResponse(t *testing.T) {
        server := newModelFake(t)

-       server.reply = func(w http.ResponseWriter, call ModelFakeCall) {
+       server.reply = func(w http.ResponseWriter, _ ModelFakeCall) {

                modelWriteEvents(w, modelCompletedEvent([]any{modelMessageItem("only here")}, 10, 0, 2))
        }
 
                modelWriteEvents(w, modelCompletedEvent([]any{modelMessageItem("only here")}, 10, 0, 2))
        }
 


@@ -132,8 +145,10 @@ func TestClientRecordsEachCall(t *testing.T) {
                w.Header().Set("X-Codex-Plan-Type", "plus")
                w.Header().Set("X-Other", "not quota")
                w.Header().Set("X-Codex-Turn-State", "opaque state")
                w.Header().Set("X-Codex-Plan-Type", "plus")
                w.Header().Set("X-Other", "not quota")
                w.Header().Set("X-Codex-Turn-State", "opaque state")

+

                if call.number == 1 {
                        w.WriteHeader(http.StatusTooManyRequests)
                if call.number == 1 {
                        w.WriteHeader(http.StatusTooManyRequests)

+

                        _, _ = io.WriteString(w, `{"detail": "slow down"}`)
 
                        return
                        _, _ = io.WriteString(w, `{"detail": "slow down"}`)
 
                        return


@@ -150,7 +165,7 @@ func TestClientRecordsEachCall(t *testing.T) {
        require.NoError(t, err)
        require.NotContains(t, server.Call(0).body, "node")
        require.NotContains(t, string(server.Call(0).raw), "[2,5]")
        require.NoError(t, err)
        require.NotContains(t, server.Call(0).body, "node")
        require.NotContains(t, string(server.Call(0).raw), "[2,5]")

-       require.NotContains(t, string(server.Call(0).raw), "GreenOtter")
+       require.NotContains(t, server.Call(0).body, "agent")

 
        _, err = client.Create(t.Context(), modelTestRequest())
        require.ErrorContains(t, err, "HTTP 429")
 
        _, err = client.Create(t.Context(), modelTestRequest())
        require.ErrorContains(t, err, "HTTP 429")


@@ -163,6 +178,7 @@ func TestClientRecordsEachCall(t *testing.T) {
                "x-codex-primary-used-percent": "12",
                "x-codex-plan-type":            "plus",
        }
                "x-codex-primary-used-percent": "12",
                "x-codex-plan-type":            "plus",
        }

+

        require.Equal(t, "gpt-test", records[0].Model)
        require.Equal(t, http.StatusOK, records[0].Status)
        require.Equal(t, 500, records[0].InputTokens)
        require.Equal(t, "gpt-test", records[0].Model)
        require.Equal(t, http.StatusOK, records[0].Status)
        require.Equal(t, 500, records[0].InputTokens)


@@ -200,11 +216,13 @@ func TestClientRefusesCallsOverTheLimit(t *testing.T) {
 
        for range 2 {
                require.False(t, client.LimitReached())
 
        for range 2 {
                require.False(t, client.LimitReached())

+

                _, err := client.Create(t.Context(), modelTestRequest())
                require.NoError(t, err)
        }
 
        require.True(t, client.LimitReached())
                _, err := client.Create(t.Context(), modelTestRequest())
                require.NoError(t, err)
        }
 
        require.True(t, client.LimitReached())

+

        _, err := client.Create(t.Context(), modelTestRequest())
        require.ErrorIs(t, err, errModelCallLimit)
        require.Equal(t, 2, server.Calls())
        _, err := client.Create(t.Context(), modelTestRequest())
        require.ErrorIs(t, err, errModelCallLimit)
        require.Equal(t, 2, server.Calls())


@@ -242,7 +260,7 @@ func TestClientFailsWhenTheResponseFails(t *testing.T) {
        for _, tc := range testCases {
                t.Run(tc.name, func(t *testing.T) {
                        server := newModelFake(t)
        for _, tc := range testCases {
                t.Run(tc.name, func(t *testing.T) {
                        server := newModelFake(t)

-                       server.reply = func(w http.ResponseWriter, call ModelFakeCall) {
+                       server.reply = func(w http.ResponseWriter, _ ModelFakeCall) {

                                modelWriteEvents(w, tc.events...)
                        }
 
                                modelWriteEvents(w, tc.events...)
                        }