Files
agent-radar 2ed3415fb7
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
源码快照 @ 2026-09-01 (source-only, 剔除非源码素材)
2026-09-01 20:17:27 +08:00

215 lines
6.7 KiB
Go

package agent
import (
"context"
"errors"
"testing"
runtimeprep "github.com/tutti-os/tutti/packages/agent/runtimeprep"
modelgatewayservice "github.com/tutti-os/tutti/services/tuttid/service/modelgateway"
)
type fakeModelGateway struct {
endpoint modelgatewayservice.ClientEndpoint
err error
registeredRoute *modelgatewayservice.Route
registerCalls *int
unregisterCalls *[][2]string
}
func (f fakeModelGateway) Register(_ context.Context, route modelgatewayservice.Route) (modelgatewayservice.ClientEndpoint, error) {
if f.registerCalls != nil {
*f.registerCalls++
}
if f.registeredRoute != nil {
*f.registeredRoute = route
}
return f.endpoint, f.err
}
func (f fakeModelGateway) Unregister(_ context.Context, workspaceID string, agentSessionID string) {
if f.unregisterCalls != nil {
*f.unregisterCalls = append(*f.unregisterCalls, [2]string{workspaceID, agentSessionID})
}
}
func TestPrepareRuntimeCodexGatewayUsesTemporaryCredentialAndRollsBackFailure(t *testing.T) {
t.Parallel()
upstreamKey := "sk-upstream-secret"
var preparedInput runtimeprep.PrepareInput
var registeredRoute modelgatewayservice.Route
var unregisterCalls [][2]string
service := &Service{
RuntimePreparer: fakeRuntimePreparer{
input: &preparedInput,
err: errors.New("prepare failed"),
},
ModelGateway: fakeModelGateway{
endpoint: modelgatewayservice.ClientEndpoint{
BaseURL: "http://127.0.0.1:40000/v1",
Token: "temporary-token",
WireAPI: "responses",
},
registeredRoute: &registeredRoute,
unregisterCalls: &unregisterCalls,
},
}
_, err := service.prepareRuntimeWithModelEndpoint(
context.Background(),
"workspace",
"/repo",
CreateSessionInput{
AgentSessionID: "session",
Provider: "codex",
Model: stringPointer("model-a"),
},
&runtimeprep.ModelEndpointConfig{
Protocol: "openai",
BaseURL: "https://upstream.example/v1",
APIKey: upstreamKey,
Model: "model-a",
Models: []runtimeprep.ModelEndpointModel{{ID: "model-a"}},
},
)
if err == nil || err.Error() != "prepare failed" {
t.Fatalf("prepareRuntimeWithModelEndpoint() error = %v", err)
}
if registeredRoute.UpstreamAPIKey != upstreamKey ||
registeredRoute.UpstreamURL != "https://upstream.example/v1" {
t.Fatalf("registered route = %#v", registeredRoute)
}
if preparedInput.ModelEndpoint == nil ||
preparedInput.ModelEndpoint.APIKey != "temporary-token" ||
preparedInput.ModelEndpoint.BaseURL != "http://127.0.0.1:40000/v1" ||
preparedInput.ModelEndpoint.WireAPI != "responses" {
t.Fatalf("prepared endpoint = %#v", preparedInput.ModelEndpoint)
}
if len(unregisterCalls) != 2 {
t.Fatalf("unregister calls = %#v, want replacement revoke and rollback revoke", unregisterCalls)
}
}
func TestPrepareRuntimeTuttiAgentGatewayUsesResponsesEndpoint(t *testing.T) {
t.Parallel()
var preparedInput runtimeprep.PrepareInput
registerCalls := 0
service := &Service{
RuntimePreparer: fakeRuntimePreparer{input: &preparedInput},
ModelGateway: fakeModelGateway{
endpoint: modelgatewayservice.ClientEndpoint{
BaseURL: "http://127.0.0.1:40000/v1",
Token: "temporary-token",
WireAPI: "responses",
},
registerCalls: &registerCalls,
},
}
if _, err := service.prepareRuntimeWithModelEndpoint(
context.Background(),
"workspace",
"/repo",
CreateSessionInput{AgentSessionID: "session", Provider: "tutti-agent"},
&runtimeprep.ModelEndpointConfig{
Protocol: "openai",
BaseURL: "https://upstream.example/v1",
APIKey: "sk-upstream-secret",
Model: "model-a",
},
); err != nil {
t.Fatalf("prepareRuntimeWithModelEndpoint() error = %v", err)
}
if registerCalls != 1 {
t.Fatalf("gateway Register() calls = %d, want 1", registerCalls)
}
if preparedInput.ModelEndpoint == nil ||
preparedInput.ModelEndpoint.BaseURL != "http://127.0.0.1:40000/v1" ||
preparedInput.ModelEndpoint.APIKey != "temporary-token" ||
preparedInput.ModelEndpoint.WireAPI != "responses" {
t.Fatalf("Tutti Agent endpoint = %#v, want temporary Responses endpoint", preparedInput.ModelEndpoint)
}
}
func TestPrepareRuntimeTuttiAgentGatewayReportsProviderNeutralFailures(t *testing.T) {
t.Parallel()
endpoint := &runtimeprep.ModelEndpointConfig{
Protocol: "openai",
BaseURL: "https://upstream.example/v1",
APIKey: "sk-upstream-secret",
Model: "model-a",
}
input := CreateSessionInput{AgentSessionID: "session", Provider: "tutti-agent"}
withoutGateway := &Service{RuntimePreparer: fakeRuntimePreparer{}}
if _, err := withoutGateway.prepareRuntimeWithModelEndpoint(
context.Background(), "workspace", "/repo", input, endpoint,
); err == nil || err.Error() != `model-plan gateway is unavailable for provider "tutti-agent"` {
t.Fatalf("missing gateway error = %v", err)
}
registerFailure := &Service{
RuntimePreparer: fakeRuntimePreparer{},
ModelGateway: fakeModelGateway{err: errors.New("register failed")},
}
if _, err := registerFailure.prepareRuntimeWithModelEndpoint(
context.Background(), "workspace", "/repo", input, endpoint,
); err == nil || err.Error() != `register model-plan gateway route for provider "tutti-agent": register failed` {
t.Fatalf("register gateway error = %v", err)
}
}
func TestPrepareRuntimeOpenCodeKeepsDirectModelPlanEndpoint(t *testing.T) {
t.Parallel()
var preparedInput runtimeprep.PrepareInput
registerCalls := 0
service := &Service{
RuntimePreparer: fakeRuntimePreparer{input: &preparedInput},
ModelGateway: fakeModelGateway{
registerCalls: &registerCalls,
},
}
endpoint := &runtimeprep.ModelEndpointConfig{
Protocol: "openai",
BaseURL: "https://upstream.example/v1",
APIKey: "sk-direct",
Model: "tutti-model-plan/model-a",
}
if _, err := service.prepareRuntimeWithModelEndpoint(
context.Background(),
"workspace",
"/repo",
CreateSessionInput{
AgentSessionID: "session",
Provider: "opencode",
},
endpoint,
); err != nil {
t.Fatalf("prepareRuntimeWithModelEndpoint() error = %v", err)
}
if registerCalls != 0 {
t.Fatalf("gateway Register() calls = %d, want 0", registerCalls)
}
if preparedInput.ModelEndpoint != endpoint ||
preparedInput.ModelEndpoint.APIKey != "sk-direct" ||
preparedInput.ModelEndpoint.WireAPI != "" {
t.Fatalf("OpenCode endpoint = %#v, want direct plan endpoint", preparedInput.ModelEndpoint)
}
}
func TestCleanupRuntimeRevokesGatewayWithoutRuntimePreparer(t *testing.T) {
t.Parallel()
var unregisterCalls [][2]string
service := &Service{
ModelGateway: fakeModelGateway{unregisterCalls: &unregisterCalls},
}
if err := service.cleanupRuntime(context.Background(), "workspace", "session"); err != nil {
t.Fatalf("cleanupRuntime() error = %v", err)
}
if len(unregisterCalls) != 1 || unregisterCalls[0] != [2]string{"workspace", "session"} {
t.Fatalf("unregister calls = %#v", unregisterCalls)
}
}