| package executor |
|
|
| import ( |
| "context" |
| "net/http" |
| "net/http/httptest" |
| "strings" |
| "testing" |
|
|
| "github.com/gin-gonic/gin" |
| "github.com/tidwall/gjson" |
| ) |
|
|
| func TestNormalizeCodexRequestBody(t *testing.T) { |
| input := []byte(`{"previous_response_id":"a","prompt_cache_retention":"24h","safety_identifier":"id"}`) |
|
|
| got, err := normalizeCodexRequestBody(input, "gpt-5", true) |
| if err != nil { |
| t.Fatalf("normalizeCodexRequestBody returned error: %v", err) |
| } |
|
|
| if model := gjson.GetBytes(got, "model").String(); model != "gpt-5" { |
| t.Fatalf("expected model gpt-5, got %q", model) |
| } |
| if stream := gjson.GetBytes(got, "stream"); !stream.Exists() || !stream.Bool() { |
| t.Fatalf("expected stream=true, got %s", stream.Raw) |
| } |
| if gjson.GetBytes(got, "instructions").String() != "" { |
| t.Fatalf("expected instructions to default to empty string") |
| } |
| if gjson.GetBytes(got, "previous_response_id").Exists() { |
| t.Fatalf("expected previous_response_id to be removed") |
| } |
| if gjson.GetBytes(got, "prompt_cache_retention").Exists() { |
| t.Fatalf("expected prompt_cache_retention to be removed") |
| } |
| if gjson.GetBytes(got, "safety_identifier").Exists() { |
| t.Fatalf("expected safety_identifier to be removed") |
| } |
| } |
|
|
| func TestNormalizeCodexRequestBody_MapsReasoningEffortAlias(t *testing.T) { |
| input := []byte(`{"reasoning_effort":"high"}`) |
|
|
| got, err := normalizeCodexRequestBody(input, "gpt-5", true) |
| if err != nil { |
| t.Fatalf("normalizeCodexRequestBody returned error: %v", err) |
| } |
|
|
| if gotEffort := gjson.GetBytes(got, "reasoning.effort").String(); gotEffort != "high" { |
| t.Fatalf("reasoning.effort = %q, want %q", gotEffort, "high") |
| } |
| if gjson.GetBytes(got, "reasoning_effort").Exists() { |
| t.Fatalf("expected reasoning_effort alias to be removed") |
| } |
| } |
|
|
| func TestNormalizeCodexRequestBody_AutoInjectsReasoningProfile(t *testing.T) { |
| input := []byte(`{ |
| "reasoning_effort":"high", |
| "instructions":"Base instructions", |
| "_cliproxy":{"reasoning_profile":"deep_engineering"} |
| }`) |
|
|
| got, err := normalizeCodexRequestBody(input, "gpt-5", true) |
| if err != nil { |
| t.Fatalf("normalizeCodexRequestBody returned error: %v", err) |
| } |
|
|
| instructions := gjson.GetBytes(got, "instructions").String() |
| if instructions == "" { |
| t.Fatal("instructions should not be empty") |
| } |
| if instructions == "Base instructions" { |
| t.Fatalf("expected reasoning profile to append instructions") |
| } |
| if !containsAll(instructions, "Base instructions", "Architectural/Design Rationale", "Edge Cases and Failure Prevention", "Production-Ready Implementation") { |
| t.Fatalf("instructions missing expected scaffold: %q", instructions) |
| } |
| if !containsAll(instructions, "Override Brevity", "Library & Framework Discipline", "Response format (normal mode)") { |
| t.Fatalf("instructions missing deep engineering standards block: %q", instructions) |
| } |
| if gjson.GetBytes(got, "_cliproxy").Exists() { |
| t.Fatalf("expected local _cliproxy controls to be stripped") |
| } |
| } |
|
|
| func TestNormalizeCodexRequestBody_DoesNotInjectReasoningProfileWhenThinkingDisabled(t *testing.T) { |
| input := []byte(`{ |
| "reasoning_effort":"none", |
| "instructions":"Base instructions", |
| "_cliproxy":{"reasoning_profile":"deep_engineering"} |
| }`) |
|
|
| got, err := normalizeCodexRequestBody(input, "gpt-5", true) |
| if err != nil { |
| t.Fatalf("normalizeCodexRequestBody returned error: %v", err) |
| } |
|
|
| if instructions := gjson.GetBytes(got, "instructions").String(); instructions != "Base instructions" { |
| t.Fatalf("instructions = %q, want %q", instructions, "Base instructions") |
| } |
| if gjson.GetBytes(got, "_cliproxy").Exists() { |
| t.Fatalf("expected local _cliproxy controls to be stripped") |
| } |
| } |
|
|
| func TestNormalizeCodexRequestBody_IncludesCustomReasoningPrompt(t *testing.T) { |
| input := []byte(`{ |
| "reasoning":{"effort":"medium"}, |
| "_cliproxy":{"reasoning_prompt":"Use strict WCAG AAA and include an edge-case checklist."} |
| }`) |
|
|
| got, err := normalizeCodexRequestBody(input, "gpt-5", true) |
| if err != nil { |
| t.Fatalf("normalizeCodexRequestBody returned error: %v", err) |
| } |
|
|
| instructions := gjson.GetBytes(got, "instructions").String() |
| if !containsAll(instructions, "strict WCAG AAA", "edge-case checklist") { |
| t.Fatalf("custom reasoning prompt not injected: %q", instructions) |
| } |
| } |
|
|
| func TestNormalizeCodexRequestBody_StripsAgentModeControls(t *testing.T) { |
| input := []byte(`{ |
| "agent_mode":"planner-reviewer", |
| "_cliproxy":{"agent_mode":"planner-reviewer"}, |
| "instructions":"hello" |
| }`) |
|
|
| got, err := normalizeCodexRequestBody(input, "gpt-5", true) |
| if err != nil { |
| t.Fatalf("normalizeCodexRequestBody returned error: %v", err) |
| } |
| if gjson.GetBytes(got, "agent_mode").Exists() { |
| t.Fatalf("expected agent_mode to be stripped") |
| } |
| if gjson.GetBytes(got, "_cliproxy").Exists() { |
| t.Fatalf("expected _cliproxy to be stripped") |
| } |
| } |
|
|
| func TestCodexProviderApplyHeaders_ForwardsCodexHintHeaders(t *testing.T) { |
| gin.SetMode(gin.TestMode) |
| rec := httptest.NewRecorder() |
| c, _ := gin.CreateTestContext(rec) |
| c.Request = httptest.NewRequest(http.MethodPost, "/", nil) |
| c.Request.Header.Set("x-codex-turn-state", "turn-state") |
| c.Request.Header.Set("x-codex-turn-metadata", "turn-meta") |
| c.Request.Header.Set("x-responsesapi-include-timing-metrics", "1") |
|
|
| req, err := http.NewRequestWithContext(contextWithGinForTest(c), http.MethodPost, "https://example.com", nil) |
| if err != nil { |
| t.Fatalf("new request: %v", err) |
| } |
|
|
| p := NewCodexProvider(nil) |
| p.ApplyHeaders(req, nil, "token", true) |
|
|
| if got := req.Header.Get("x-codex-turn-state"); got != "turn-state" { |
| t.Fatalf("x-codex-turn-state = %q, want %q", got, "turn-state") |
| } |
| if got := req.Header.Get("x-codex-turn-metadata"); got != "turn-meta" { |
| t.Fatalf("x-codex-turn-metadata = %q, want %q", got, "turn-meta") |
| } |
| if got := req.Header.Get("x-responsesapi-include-timing-metrics"); got != "1" { |
| t.Fatalf("x-responsesapi-include-timing-metrics = %q, want %q", got, "1") |
| } |
| if got := req.Header.Get("Accept"); got != "text/event-stream" { |
| t.Fatalf("Accept = %q, want %q", got, "text/event-stream") |
| } |
| } |
|
|
| func TestCodexCompletedEventPayload(t *testing.T) { |
| tests := []struct { |
| name string |
| data []byte |
| want bool |
| }{ |
| { |
| name: "valid completed event", |
| data: []byte("data: {\"type\":\"response.completed\",\"response\":{}}"), |
| want: true, |
| }, |
| { |
| name: "non-completed event", |
| data: []byte("data: {\"type\":\"response.in_progress\"}"), |
| want: false, |
| }, |
| { |
| name: "non-sse payload", |
| data: []byte(`{"type":"response.completed"}`), |
| want: false, |
| }, |
| } |
|
|
| for _, tt := range tests { |
| t.Run(tt.name, func(t *testing.T) { |
| payload, ok := codexCompletedEventPayload(tt.data) |
| if ok != tt.want { |
| t.Fatalf("expected ok=%v, got %v", tt.want, ok) |
| } |
| if ok && gjson.GetBytes(payload, "type").String() != "response.completed" { |
| t.Fatalf("expected response.completed payload, got %s", string(payload)) |
| } |
| }) |
| } |
| } |
|
|
| func TestBuildCodexReasoningProfilePrompt_DeepEngineeringIncludesLanguageStandards(t *testing.T) { |
| got := buildCodexReasoningProfilePrompt("deep_engineering", "") |
| if !containsAll(got, "Language-specific awareness", "Shell/Bash", "SQL: Always parameterize queries") { |
| t.Fatalf("deep engineering prompt missing language-specific standards: %q", got) |
| } |
| } |
|
|
| func contextWithGinForTest(c *gin.Context) context.Context { |
| if c == nil { |
| return context.Background() |
| } |
| return context.WithValue(context.Background(), "gin", c) |
| } |
|
|
| func containsAll(s string, subs ...string) bool { |
| for _, sub := range subs { |
| if !strings.Contains(s, sub) { |
| return false |
| } |
| } |
| return true |
| } |
|
|
