exec_test.go

package codex

import (
	"context"
	"os"
	"path/filepath"
	"reflect"
	"strings"
	"testing"
)

func TestSerializeConfigOverrides(t *testing.T) {
	t.Parallel()

	overrides, err := serializeConfigOverrides(map[string]any{
		"approval_policy":         "never",
		"sandbox_workspace_write": map[string]any{"network_access": true},
		"retry_budget":            3,
		"tool_rules":              map[string]any{"allow": []any{"git status", "git diff"}},
	})
	if err != nil {
		t.Fatalf("serializeConfigOverrides() error = %v", err)
	}

	expected := []string{
		`approval_policy="never"`,
		`sandbox_workspace_write.network_access=true`,
		`retry_budget=3`,
		`tool_rules.allow=["git status", "git diff"]`,
	}
	if !reflect.DeepEqual(overrides, expected) {
		t.Fatalf("serializeConfigOverrides() = %#v, want %#v", overrides, expected)
	}
}

func TestBuildCommandArgsResumeBeforeImages(t *testing.T) {
	t.Parallel()

	exec := NewCodexExec("codex", nil, nil)
	args, err := exec.buildCommandArgs(CodexExecArgs{
		Input:    "hi",
		ThreadID: "thread-id",
		Images:   []string{"img.png"},
	})
	if err != nil {
		t.Fatalf("buildCommandArgs() error = %v", err)
	}

	resumeIndex := indexOf(args, "resume")
	imageIndex := indexOf(args, "--image")
	if resumeIndex == -1 || imageIndex == -1 || resumeIndex >= imageIndex {
		t.Fatalf("resume/image ordering incorrect: %#v", args)
	}
}

func TestBuildEnvOverrideDoesNotLeak(t *testing.T) {
	t.Setenv("CODEX_ENV_SHOULD_NOT_LEAK", "leak")
	env := buildEnv(map[string]string{"CUSTOM_ENV": "custom"}, "http://example.com", "test")
	joined := strings.Join(env, "\n")

	if strings.Contains(joined, "CODEX_ENV_SHOULD_NOT_LEAK=leak") {
		t.Fatalf("buildEnv() leaked parent process env: %s", joined)
	}
	if !strings.Contains(joined, "CUSTOM_ENV=custom") {
		t.Fatalf("buildEnv() missing custom env: %s", joined)
	}
	if !strings.Contains(joined, "OPENAI_BASE_URL=http://example.com") {
		t.Fatalf("buildEnv() missing base url: %s", joined)
	}
	if !strings.Contains(joined, "CODEX_API_KEY=test") {
		t.Fatalf("buildEnv() missing api key: %s", joined)
	}
	if !strings.Contains(joined, internalOriginatorEnv+"="+goSDKOriginator) {
		t.Fatalf("buildEnv() missing originator: %s", joined)
	}
}

func TestExecRunAndThreadRun(t *testing.T) {
	t.Parallel()

	fixture := newFixtureCodex(t, `#!/bin/sh
set -eu
for arg in "$@"; do printf '%s\n' "$arg"; done > "$ARGS_FILE"
env | sort > "$ENV_FILE"
cat > "$STDIN_FILE"
schema_path=""
prev=""
for arg in "$@"; do
  if [ "$prev" = "--output-schema" ]; then
    schema_path="$arg"
    break
  fi
  prev="$arg"
done
if [ -n "$schema_path" ] && [ -f "$schema_path" ]; then
  printf '%s' "present" > "$SCHEMA_CHECK_FILE"
fi
printf '%s\n' '{"type":"thread.started","thread_id":"thread_123"}'
printf '%s\n' '{"type":"turn.started"}'
printf '%s\n' '{"type":"item.completed","item":{"id":"item_1","type":"agent_message","text":"Hi!"}}'
printf '%s\n' '{"type":"turn.completed","usage":{"input_tokens":42,"cached_input_tokens":12,"output_tokens":5}}'
`)

	client := New(CodexOptions{
		CodexPathOverride: fixture.script,
		BaseURL:           "http://example.com",
		APIKey:            "test",
		Config: map[string]any{
			"approval_policy": "never",
		},
		Env: map[string]string{
			"ARGS_FILE":         fixture.argsFile,
			"ENV_FILE":          fixture.envFile,
			"STDIN_FILE":        fixture.stdinFile,
			"SCHEMA_CHECK_FILE": fixture.schemaCheckFile,
		},
	})

	thread := client.StartThread(ThreadOptions{
		Model:            "gpt-test-1",
		SandboxMode:      SandboxWorkspaceWrite,
		ApprovalPolicy:   ApprovalOnRequest,
		WorkingDirectory: "/tmp/project",
		AdditionalDirectories: []string{
			"../backend",
			"/tmp/shared",
		},
	})

	result, err := thread.Run([]UserInput{
		{Type: "text", Text: "Describe file changes"},
		{Type: "text", Text: "Focus on impacted tests"},
		{Type: "local_image", Path: "/tmp/first.png"},
		{Type: "local_image", Path: "/tmp/second.jpg"},
	}, TurnOptions{
		Context: context.Background(),
		OutputSchema: map[string]any{
			"type": "object",
			"properties": map[string]any{
				"answer": map[string]any{"type": "string"},
			},
		},
	})
	if err != nil {
		t.Fatalf("thread.Run() error = %v", err)
	}

	if thread.ID() != "thread_123" {
		t.Fatalf("thread.ID() = %q, want %q", thread.ID(), "thread_123")
	}
	if result.FinalResponse != "Hi!" {
		t.Fatalf("FinalResponse = %q, want %q", result.FinalResponse, "Hi!")
	}
	if result.Usage == nil || result.Usage.InputTokens != 42 || result.Usage.CachedInputTokens != 12 || result.Usage.OutputTokens != 5 {
		t.Fatalf("Usage = %#v, want populated usage", result.Usage)
	}

	args := readLines(t, fixture.argsFile)
	expectContainsPair(t, args, "--model", "gpt-test-1")
	expectContainsPair(t, args, "--sandbox", "workspace-write")
	expectContainsPair(t, args, "--cd", "/tmp/project")
	expectContainsPair(t, args, "--config", `approval_policy="never"`)
	expectContainsPair(t, args, "--config", `approval_policy="on-request"`)
	expectContainsPair(t, args, "--add-dir", "../backend")
	expectContainsPair(t, args, "--add-dir", "/tmp/shared")

	if got := collectFollowingArgs(args, "--image"); !reflect.DeepEqual(got, []string{"/tmp/first.png", "/tmp/second.jpg"}) {
		t.Fatalf("images = %#v", got)
	}

	stdin := strings.TrimSpace(readText(t, fixture.stdinFile))
	if stdin != "Describe file changes\n\nFocus on impacted tests" {
		t.Fatalf("stdin = %q", stdin)
	}

	if got := strings.TrimSpace(readText(t, fixture.schemaCheckFile)); got != "present" {
		t.Fatalf("schema file was not present during exec, got %q", got)
	}
	schemaPath := valueAfter(args, "--output-schema")
	if schemaPath == "" {
		t.Fatal("missing --output-schema argument")
	}
	if _, err := os.Stat(schemaPath); !os.IsNotExist(err) {
		t.Fatalf("schema file still exists after run: %s", schemaPath)
	}
}

func indexOf(values []string, target string) int {
	for i, value := range values {
		if value == target {
			return i
		}
	}
	return -1
}

type fixtureCodex struct {
	script          string
	argsFile        string
	envFile         string
	stdinFile       string
	schemaCheckFile string
}

func newFixtureCodex(t *testing.T, scriptBody string) fixtureCodex {
	t.Helper()

	dir := t.TempDir()
	script := filepath.Join(dir, "fake-codex.sh")
	argsFile := filepath.Join(dir, "args.txt")
	envFile := filepath.Join(dir, "env.txt")
	stdinFile := filepath.Join(dir, "stdin.txt")
	schemaCheckFile := filepath.Join(dir, "schema.txt")

	if err := os.WriteFile(script, []byte(scriptBody), 0o755); err != nil {
		t.Fatalf("write script: %v", err)
	}

	return fixtureCodex{
		script:          script,
		argsFile:        argsFile,
		envFile:         envFile,
		stdinFile:       stdinFile,
		schemaCheckFile: schemaCheckFile,
	}
}

func readLines(t *testing.T, path string) []string {
	t.Helper()
	text := strings.TrimSpace(readText(t, path))
	if text == "" {
		return nil
	}
	return strings.Split(text, "\n")
}

func readText(t *testing.T, path string) string {
	t.Helper()
	data, err := os.ReadFile(path)
	if err != nil {
		t.Fatalf("read %s: %v", path, err)
	}
	return string(data)
}

func expectContainsPair(t *testing.T, args []string, key string, value string) {
	t.Helper()
	for i := 0; i+1 < len(args); i++ {
		if args[i] == key && args[i+1] == value {
			return
		}
	}
	t.Fatalf("pair %q %q not found in %#v", key, value, args)
}

func collectFollowingArgs(args []string, key string) []string {
	collected := make([]string, 0)
	for i := 0; i+1 < len(args); i++ {
		if args[i] == key {
			collected = append(collected, args[i+1])
		}
	}
	return collected
}

func valueAfter(args []string, key string) string {
	for i := 0; i+1 < len(args); i++ {
		if args[i] == key {
			return args[i+1]
		}
	}
	return ""
}