570 lines
16 KiB
Go
570 lines
16 KiB
Go
package execenv
|
|
|
|
import (
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/pelletier/go-toml/v2"
|
|
)
|
|
|
|
// parseTOML decodes the given content with a spec-strict parser. Codex's
|
|
// `toml-rs` follows the same strict semantics, so a config that parses
|
|
// here will load in Codex.
|
|
func parseTOML(t *testing.T, content string) map[string]any {
|
|
t.Helper()
|
|
var parsed map[string]any
|
|
if err := toml.Unmarshal([]byte(content), &parsed); err != nil {
|
|
t.Fatalf("expected valid TOML, got parser error: %v\n--- file ---\n%s", err, content)
|
|
}
|
|
return parsed
|
|
}
|
|
|
|
// requireMultiAgentDisabled asserts that the parsed config has
|
|
// features.multi_agent set to false.
|
|
func requireMultiAgentDisabled(t *testing.T, parsed map[string]any) {
|
|
t.Helper()
|
|
features, ok := parsed["features"].(map[string]any)
|
|
if !ok {
|
|
t.Fatalf("expected `features` table in parsed config, got: %#v", parsed["features"])
|
|
}
|
|
v, ok := features["multi_agent"].(bool)
|
|
if !ok {
|
|
t.Fatalf("expected features.multi_agent to be a bool, got: %#v", features["multi_agent"])
|
|
}
|
|
if v {
|
|
t.Errorf("expected features.multi_agent = false, got true")
|
|
}
|
|
}
|
|
|
|
func TestStripUserMultiAgentDirectives(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
tests := []struct {
|
|
name string
|
|
in string
|
|
want string
|
|
}{
|
|
{
|
|
name: "drops top-level dotted-key form",
|
|
in: `model = "o3"
|
|
features.multi_agent = true
|
|
|
|
[profiles.default]
|
|
model = "o3"
|
|
`,
|
|
want: `model = "o3"
|
|
|
|
[profiles.default]
|
|
model = "o3"
|
|
`,
|
|
},
|
|
{
|
|
name: "drops top-level dotted-key form with whitespace",
|
|
in: `model = "o3"
|
|
features . multi_agent = true
|
|
|
|
[profiles.default]
|
|
model = "o3"
|
|
`,
|
|
want: `model = "o3"
|
|
|
|
[profiles.default]
|
|
model = "o3"
|
|
`,
|
|
},
|
|
{
|
|
name: "drops multi_agent inside [features] table",
|
|
in: `[features]
|
|
multi_agent = true
|
|
experimental_foo = true
|
|
|
|
[profiles.default]
|
|
model = "o3"
|
|
`,
|
|
want: `[features]
|
|
experimental_foo = true
|
|
|
|
[profiles.default]
|
|
model = "o3"
|
|
`,
|
|
},
|
|
{
|
|
name: "drops multi_agent inside [features] table with inline comment",
|
|
in: `[features] # user feature flags
|
|
multi_agent = true
|
|
experimental_foo = true
|
|
`,
|
|
want: `[features] # user feature flags
|
|
experimental_foo = true
|
|
`,
|
|
},
|
|
{
|
|
name: "drops multi_agent inside spaced [ features ] table",
|
|
in: `[ features ]
|
|
multi_agent = true
|
|
experimental_foo = true
|
|
`,
|
|
want: `[ features ]
|
|
experimental_foo = true
|
|
`,
|
|
},
|
|
{
|
|
name: "preserves multi_agent under unrelated table",
|
|
in: `[profiles.experimental]
|
|
multi_agent = true
|
|
`,
|
|
want: `[profiles.experimental]
|
|
multi_agent = true
|
|
`,
|
|
},
|
|
{
|
|
name: "preserves multi_agent under nested [features.experimental]",
|
|
in: `[features.experimental]
|
|
multi_agent = true
|
|
`,
|
|
want: `[features.experimental]
|
|
multi_agent = true
|
|
`,
|
|
},
|
|
{
|
|
name: "no multi_agent — content unchanged",
|
|
in: `model = "o3"
|
|
|
|
[profiles.default]
|
|
model = "o3"
|
|
`,
|
|
want: `model = "o3"
|
|
|
|
[profiles.default]
|
|
model = "o3"
|
|
`,
|
|
},
|
|
{
|
|
name: "drops both forms simultaneously",
|
|
in: `features.multi_agent = true
|
|
|
|
[features]
|
|
multi_agent = false
|
|
something_else = "keep"
|
|
`,
|
|
want: `
|
|
[features]
|
|
something_else = "keep"
|
|
`,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
got := stripUserMultiAgentDirectives(tt.in)
|
|
if got != tt.want {
|
|
t.Errorf("stripUserMultiAgentDirectives mismatch\n--- got ---\n%s\n--- want ---\n%s", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestEnsureCodexMultiAgentConfigEmptyFile(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
dir := t.TempDir()
|
|
configPath := filepath.Join(dir, "config.toml")
|
|
|
|
if err := ensureCodexMultiAgentConfig(configPath, nil); err != nil {
|
|
t.Fatalf("ensureCodexMultiAgentConfig failed: %v", err)
|
|
}
|
|
|
|
data, err := os.ReadFile(configPath)
|
|
if err != nil {
|
|
t.Fatalf("read result: %v", err)
|
|
}
|
|
got := string(data)
|
|
if !strings.Contains(got, "features.multi_agent = false") {
|
|
t.Errorf("expected managed block to set features.multi_agent = false at root, got:\n%s", got)
|
|
}
|
|
if !strings.Contains(got, multicaMultiAgentBeginMarker) {
|
|
t.Errorf("expected begin marker, got:\n%s", got)
|
|
}
|
|
if !strings.Contains(got, multicaMultiAgentEndMarker) {
|
|
t.Errorf("expected end marker, got:\n%s", got)
|
|
}
|
|
requireMultiAgentDisabled(t, parseTOML(t, got))
|
|
}
|
|
|
|
func TestEnsureCodexMultiAgentConfigDottedKey(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
dir := t.TempDir()
|
|
configPath := filepath.Join(dir, "config.toml")
|
|
original := `model = "o3"
|
|
features.multi_agent = true
|
|
|
|
[profiles.default]
|
|
model = "o3"
|
|
`
|
|
if err := os.WriteFile(configPath, []byte(original), 0o644); err != nil {
|
|
t.Fatalf("write fixture: %v", err)
|
|
}
|
|
|
|
if err := ensureCodexMultiAgentConfig(configPath, nil); err != nil {
|
|
t.Fatalf("ensureCodexMultiAgentConfig failed: %v", err)
|
|
}
|
|
|
|
data, _ := os.ReadFile(configPath)
|
|
got := string(data)
|
|
if strings.Contains(got, "features.multi_agent = true") {
|
|
t.Errorf("expected user features.multi_agent = true to be stripped, got:\n%s", got)
|
|
}
|
|
if !strings.Contains(got, "features.multi_agent = false") {
|
|
t.Errorf("expected managed features.multi_agent = false at root, got:\n%s", got)
|
|
}
|
|
if !strings.Contains(got, `[profiles.default]`) || !strings.Contains(got, `model = "o3"`) {
|
|
t.Errorf("expected unrelated content preserved, got:\n%s", got)
|
|
}
|
|
requireMultiAgentDisabled(t, parseTOML(t, got))
|
|
}
|
|
|
|
func TestEnsureCodexMultiAgentConfigDottedKeyWithWhitespace(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
dir := t.TempDir()
|
|
configPath := filepath.Join(dir, "config.toml")
|
|
original := `model = "o3"
|
|
features . multi_agent = true
|
|
`
|
|
if err := os.WriteFile(configPath, []byte(original), 0o644); err != nil {
|
|
t.Fatalf("write fixture: %v", err)
|
|
}
|
|
|
|
if err := ensureCodexMultiAgentConfig(configPath, nil); err != nil {
|
|
t.Fatalf("ensureCodexMultiAgentConfig failed: %v", err)
|
|
}
|
|
|
|
data, _ := os.ReadFile(configPath)
|
|
got := string(data)
|
|
if strings.Contains(got, "features . multi_agent = true") {
|
|
t.Errorf("expected user features . multi_agent = true to be stripped, got:\n%s", got)
|
|
}
|
|
requireMultiAgentDisabled(t, parseTOML(t, got))
|
|
}
|
|
|
|
func TestEnsureCodexMultiAgentConfigFeaturesTable(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
dir := t.TempDir()
|
|
configPath := filepath.Join(dir, "config.toml")
|
|
original := `[features]
|
|
multi_agent = true
|
|
experimental_thinking = true
|
|
|
|
[profiles.default]
|
|
model = "o3"
|
|
`
|
|
if err := os.WriteFile(configPath, []byte(original), 0o644); err != nil {
|
|
t.Fatalf("write fixture: %v", err)
|
|
}
|
|
|
|
if err := ensureCodexMultiAgentConfig(configPath, nil); err != nil {
|
|
t.Fatalf("ensureCodexMultiAgentConfig failed: %v", err)
|
|
}
|
|
|
|
data, _ := os.ReadFile(configPath)
|
|
got := string(data)
|
|
|
|
// User's `multi_agent = true` must be gone, our managed `multi_agent = false`
|
|
// must be inside the [features] table (NOT at the root as a dotted key,
|
|
// which would redefine the table and break the strict TOML parser).
|
|
if strings.Contains(got, "multi_agent = true") {
|
|
t.Errorf("expected user multi_agent = true to be stripped, got:\n%s", got)
|
|
}
|
|
if strings.Contains(got, "features.multi_agent = false") {
|
|
t.Errorf("managed block must NOT use root dotted-key form when [features] table exists (would redefine the table); got:\n%s", got)
|
|
}
|
|
if !strings.Contains(got, "[features]") {
|
|
t.Errorf("expected [features] header preserved, got:\n%s", got)
|
|
}
|
|
if !strings.Contains(got, "experimental_thinking = true") {
|
|
t.Errorf("expected sibling features.* keys preserved, got:\n%s", got)
|
|
}
|
|
|
|
// Output must parse as valid TOML and have features.multi_agent = false.
|
|
requireMultiAgentDisabled(t, parseTOML(t, got))
|
|
}
|
|
|
|
func TestEnsureCodexMultiAgentConfigFeaturesTableHeaderVariants(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
cases := map[string]string{
|
|
"inline_comment": `[features] # user feature flags
|
|
multi_agent = true
|
|
experimental_thinking = true
|
|
`,
|
|
"spaced_header": `[ features ]
|
|
multi_agent = true
|
|
experimental_thinking = true
|
|
`,
|
|
}
|
|
|
|
for name, original := range cases {
|
|
t.Run(name, func(t *testing.T) {
|
|
t.Parallel()
|
|
dir := t.TempDir()
|
|
configPath := filepath.Join(dir, "config.toml")
|
|
if err := os.WriteFile(configPath, []byte(original), 0o644); err != nil {
|
|
t.Fatalf("write fixture: %v", err)
|
|
}
|
|
|
|
if err := ensureCodexMultiAgentConfig(configPath, nil); err != nil {
|
|
t.Fatalf("ensureCodexMultiAgentConfig failed: %v", err)
|
|
}
|
|
|
|
data, _ := os.ReadFile(configPath)
|
|
got := string(data)
|
|
if strings.Contains(got, "features.multi_agent = false") {
|
|
t.Errorf("managed block must NOT use root dotted-key form when [features] table exists; got:\n%s", got)
|
|
}
|
|
if strings.Contains(got, "multi_agent = true") {
|
|
t.Errorf("expected user multi_agent = true to be stripped, got:\n%s", got)
|
|
}
|
|
|
|
parsed := parseTOML(t, got)
|
|
requireMultiAgentDisabled(t, parsed)
|
|
features := parsed["features"].(map[string]any)
|
|
if v, _ := features["experimental_thinking"].(bool); !v {
|
|
t.Errorf("expected user's features.experimental_thinking preserved, got %v", features["experimental_thinking"])
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestEnsureCodexMultiAgentConfigFeaturesTableEmpty(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
dir := t.TempDir()
|
|
configPath := filepath.Join(dir, "config.toml")
|
|
original := `[features]
|
|
`
|
|
if err := os.WriteFile(configPath, []byte(original), 0o644); err != nil {
|
|
t.Fatalf("write fixture: %v", err)
|
|
}
|
|
|
|
if err := ensureCodexMultiAgentConfig(configPath, nil); err != nil {
|
|
t.Fatalf("ensureCodexMultiAgentConfig failed: %v", err)
|
|
}
|
|
|
|
data, _ := os.ReadFile(configPath)
|
|
requireMultiAgentDisabled(t, parseTOML(t, string(data)))
|
|
}
|
|
|
|
func TestEnsureCodexMultiAgentConfigFeaturesSubtableOnly(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
// User has [features.experimental] but no bare [features] header. The
|
|
// dotted-key form at root is fine — both implicitly define `features`,
|
|
// neither defines `[features]` explicitly, so no redefinition.
|
|
dir := t.TempDir()
|
|
configPath := filepath.Join(dir, "config.toml")
|
|
original := `[features.experimental]
|
|
thinking = true
|
|
`
|
|
if err := os.WriteFile(configPath, []byte(original), 0o644); err != nil {
|
|
t.Fatalf("write fixture: %v", err)
|
|
}
|
|
|
|
if err := ensureCodexMultiAgentConfig(configPath, nil); err != nil {
|
|
t.Fatalf("ensureCodexMultiAgentConfig failed: %v", err)
|
|
}
|
|
|
|
data, _ := os.ReadFile(configPath)
|
|
got := string(data)
|
|
if !strings.Contains(got, "features.multi_agent = false") {
|
|
t.Errorf("expected root dotted-key form when only sub-tables exist, got:\n%s", got)
|
|
}
|
|
|
|
parsed := parseTOML(t, got)
|
|
requireMultiAgentDisabled(t, parsed)
|
|
features := parsed["features"].(map[string]any)
|
|
exp, _ := features["experimental"].(map[string]any)
|
|
if v, _ := exp["thinking"].(bool); !v {
|
|
t.Errorf("expected features.experimental.thinking preserved, got: %#v", exp)
|
|
}
|
|
}
|
|
|
|
func TestEnsureCodexMultiAgentConfigIdempotent(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
cases := map[string]string{
|
|
"root_form": `model = "o3"
|
|
features.multi_agent = true
|
|
`,
|
|
"in_features_table": `[features]
|
|
multi_agent = true
|
|
experimental_thinking = true
|
|
`,
|
|
"in_features_table_with_other_keys": `[features]
|
|
experimental_thinking = true
|
|
|
|
[profiles.default]
|
|
model = "o3"
|
|
`,
|
|
}
|
|
for name, original := range cases {
|
|
t.Run(name, func(t *testing.T) {
|
|
t.Parallel()
|
|
dir := t.TempDir()
|
|
configPath := filepath.Join(dir, "config.toml")
|
|
if err := os.WriteFile(configPath, []byte(original), 0o644); err != nil {
|
|
t.Fatalf("write fixture: %v", err)
|
|
}
|
|
|
|
if err := ensureCodexMultiAgentConfig(configPath, nil); err != nil {
|
|
t.Fatalf("first run failed: %v", err)
|
|
}
|
|
first, _ := os.ReadFile(configPath)
|
|
infoFirst, _ := os.Stat(configPath)
|
|
|
|
if err := ensureCodexMultiAgentConfig(configPath, nil); err != nil {
|
|
t.Fatalf("second run failed: %v", err)
|
|
}
|
|
second, _ := os.ReadFile(configPath)
|
|
infoSecond, _ := os.Stat(configPath)
|
|
|
|
if string(first) != string(second) {
|
|
t.Errorf("expected idempotent rewrite\n--- first ---\n%s\n--- second ---\n%s", first, second)
|
|
}
|
|
if !infoSecond.ModTime().Equal(infoFirst.ModTime()) {
|
|
t.Errorf("expected no rewrite on second pass (file was touched)")
|
|
}
|
|
// Final output must parse as valid TOML.
|
|
requireMultiAgentDisabled(t, parseTOML(t, string(second)))
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestEnsureCodexMultiAgentConfigEscapeHatch(t *testing.T) {
|
|
// Cannot run in parallel: mutates process env.
|
|
dir := t.TempDir()
|
|
configPath := filepath.Join(dir, "config.toml")
|
|
original := `model = "o3"
|
|
features.multi_agent = true
|
|
`
|
|
if err := os.WriteFile(configPath, []byte(original), 0o644); err != nil {
|
|
t.Fatalf("write fixture: %v", err)
|
|
}
|
|
|
|
t.Setenv(MulticaCodexMultiAgentEnv, "1")
|
|
|
|
if err := ensureCodexMultiAgentConfig(configPath, nil); err != nil {
|
|
t.Fatalf("ensureCodexMultiAgentConfig failed: %v", err)
|
|
}
|
|
|
|
data, _ := os.ReadFile(configPath)
|
|
got := string(data)
|
|
if got != original {
|
|
t.Errorf("expected file untouched when escape hatch set\n--- got ---\n%s\n--- want ---\n%s", got, original)
|
|
}
|
|
}
|
|
|
|
func TestCodexMultiAgentEnabledTruthy(t *testing.T) {
|
|
for _, v := range []string{"1", "true", "TRUE", "yes", "On"} {
|
|
t.Run(v, func(t *testing.T) {
|
|
t.Setenv(MulticaCodexMultiAgentEnv, v)
|
|
if !codexMultiAgentEnabled() {
|
|
t.Errorf("expected %q to be truthy", v)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCodexMultiAgentEnabledFalsy(t *testing.T) {
|
|
for _, v := range []string{"", "0", "false", "no", "off", "anything else"} {
|
|
t.Run(v, func(t *testing.T) {
|
|
t.Setenv(MulticaCodexMultiAgentEnv, v)
|
|
if codexMultiAgentEnabled() {
|
|
t.Errorf("expected %q to be falsy", v)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestEnsureCodexMultiAgentConfigCoexistsWithSandboxBlock(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
dir := t.TempDir()
|
|
configPath := filepath.Join(dir, "config.toml")
|
|
original := `model = "o3"
|
|
features.multi_agent = true
|
|
`
|
|
if err := os.WriteFile(configPath, []byte(original), 0o644); err != nil {
|
|
t.Fatalf("write fixture: %v", err)
|
|
}
|
|
|
|
policy := codexSandboxPolicy{Mode: "workspace-write", NetworkAccess: true, Reason: "test"}
|
|
if err := ensureCodexSandboxConfig(configPath, policy, "0.121.0", nil); err != nil {
|
|
t.Fatalf("ensureCodexSandboxConfig failed: %v", err)
|
|
}
|
|
if err := ensureCodexMultiAgentConfig(configPath, nil); err != nil {
|
|
t.Fatalf("ensureCodexMultiAgentConfig failed: %v", err)
|
|
}
|
|
|
|
data, _ := os.ReadFile(configPath)
|
|
got := string(data)
|
|
if !strings.Contains(got, multicaManagedBeginMarker) {
|
|
t.Errorf("expected sandbox managed block, got:\n%s", got)
|
|
}
|
|
if !strings.Contains(got, multicaMultiAgentBeginMarker) {
|
|
t.Errorf("expected multi-agent managed block, got:\n%s", got)
|
|
}
|
|
if strings.Contains(got, "features.multi_agent = true") {
|
|
t.Errorf("expected user features.multi_agent = true to be stripped, got:\n%s", got)
|
|
}
|
|
|
|
// File must parse as valid TOML and have multi_agent disabled.
|
|
requireMultiAgentDisabled(t, parseTOML(t, got))
|
|
|
|
// Re-running both should be idempotent.
|
|
if err := ensureCodexSandboxConfig(configPath, policy, "0.121.0", nil); err != nil {
|
|
t.Fatalf("ensureCodexSandboxConfig (rerun) failed: %v", err)
|
|
}
|
|
if err := ensureCodexMultiAgentConfig(configPath, nil); err != nil {
|
|
t.Fatalf("ensureCodexMultiAgentConfig (rerun) failed: %v", err)
|
|
}
|
|
dataAfter, _ := os.ReadFile(configPath)
|
|
if string(dataAfter) != got {
|
|
t.Errorf("expected idempotent combined rewrite\n--- first ---\n%s\n--- second ---\n%s", got, dataAfter)
|
|
}
|
|
}
|
|
|
|
// Regression for PR #1845 review: when the user's config has a `[features]`
|
|
// table, naively writing `features.multi_agent = false` at the TOML root
|
|
// implicitly redefines the same table. The strict TOML parser used by
|
|
// Codex (`toml-rs`) rejects that with `table 'features' already exists`.
|
|
func TestRegressionFeaturesTableProducesValidTOML(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
dir := t.TempDir()
|
|
configPath := filepath.Join(dir, "config.toml")
|
|
original := `[features]
|
|
experimental_thinking = true
|
|
`
|
|
if err := os.WriteFile(configPath, []byte(original), 0o644); err != nil {
|
|
t.Fatalf("write fixture: %v", err)
|
|
}
|
|
|
|
if err := ensureCodexMultiAgentConfig(configPath, nil); err != nil {
|
|
t.Fatalf("ensureCodexMultiAgentConfig failed: %v", err)
|
|
}
|
|
|
|
data, _ := os.ReadFile(configPath)
|
|
parsed := parseTOML(t, string(data))
|
|
requireMultiAgentDisabled(t, parsed)
|
|
|
|
features := parsed["features"].(map[string]any)
|
|
if v, _ := features["experimental_thinking"].(bool); !v {
|
|
t.Errorf("expected user's features.experimental_thinking preserved, got %v", features["experimental_thinking"])
|
|
}
|
|
}
|