Files
ai/controllers/provider_admin_test.go
zeekayandHanzo Dev a222079c0c Third-party chat is served through OpenRouter only
The OpenRouter family now resolves 83 short ids callers already send (gpt-4o,
claude-sonnet-4-6, deepseek-v4-pro, …) to the OpenRouter SKU
of the same model. The alias is read inside the family's lookup, so it is
routed, priced, gated, metered and given the data-collection terms of that SKU;
the vendor is sent its own id and the answer still names the id the caller
sent. An alias whose SKU OpenRouter stops listing resolves to nothing.

The static route table and conf/models.yaml drop every DigitalOcean, Fireworks,
OpenAI-direct and Anthropic chat route that now has an alias, and the routes
that were already OpenRouter ids (openai/gpt-4o, anthropic/claude-sonnet-4, …).
They keep what OpenRouter does not serve: speech, embeddings, image, video,
DigitalOcean's routers, and the chat models with no priced OpenRouter
equivalent. The failover tail sends the catalog's own id for an upstream the
family knows as an alias.

Ids that named the relay a model used to go through (openai-gpt-4o,
fireworks/*, openai-direct/*) get no alias: they were a vendor's spelling, not a
model, and a caller moves to the model's own id.

Co-authored-by: Hanzo Dev <[email protected]>
2026-09-24 10:41:50 -07:00

280 lines
10 KiB
Go

// Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package controllers
import (
"encoding/json"
"net/http"
"strings"
"testing"
"github.com/hanzoai/ai/internal/authtest"
iam "github.com/hanzoai/ai/internal/iam"
"github.com/hanzoai/ai/object"
)
// ── adminProviderView projection ────────────────────────────────────────────
// TestToAdminProviderView_FieldsAndFlags verifies the projection maps State →
// enabled, IsDefault → primary, resolves keyPresent as a boolean, and carries the
// model count from the supplied map.
func TestToAdminProviderView_FieldsAndFlags(t *testing.T) {
// KMS disabled + no env key → a kms:// ref is fail-closed absent.
t.Setenv("HANZO_API_KEY", "")
p := &object.Provider{
Name: "do-ai",
DisplayName: "DigitalOcean AI (GenAI)",
Category: "Model",
Type: "DigitalOcean",
ProviderUrl: "https://inference.do-ai.run/v1",
ClientSecret: "kms://DO_AI_API_KEY_MISSING_FOR_TEST",
State: "Active",
IsDefault: true,
}
counts := map[string]int{"do-ai": 122}
v := toAdminProviderView(p, counts)
if v.Name != "do-ai" {
t.Errorf("Name = %q, want do-ai", v.Name)
}
if v.DisplayName != "DigitalOcean AI (GenAI)" {
t.Errorf("DisplayName = %q", v.DisplayName)
}
if v.Type != "DigitalOcean" {
t.Errorf("Type = %q, want DigitalOcean", v.Type)
}
if !v.Enabled {
t.Error("Enabled = false for State=Active, want true")
}
if !v.Primary {
t.Error("Primary = false for IsDefault=true, want true")
}
if v.KeyPresent {
t.Error("KeyPresent = true for an unresolved kms:// ref (KMS off), want false")
}
if v.ModelCount != 122 {
t.Errorf("ModelCount = %d, want 122", v.ModelCount)
}
if v.ProviderURL != "https://inference.do-ai.run/v1" {
t.Errorf("ProviderURL = %q", v.ProviderURL)
}
}
func TestToAdminProviderView_DisabledAndKeyFromEnv(t *testing.T) {
// Env-first resolution → keyPresent true; State != Active → enabled false;
// IsDefault false → primary false.
t.Setenv("FIREWORKS_API_KEY_TEST_PRESENT", "fw-key")
p := &object.Provider{
Name: "fireworks",
Category: "Model",
Type: "Fireworks",
ClientSecret: "kms://FIREWORKS_API_KEY_TEST_PRESENT",
State: "Disabled",
IsDefault: false,
}
v := toAdminProviderView(p, map[string]int{})
if v.Enabled {
t.Error("Enabled = true for State=Disabled, want false")
}
if v.Primary {
t.Error("Primary = true for IsDefault=false, want false")
}
if !v.KeyPresent {
t.Error("KeyPresent = false for a kms:// ref resolvable via env, want true")
}
if v.ModelCount != 0 {
t.Errorf("ModelCount = %d for a provider absent from the count map, want 0", v.ModelCount)
}
}
// TestAdminProviderView_NeverSerializesSecrets is the security regression guard:
// the JSON of the management view must NOT contain any secret-bearing key. If a
// future edit adds ClientSecret/ProviderKey to the struct, this fails.
func TestAdminProviderView_NeverSerializesSecrets(t *testing.T) {
t.Setenv("SUPER_SECRET_TEST_KEY", "sk-must-not-leak-123")
p := &object.Provider{
Name: "do-ai",
Category: "Model",
ClientSecret: "kms://SUPER_SECRET_TEST_KEY",
ProviderKey: "sk-provider-key-must-not-leak",
UserKey: "user-key-must-not-leak",
SignKey: "sign-key-must-not-leak",
State: "Active",
}
v := toAdminProviderView(p, map[string]int{"do-ai": 1})
// Sanity: env-first means keyPresent should be true here.
if !v.KeyPresent {
t.Fatal("precondition: expected keyPresent true via env resolution")
}
blob, err := json.Marshal(v)
if err != nil {
t.Fatalf("marshal: %v", err)
}
s := string(blob)
for _, forbidden := range []string{
"sk-must-not-leak-123", // resolved kms value
"kms://SUPER_SECRET_TEST_KEY", // the raw ref
"sk-provider-key-must-not-leak", // providerKey
"user-key-must-not-leak", // userKey
"sign-key-must-not-leak", // signKey
"clientSecret", "providerKey", // secret-bearing field names
"userKey", "signKey", "configText",
} {
if strings.Contains(s, forbidden) {
t.Errorf("admin provider view JSON leaked %q: %s", forbidden, s)
}
}
// Positive: the boolean signal IS present.
if !strings.Contains(s, `"keyPresent":true`) {
t.Errorf("expected keyPresent:true in JSON, got: %s", s)
}
}
// Note: the exactly-one-primary transition now lives in object.SetPrimaryModelProvider
// (one atomic, promote-first UPDATE pair — no in-memory diff to loop over). Its
// ordering + WHERE clauses are regression-tested in
// object/provider_default_atomic_test.go against the built SQL, without a DB.
// ── C-1 controller self-guard (RequireSuperAdmin) ──────────────────────────
//
// Belt-AND-suspenders: even if the authz filter is ever bypassed, the three admin
// controllers call c.RequireSuperAdmin() FIRST and refuse. These tests exercise
// that guard directly (session principal), asserting fail-closed 401/403 and pass
// for a super admin — the SAME policy as the filter (util.IsSuperAdmin).
// ctrlFakeSession (the minimal in-memory session.Store used to carry a test
// principal without a live session manager) is defined once in index_auth_test.go
// and shared across the package's controller tests — reused here to keep a single
// definition (it collided when this file, from the provider-admin PR, was rebased
// onto the branch that introduced index_auth_test.go).
// toggling is a request at the provider-admin toggle, carrying auth. The endpoint is
// named once here; who is calling is whatever credential the caller presents.
func toggling(auth string) *ApiController {
return presenting(visit(http.MethodPost, "/v1/admin/providers/toggle"), auth)
}
func TestRequireSuperAdmin_NoPrincipal401(t *testing.T) {
c := toggling("")
if c.RequireSuperAdmin() {
t.Error("RequireSuperAdmin() = true for no principal, want false (deny)")
}
if answered(c) != http.StatusUnauthorized {
t.Errorf("no-principal status = %d, want 401", answered(c))
}
}
func TestRequireSuperAdmin_OrgAdminForbidden403(t *testing.T) {
orgAdmin := &iam.User{Owner: "maxpower", Name: "dave", IsAdmin: true}
c := toggling(authtest.Bearer(t, *orgAdmin))
if c.RequireSuperAdmin() {
t.Error("RequireSuperAdmin() = true for an ORG admin, want false (not a platform admin)")
}
if answered(c) != http.StatusForbidden {
t.Errorf("org-admin status = %d, want 403", answered(c))
}
}
func TestRequireSuperAdmin_SuperAdminPasses(t *testing.T) {
superAdmin := &iam.User{Owner: "admin", Name: "admin", IsAdmin: true}
c := toggling(authtest.Bearer(t, *superAdmin))
if !c.RequireSuperAdmin() {
t.Error("RequireSuperAdmin() = false for a super admin, want true (pass)")
}
// Pass path writes nothing (the handler continues).
if sent(c) != "" {
t.Errorf("super-admin pass wrote a body %q, want none", sent(c))
}
}
// ── stateForEnabled ─────────────────────────────────────────────────────────
func TestStateForEnabled(t *testing.T) {
if got := stateForEnabled(true); got != "Active" {
t.Errorf("stateForEnabled(true) = %q, want Active", got)
}
if got := stateForEnabled(false); got != "Disabled" {
t.Errorf("stateForEnabled(false) = %q, want Disabled", got)
}
}
// ── modelCountByProvider ────────────────────────────────────────────────────
// TestModelCountByProvider_MatchesStaticMap verifies the count helper agrees
// with an independent count over the static map — proving it is computed from the
// route table, not hardcoded. (In the unit env no YAML config is loaded, so the
// helper uses the static modelRoutes map.)
func TestModelCountByProvider_MatchesStaticMap(t *testing.T) {
if GetModelConfig() != nil {
t.Skip("YAML model config loaded; static-map parity check not applicable")
}
got := modelCountByProvider()
// Independent recount over the same source.
want := map[string]int{}
for _, route := range modelRoutes {
want[route.providerName]++
}
if len(got) != len(want) {
t.Errorf("provider count keys = %d, want %d (got=%v want=%v)", len(got), len(want), got, want)
}
for prov, n := range want {
if got[prov] != n {
t.Errorf("modelCountByProvider()[%q] = %d, want %d", prov, got[prov], n)
}
}
// Every count must equal the number of routes whose providerName == prov —
// asserted here for the known providers so drift in the table is visible.
for _, prov := range []string{"do-ai", "speech"} {
n := 0
for _, route := range modelRoutes {
if route.providerName == prov {
n++
}
}
if got[prov] != n {
t.Errorf("count for %q = %d, recount = %d", prov, got[prov], n)
}
if n == 0 {
t.Errorf("expected at least one route for provider %q", prov)
}
}
}
// TestModelCountByProvider_NoStaticZenRoute documents that ai holds no static zen
// route: the zen family is discovered from zen's /v1/models and routed via the
// dynamic zen passthrough, so modelCountByProvider (which counts the static table)
// reports no "zen" provider, while raw models still count under their provider.
func TestModelCountByProvider_NoStaticZenRoute(t *testing.T) {
if GetModelConfig() != nil {
t.Skip("YAML model config loaded; static-map behavior check not applicable")
}
counts := modelCountByProvider()
if _, ok := counts["zen"]; ok {
t.Errorf("no static route should target providerName=\"zen\" (zen is a dynamic passthrough); got count=%d", counts["zen"])
}
if counts["do-ai"] == 0 {
t.Error("expected do-ai to serve at least one static route")
}
// A raw do-ai model resolves to the do-ai provider.
if r := resolveModelRoute("bge-m3"); r == nil || r.providerName != "do-ai" {
t.Errorf("bge-m3 route = %+v, want providerName=do-ai", r)
}
}