Migrate OpenRouter catalog assets to keyed configuration
This commit is contained in:
241
catalog_test.go
241
catalog_test.go
@@ -2,11 +2,11 @@ package openrouter
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"io/fs"
|
||||
"path"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
@@ -14,188 +14,145 @@ import (
|
||||
)
|
||||
|
||||
func TestCatalogLayoutAndContents(t *testing.T) {
|
||||
fsys := FS()
|
||||
if fsys == nil {
|
||||
assets := FS()
|
||||
if assets == nil {
|
||||
t.Fatal("FS returned nil")
|
||||
}
|
||||
|
||||
manifestPath := Root + "/backend.json"
|
||||
manifestData, err := fs.ReadFile(fsys, manifestPath)
|
||||
backendPath := Root + "/backend.yml"
|
||||
backendData, err := fs.ReadFile(assets, backendPath)
|
||||
if err != nil {
|
||||
t.Fatalf("read manifest: %v", err)
|
||||
t.Fatalf("read backend: %v", err)
|
||||
}
|
||||
assertOpenRouterManifest(t, manifestData)
|
||||
assertBackend(t, backendData)
|
||||
|
||||
profilesRoot := Root + "/profiles"
|
||||
profileCount := 0
|
||||
ids := map[string]string{}
|
||||
err = fs.WalkDir(fsys, Root, func(path string, entry fs.DirEntry, walkErr error) error {
|
||||
ids := make(map[string]string)
|
||||
err = fs.WalkDir(assets, Root, func(assetPath string, entry fs.DirEntry, walkErr error) error {
|
||||
if walkErr != nil {
|
||||
return walkErr
|
||||
}
|
||||
if path == Root || path == profilesRoot || entry.IsDir() {
|
||||
if assetPath == Root || assetPath == profilesRoot || entry.IsDir() {
|
||||
return nil
|
||||
}
|
||||
if path == manifestPath {
|
||||
if assetPath == backendPath {
|
||||
if !entry.Type().IsRegular() {
|
||||
return fmt.Errorf("manifest is not a regular file")
|
||||
return fmt.Errorf("backend asset is not a regular file")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
if !strings.HasPrefix(path, profilesRoot+"/") {
|
||||
return fmt.Errorf("unexpected catalog entry %q", path)
|
||||
if !strings.HasPrefix(assetPath, profilesRoot+"/") {
|
||||
return fmt.Errorf("unexpected catalog entry %q", assetPath)
|
||||
}
|
||||
if !entry.Type().IsRegular() || !strings.HasSuffix(path, ".yml") {
|
||||
return fmt.Errorf("profile asset %q is not a regular .yml file", path)
|
||||
if !entry.Type().IsRegular() || !strings.HasSuffix(assetPath, ".yml") {
|
||||
return fmt.Errorf("profile asset %q is not a regular .yml file", assetPath)
|
||||
}
|
||||
|
||||
data, err := fs.ReadFile(fsys, path)
|
||||
data, err := fs.ReadFile(assets, assetPath)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
id := assertOpenRouterProfile(t, path, data)
|
||||
id := assertProfile(t, assetPath, data)
|
||||
if previous, found := ids[id]; found {
|
||||
return fmt.Errorf("duplicate profile ID %q in %s and %s", id, previous, path)
|
||||
return fmt.Errorf("duplicate profile ID %q in %s and %s", id, previous, assetPath)
|
||||
}
|
||||
ids[id] = path
|
||||
profileCount++
|
||||
ids[id] = assetPath
|
||||
return nil
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("validate catalog layout: %v", err)
|
||||
}
|
||||
if profileCount == 0 {
|
||||
t.Fatal("catalog contains no profiles")
|
||||
if len(ids) != 36 {
|
||||
t.Fatalf("profile inventory changed: got %d, want 36", len(ids))
|
||||
}
|
||||
}
|
||||
|
||||
func assertOpenRouterManifest(t *testing.T, data []byte) {
|
||||
func assertBackend(t *testing.T, data []byte) {
|
||||
t.Helper()
|
||||
|
||||
type manifest struct {
|
||||
SchemaVersion int `json:"schema_version"`
|
||||
ID string `json:"id"`
|
||||
Endpoint string `json:"endpoint"`
|
||||
APIKeyEnv string `json:"api_key_env"`
|
||||
ConcurrencyLimit int `json:"concurrency_limit"`
|
||||
QueueCapacity int `json:"queue_capacity"`
|
||||
ExtraParams json.RawMessage `json:"extra_params"`
|
||||
root := decodeMapping(t, "backend", data)
|
||||
backends := requireSingleMapping(t, "backend", root, "backends")
|
||||
if len(backends) != 1 || backends["openrouter"] == nil {
|
||||
t.Fatalf("backend asset must define only openrouter: %v", backends)
|
||||
}
|
||||
|
||||
decoder := json.NewDecoder(bytes.NewReader(data))
|
||||
decoder.DisallowUnknownFields()
|
||||
var value manifest
|
||||
if err := decoder.Decode(&value); err != nil {
|
||||
t.Fatalf("decode manifest: %v", err)
|
||||
}
|
||||
if err := requireJSONEnd(decoder); err != nil {
|
||||
t.Fatalf("decode manifest: %v", err)
|
||||
}
|
||||
if value.SchemaVersion != 1 ||
|
||||
value.ID != "openrouter" ||
|
||||
value.Endpoint != "https://openrouter.ai/api/v1" ||
|
||||
value.APIKeyEnv != "OPENROUTER_API_KEY" ||
|
||||
value.ConcurrencyLimit != 16 ||
|
||||
value.QueueCapacity != 1024 ||
|
||||
string(value.ExtraParams) != "null" {
|
||||
t.Fatalf("unexpected manifest: %#v", value)
|
||||
}
|
||||
}
|
||||
|
||||
func requireJSONEnd(decoder *json.Decoder) error {
|
||||
var trailing any
|
||||
if err := decoder.Decode(&trailing); errors.Is(err, io.EOF) {
|
||||
return nil
|
||||
} else if err != nil {
|
||||
return err
|
||||
}
|
||||
return errors.New("catalog manifest must contain exactly one JSON value")
|
||||
}
|
||||
|
||||
func assertOpenRouterProfile(t *testing.T, path string, data []byte) string {
|
||||
t.Helper()
|
||||
|
||||
var document yaml.Node
|
||||
decoder := yaml.NewDecoder(bytes.NewReader(data))
|
||||
if err := decoder.Decode(&document); err != nil {
|
||||
t.Fatalf("decode profile %s: %v", path, err)
|
||||
}
|
||||
if err := requireYAMLEnd(decoder); err != nil {
|
||||
t.Fatalf("decode profile %s: %v", path, err)
|
||||
}
|
||||
if document.Kind != yaml.DocumentNode || len(document.Content) != 1 || document.Content[0].Kind != yaml.MappingNode {
|
||||
t.Fatalf("profile %s must contain one mapping document", path)
|
||||
}
|
||||
|
||||
fields := yamlFields(document.Content[0])
|
||||
idField := fields["id"]
|
||||
if idField == nil {
|
||||
t.Fatalf("profile %s has no ID", path)
|
||||
}
|
||||
id := strings.TrimSpace(idField.Value)
|
||||
if id == "" {
|
||||
t.Fatalf("profile %s has a blank ID", path)
|
||||
}
|
||||
if fields["backend"] == nil || fields["backend"].Value != "openrouter" {
|
||||
t.Fatalf("profile %s does not select openrouter", path)
|
||||
}
|
||||
for _, field := range []string{"endpoint", "api_key_env", "api_key"} {
|
||||
if fields[field] != nil {
|
||||
t.Fatalf("profile %s contains prohibited %s field", path, field)
|
||||
definition := mappingFields(t, "backend", backends["openrouter"])
|
||||
for field, want := range map[string]string{
|
||||
"endpoint": "https://openrouter.ai/api/v1", "api_key_env": "OPENROUTER_API_KEY",
|
||||
"concurrency_limit": "16", "queue_capacity": "1024",
|
||||
} {
|
||||
value := definition[field]
|
||||
if value == nil || value.Value != want {
|
||||
t.Fatalf("backend %s: got %v, want %q", field, value, want)
|
||||
}
|
||||
}
|
||||
if extraParams := fields["extra_params"]; extraParams != nil {
|
||||
assertNoSecretKeys(t, path, extraParams)
|
||||
if len(definition) != 4 {
|
||||
t.Fatalf("unexpected backend fields: %v", definition)
|
||||
}
|
||||
return id
|
||||
}
|
||||
|
||||
func requireYAMLEnd(decoder *yaml.Decoder) error {
|
||||
func assertProfile(t *testing.T, assetPath string, data []byte) string {
|
||||
t.Helper()
|
||||
root := decodeMapping(t, assetPath, data)
|
||||
profiles := requireSingleMapping(t, assetPath, root, "profiles")
|
||||
if len(profiles) != 1 {
|
||||
t.Fatalf("profile asset %s must define exactly one ID", assetPath)
|
||||
}
|
||||
for id, entry := range profiles {
|
||||
if id == "" || id != strings.TrimSuffix(path.Base(assetPath), ".yml") {
|
||||
t.Fatalf("profile asset %s has unexpected ID %q", assetPath, id)
|
||||
}
|
||||
fields := mappingFields(t, assetPath, entry)
|
||||
if fields["backend"] == nil || fields["backend"].Value != "openrouter" {
|
||||
t.Fatalf("profile %s does not select openrouter", assetPath)
|
||||
}
|
||||
if fields["model"] == nil || strings.TrimSpace(fields["model"].Value) == "" {
|
||||
t.Fatalf("profile %s has no model", assetPath)
|
||||
}
|
||||
for _, obsolete := range []string{"id", "base_profile"} {
|
||||
if fields[obsolete] != nil {
|
||||
t.Fatalf("profile %s contains obsolete %s field", assetPath, obsolete)
|
||||
}
|
||||
}
|
||||
return id
|
||||
}
|
||||
panic("unreachable")
|
||||
}
|
||||
|
||||
func decodeMapping(t *testing.T, name string, data []byte) *yaml.Node {
|
||||
t.Helper()
|
||||
decoder := yaml.NewDecoder(bytes.NewReader(data))
|
||||
var document yaml.Node
|
||||
if err := decoder.Decode(&document); err != nil {
|
||||
t.Fatalf("decode %s: %v", name, err)
|
||||
}
|
||||
var trailing yaml.Node
|
||||
if err := decoder.Decode(&trailing); errors.Is(err, io.EOF) {
|
||||
return nil
|
||||
} else if err != nil {
|
||||
return err
|
||||
if err := decoder.Decode(&trailing); !errors.Is(err, io.EOF) {
|
||||
t.Fatalf("%s must contain exactly one YAML document: %v", name, err)
|
||||
}
|
||||
return errors.New("profile must contain exactly one YAML document")
|
||||
if document.Kind != yaml.DocumentNode || len(document.Content) != 1 || document.Content[0].Kind != yaml.MappingNode {
|
||||
t.Fatalf("%s must contain one mapping document", name)
|
||||
}
|
||||
return document.Content[0]
|
||||
}
|
||||
|
||||
func yamlFields(mapping *yaml.Node) map[string]*yaml.Node {
|
||||
fields := make(map[string]*yaml.Node, len(mapping.Content)/2)
|
||||
for index := 0; index+1 < len(mapping.Content); index += 2 {
|
||||
fields[mapping.Content[index].Value] = mapping.Content[index+1]
|
||||
func requireSingleMapping(t *testing.T, name string, parent *yaml.Node, key string) map[string]*yaml.Node {
|
||||
t.Helper()
|
||||
fields := mappingFields(t, name, parent)
|
||||
if len(fields) != 1 || fields[key] == nil {
|
||||
t.Fatalf("%s must contain only %s", name, key)
|
||||
}
|
||||
return mappingFields(t, name, fields[key])
|
||||
}
|
||||
|
||||
func mappingFields(t *testing.T, name string, node *yaml.Node) map[string]*yaml.Node {
|
||||
t.Helper()
|
||||
if node.Kind != yaml.MappingNode {
|
||||
t.Fatalf("%s must contain a mapping", name)
|
||||
}
|
||||
fields := make(map[string]*yaml.Node, len(node.Content)/2)
|
||||
for index := 0; index+1 < len(node.Content); index += 2 {
|
||||
key := node.Content[index].Value
|
||||
if _, exists := fields[key]; exists {
|
||||
t.Fatalf("%s repeats key %q", name, key)
|
||||
}
|
||||
fields[key] = node.Content[index+1]
|
||||
}
|
||||
return fields
|
||||
}
|
||||
|
||||
func assertNoSecretKeys(t *testing.T, path string, node *yaml.Node) {
|
||||
t.Helper()
|
||||
|
||||
forbidden := map[string]bool{
|
||||
"api_key": true,
|
||||
"apikey": true,
|
||||
"authorization": true,
|
||||
"credential": true,
|
||||
"credentials": true,
|
||||
"password": true,
|
||||
"secret": true,
|
||||
"token": true,
|
||||
"access_token": true,
|
||||
}
|
||||
var visit func(*yaml.Node)
|
||||
visit = func(current *yaml.Node) {
|
||||
if current.Kind == yaml.MappingNode {
|
||||
for index := 0; index+1 < len(current.Content); index += 2 {
|
||||
if forbidden[strings.ToLower(current.Content[index].Value)] {
|
||||
t.Fatalf("profile %s contains a prohibited extra_params key", path)
|
||||
}
|
||||
visit(current.Content[index+1])
|
||||
}
|
||||
return
|
||||
}
|
||||
for _, child := range current.Content {
|
||||
visit(child)
|
||||
}
|
||||
}
|
||||
visit(node)
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user