Files
archie/internal/webui/api_setup_test.go
T
sam 812d9004a7
Quality / check (push) Successful in 4m40s
deploy / gate (push) Successful in 6m15s
deploy / archied-image (push) Successful in 2m57s
deploy / agent-image (push) Successful in 11s
deploy / dist-zip (push) Skipped
feat(webui): keep the Model setup step open until the provider credential resolves (#1045)
2026-10-31 20:04:06 +11:00

231 lines
7.1 KiB
Go

package webui
import (
"context"
"encoding/json"
"net/http"
"net/http/httptest"
"strings"
"testing"
"google.golang.org/grpc"
controlpb "github.com/samcharles93/archie-core/internal/contracts/controlplane/v1"
"github.com/samcharles93/archie-core/internal/domain/harnesssecret"
"github.com/samcharles93/archie-core/internal/domain/storecontract"
"github.com/samcharles93/archie-core/internal/secret"
)
type setupStore struct {
storecontract.TaskStore
}
func (setupStore) StatusCounts(context.Context) (map[string]int, error) {
return map[string]int{"done": 1}, nil
}
type setupModels struct {
aliases map[string]string
err error
}
func (m setupModels) CallerModels(context.Context) (string, map[string]string, error) {
return "org", m.aliases, m.err
}
// setupControl answers provider-settings and credential-bindings queries from
// fixed documents, the way the State Store would for one org.
type setupControl struct {
controlpb.ControlPlaneServiceClient
providers string
bindings string
}
func (c setupControl) Query(_ context.Context, r *controlpb.QueryRequest, _ ...grpc.CallOption) (*controlpb.QueryResponse, error) {
var value string
switch r.Kind {
case providerSettingsKind:
value = c.providers
case credentialBindingsKind:
value = c.bindings
default:
value = "null"
}
return &controlpb.QueryResponse{Resource: &controlpb.Resource{Kind: r.Kind, ValueJson: []byte(value)}}, nil
}
type setupHarnessSecrets struct {
storecontract.HarnessSecretStore
tokens map[string]harnesssecret.Secret
}
func (h setupHarnessSecrets) GetHarnessSecret(_ context.Context, _, service string) (harnesssecret.Secret, error) {
if token, ok := h.tokens[service]; ok {
return token, nil
}
return harnesssecret.Secret{}, storecontract.ErrHarnessSecretNotFound
}
func setupRequest(t *testing.T, srv *Server) []SetupStep {
t.Helper()
req := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "/api/setup", nil)
response := httptest.NewRecorder()
srv.handleSetup(response, req)
if response.Code != http.StatusOK {
t.Fatalf("response = %d %s", response.Code, response.Body.String())
}
var body struct {
Steps []SetupStep `json:"steps"`
}
if err := json.Unmarshal(response.Body.Bytes(), &body); err != nil {
t.Fatalf("decode response %q: %v", response.Body.String(), err)
}
return body.Steps
}
func modelStep(steps []SetupStep) *SetupStep {
for i := range steps {
if steps[i].Title == "Model" {
return &steps[i]
}
}
return nil
}
func TestHandleSetupModelStep(t *testing.T) {
resolving := func(_ context.Context, ref secret.SecretRef) (bool, error) {
return ref == (secret.SecretRef{Engine: "env", Key: "GOOD_KEY"}), nil
}
for _, tt := range []struct {
name string
aliases map[string]string
providers string
bindings string
tokens map[string]harnesssecret.Secret
check func(context.Context, secret.SecretRef) (bool, error)
open bool
detail string
}{
{
name: "no aliases leaves the step open",
aliases: map[string]string{},
open: true,
detail: "no model alias configured",
},
{
name: "resolving api_key_ref completes the step",
aliases: map[string]string{"default": "openai/gpt-5"},
providers: `{"openai":{"class":"openai","api_key_ref":{"engine":"env","key":"GOOD_KEY"}}}`,
check: resolving,
open: false,
},
{
name: "unresolving api_key_ref keeps the step open and names it",
aliases: map[string]string{"default": "openai/gpt-5"},
providers: `{"openai":{"class":"openai","api_key_ref":{"engine":"env","key":"BAD_KEY"}}}`,
check: resolving,
open: true,
detail: `provider "openai" credential env:BAD_KEY does not resolve`,
},
{
name: "provider declaring no credential keeps the step open",
aliases: map[string]string{"default": "openai/gpt-5"},
providers: `{"openai":{"class":"openai"}}`,
check: resolving,
open: true,
detail: `provider "openai" declares no credential`,
},
{
name: "credential binding secret resolves for an org provider",
aliases: map[string]string{"default": "acme/gpt-5"},
providers: `{"acme":{"class":"openai"}}`,
bindings: `[{"service":"acme","secret":{"engine":"env","key":"GOOD_KEY"}}]`,
check: resolving,
open: false,
},
{
name: "credential binding secret that does not resolve keeps the step open",
aliases: map[string]string{"default": "acme/gpt-5"},
providers: `{"acme":{"class":"openai"}}`,
bindings: `[{"service":"acme","secret":{"engine":"env","key":"BAD_KEY"}}]`,
check: resolving,
open: true,
detail: `provider "acme" credential env:BAD_KEY does not resolve`,
},
{
name: "org provider without a binding keeps the step open",
aliases: map[string]string{"default": "acme/gpt-5"},
providers: `{"acme":{"class":"openai"}}`,
check: resolving,
open: true,
detail: `provider "acme" declares no credential`,
},
{
name: "instance provider is not the org's credential to configure",
aliases: map[string]string{"default": "shared/gpt-5"},
providers: `{}`,
check: resolving,
open: false,
},
{
name: "oauth binding with a captured token set completes the step",
aliases: map[string]string{"default": "acme/gpt-5"},
providers: `{"acme":{"class":"openai"}}`,
bindings: `[{"service":"acme"}]`,
tokens: map[string]harnesssecret.Secret{"acme": {Org: "org", Service: "acme", AccessToken: "token"}},
check: resolving,
open: false,
},
{
name: "oauth binding without a captured token set keeps the step open",
aliases: map[string]string{"default": "acme/gpt-5"},
providers: `{"acme":{"class":"openai"}}`,
bindings: `[{"service":"acme"}]`,
tokens: map[string]harnesssecret.Secret{},
check: resolving,
open: true,
detail: `provider "acme" has no captured sign-in for credential binding "acme"`,
},
{
name: "api_key_env resolves through the env engine",
aliases: map[string]string{"default": "openai/gpt-5"},
providers: `{"openai":{"class":"openai","api_key_env":"GOOD_KEY"}}`,
check: resolving,
open: false,
},
{
name: "without the control plane the aliases alone decide",
aliases: map[string]string{"default": "openai/gpt-5"},
check: resolving,
open: false,
},
} {
t.Run(tt.name, func(t *testing.T) {
srv := &Server{Store: setupStore{}, Models: setupModels{aliases: tt.aliases}}
if tt.providers != "" || tt.bindings != "" {
srv.ControlPlane = setupControl{providers: tt.providers, bindings: tt.bindings}
}
srv.CheckSecret = tt.check
if tt.tokens != nil {
srv.HarnessSecrets = setupHarnessSecrets{tokens: tt.tokens}
}
step := modelStep(setupRequest(t, srv))
if !tt.open {
if step != nil {
t.Fatalf("Model step = %+v, want it complete (absent)", *step)
}
return
}
if step == nil {
t.Fatalf("Model step absent, want it open with detail %q", tt.detail)
}
if step.Done {
t.Fatalf("Model step done, want it open")
}
if !strings.Contains(step.Detail, tt.detail) {
t.Fatalf("Model step detail = %q, want it to contain %q", step.Detail, tt.detail)
}
})
}
}