Publish Claude Code Binaries / Stage and publish binaries (push) Canceled after 0s
Publish Tutti App Runtime / Build darwin-arm64 (push) Canceled after 0s
Publish Tutti App Runtime / Build darwin-amd64 (push) Canceled after 0s
Publish Tutti App Runtime / Build linux-amd64 (push) Canceled after 0s
Publish Tutti App Runtime / Build windows-amd64 (push) Canceled after 0s
Sync Tutti Agent Skills / sync (push) Canceled after 0s
Windows Agent Adapters / Test Windows agent adapters (push) Canceled after 0s
Windows Daemon Adapters / Test Windows daemon adapters (push) Canceled after 0s
Publish Tutti App Runtime / Publish runtime catalog (push) Canceled after 0s
163 lines
5.4 KiB
Go
163 lines
5.4 KiB
Go
package agent
|
|
|
|
import (
|
|
"reflect"
|
|
"testing"
|
|
)
|
|
|
|
func TestComposerSettingsPayloadRoundTrip(t *testing.T) {
|
|
falseValue := false
|
|
trueValue := true
|
|
cases := []ComposerSettings{
|
|
{},
|
|
{
|
|
Model: "gpt-5",
|
|
PermissionModeID: "auto",
|
|
PlanMode: true,
|
|
ReasoningEffort: "high",
|
|
},
|
|
{
|
|
BrowserUse: &falseValue,
|
|
},
|
|
{
|
|
BrowserUse: &trueValue,
|
|
Model: "claude-sonnet",
|
|
},
|
|
}
|
|
for _, settings := range cases {
|
|
payload := composerSettingsToPayload(settings)
|
|
got := composerSettingsFromPayload(payload)
|
|
if !reflect.DeepEqual(settings, got) {
|
|
t.Fatalf("round-trip mismatch: input=%#v payload=%#v got=%#v", settings, payload, got)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestComposerSettingsFromPayloadBrowserUseTriState(t *testing.T) {
|
|
falseValue := false
|
|
trueValue := true
|
|
|
|
if got := composerSettingsFromPayload(map[string]any{"browserUse": false}); got.BrowserUse == nil || *got.BrowserUse {
|
|
t.Fatalf("expected explicit false, got %#v", got.BrowserUse)
|
|
}
|
|
if got := composerSettingsFromPayload(map[string]any{"browserUse": true}); got.BrowserUse == nil || !*got.BrowserUse {
|
|
t.Fatalf("expected explicit true, got %#v", got.BrowserUse)
|
|
}
|
|
if got := composerSettingsFromPayload(nil); got.BrowserUse != nil {
|
|
t.Fatalf("expected nil browserUse, got %#v", got.BrowserUse)
|
|
}
|
|
|
|
payload := composerSettingsToPayload(ComposerSettings{BrowserUse: &falseValue})
|
|
if payload["browserUse"] != false {
|
|
t.Fatalf("payload browserUse = %#v, want false", payload["browserUse"])
|
|
}
|
|
payload = composerSettingsToPayload(ComposerSettings{BrowserUse: &trueValue})
|
|
if payload["browserUse"] != true {
|
|
t.Fatalf("payload browserUse = %#v, want true", payload["browserUse"])
|
|
}
|
|
payload = composerSettingsToPayload(ComposerSettings{})
|
|
if _, ok := payload["browserUse"]; ok {
|
|
t.Fatalf("expected browserUse omitted for unset default, payload=%#v", payload)
|
|
}
|
|
}
|
|
|
|
func TestComposerSettingsStatePayloadPreservesPlanModeFalse(t *testing.T) {
|
|
payload := composerSettingsToStatePayload(ComposerSettings{PlanMode: false})
|
|
if payload["planMode"] != false {
|
|
t.Fatalf("payload planMode = %#v, want explicit false", payload["planMode"])
|
|
}
|
|
}
|
|
|
|
func TestCreateSessionInputFromPersistedPreservesBrowserUse(t *testing.T) {
|
|
falseValue := false
|
|
input := createSessionInputFromPersisted(PersistedSession{
|
|
ID: "session-1",
|
|
Provider: "codex",
|
|
Settings: ComposerSettings{
|
|
BrowserUse: &falseValue,
|
|
Model: "gpt-5",
|
|
},
|
|
})
|
|
if input.BrowserUse == nil || *input.BrowserUse {
|
|
t.Fatalf("BrowserUse = %#v, want explicit false", input.BrowserUse)
|
|
}
|
|
if input.Model == nil || *input.Model != "gpt-5" {
|
|
t.Fatalf("Model = %#v, want gpt-5", input.Model)
|
|
}
|
|
}
|
|
|
|
func TestCreateSessionInputFromPersistedPreservesCatalogReasoningEffort(t *testing.T) {
|
|
input := createSessionInputFromPersisted(PersistedSession{
|
|
ID: "session-1",
|
|
Provider: "codex",
|
|
Settings: ComposerSettings{
|
|
Model: "gpt-catalog",
|
|
ReasoningEffort: "minimal",
|
|
},
|
|
})
|
|
if input.ReasoningEffort == nil || *input.ReasoningEffort != "minimal" {
|
|
t.Fatalf("ReasoningEffort = %#v, want minimal", input.ReasoningEffort)
|
|
}
|
|
}
|
|
|
|
func TestCreateSessionInputFromPersistedNormalizesLegacyReasoningEffort(t *testing.T) {
|
|
input := createSessionInputFromPersisted(PersistedSession{
|
|
ID: "session-1",
|
|
Provider: "claude-code",
|
|
Settings: ComposerSettings{ReasoningEffort: "minimal"},
|
|
})
|
|
if input.ReasoningEffort == nil || *input.ReasoningEffort != "high" {
|
|
t.Fatalf("ReasoningEffort = %#v, want high", input.ReasoningEffort)
|
|
}
|
|
}
|
|
|
|
func TestCreateSessionInputFromPersistedPreservesOpenCodeModelReasoningEffort(t *testing.T) {
|
|
input := createSessionInputFromPersisted(PersistedSession{
|
|
ID: "session-1",
|
|
Provider: "opencode",
|
|
Settings: ComposerSettings{ReasoningEffort: "none"},
|
|
})
|
|
if input.ReasoningEffort == nil || *input.ReasoningEffort != "none" {
|
|
t.Fatalf("ReasoningEffort = %#v, want none", input.ReasoningEffort)
|
|
}
|
|
}
|
|
|
|
func TestCreateSessionInputFromPersistedCarriesExternalRolloutSourcePath(t *testing.T) {
|
|
input := createSessionInputFromPersisted(PersistedSession{
|
|
ID: "session-1",
|
|
Provider: "codex",
|
|
InternalRuntimeContext: map[string]any{
|
|
"imported": true,
|
|
"externalSourcePath": "/home/user/.codex/sessions/2026/07/04/rollout-abc.jsonl",
|
|
},
|
|
})
|
|
if input.ExternalRolloutSourcePath != "/home/user/.codex/sessions/2026/07/04/rollout-abc.jsonl" {
|
|
t.Fatalf("ExternalRolloutSourcePath = %q, want imported source path preserved", input.ExternalRolloutSourcePath)
|
|
}
|
|
}
|
|
|
|
func TestCreateSessionInputFromPersistedDoesNotTreatClaudeExportAsRollout(t *testing.T) {
|
|
input := createSessionInputFromPersisted(PersistedSession{
|
|
ID: "session-1",
|
|
Provider: "claude-code",
|
|
InternalRuntimeContext: map[string]any{
|
|
"imported": true,
|
|
"externalImportResumeSupported": false,
|
|
"externalSourcePath": "/home/user/Downloads/claude-export.zip",
|
|
},
|
|
})
|
|
if input.ExternalRolloutSourcePath != "" {
|
|
t.Fatalf("ExternalRolloutSourcePath = %q, want archive path excluded from provider resume", input.ExternalRolloutSourcePath)
|
|
}
|
|
}
|
|
|
|
func TestCreateSessionInputFromPersistedLeavesExternalRolloutSourcePathEmptyForNonImportedSession(t *testing.T) {
|
|
input := createSessionInputFromPersisted(PersistedSession{
|
|
ID: "session-1",
|
|
Provider: "codex",
|
|
})
|
|
if input.ExternalRolloutSourcePath != "" {
|
|
t.Fatalf("ExternalRolloutSourcePath = %q, want empty for a session with no RuntimeContext", input.ExternalRolloutSourcePath)
|
|
}
|
|
}
|