129 lines
3.7 KiB
Go
129 lines
3.7 KiB
Go
package llm
|
|
|
|
import (
|
|
"encoding/json"
|
|
"sort"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func TestLookupResponseSchemaSucceedsForRegisteredSchemas(t *testing.T) {
|
|
tests := []ResponseSchemaKey{
|
|
TestArtifactSchemaKey,
|
|
TestValidatorDecisionSchemaKey,
|
|
}
|
|
|
|
for _, key := range tests {
|
|
t.Run(string(key), func(t *testing.T) {
|
|
schema, ok := LookupResponseSchema(key)
|
|
if !ok {
|
|
t.Fatalf("expected schema for key %q", key)
|
|
}
|
|
if schema.Key != key {
|
|
t.Fatalf("unexpected key: got %q want %q", schema.Key, key)
|
|
}
|
|
if schema.ID == "" || schema.Version == "" || schema.Name == "" {
|
|
t.Fatalf("expected schema metadata, got %+v", schema)
|
|
}
|
|
if !strings.HasPrefix(schema.SHA256, "sha256:") {
|
|
t.Fatalf("expected prefixed hash, got %q", schema.SHA256)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestLookupResponseSchemaUnknownReturnsFalse(t *testing.T) {
|
|
if schema, ok := LookupResponseSchema("unknown"); ok {
|
|
t.Fatalf("expected unknown schema lookup to fail, got %+v", schema)
|
|
}
|
|
}
|
|
|
|
func TestLookupResponseSchemaDNDSpellsIsNotFrameworkRegistered(t *testing.T) {
|
|
if schema, ok := LookupResponseSchema("dnd_spells"); ok {
|
|
t.Fatalf("expected D&D spells schema lookup to fail in framework registry, got %+v", schema)
|
|
}
|
|
}
|
|
|
|
func TestMustLookupResponseSchemaPanicsForUnknownKey(t *testing.T) {
|
|
defer func() {
|
|
if recover() == nil {
|
|
t.Fatalf("expected panic")
|
|
}
|
|
}()
|
|
|
|
_ = MustLookupResponseSchema("unknown")
|
|
}
|
|
|
|
func TestRegisteredResponseSchemasSortedByKey(t *testing.T) {
|
|
schemas := RegisteredResponseSchemas()
|
|
if len(schemas) != 2 {
|
|
t.Fatalf("expected two schemas, got %d", len(schemas))
|
|
}
|
|
|
|
keys := make([]string, len(schemas))
|
|
seen := make(map[ResponseSchemaKey]bool, len(schemas))
|
|
for i, schema := range schemas {
|
|
keys[i] = string(schema.Key)
|
|
seen[schema.Key] = true
|
|
}
|
|
if !sort.StringsAreSorted(keys) {
|
|
t.Fatalf("expected sorted keys, got %v", keys)
|
|
}
|
|
if !seen[TestArtifactSchemaKey] || !seen[TestValidatorDecisionSchemaKey] {
|
|
t.Fatalf("registered schemas = %v, want test schemas", keys)
|
|
}
|
|
}
|
|
|
|
func TestResponseSchemaContentIsValidJSON(t *testing.T) {
|
|
for _, schema := range RegisteredResponseSchemas() {
|
|
if !json.Valid(schema.JSONSchema) {
|
|
t.Fatalf("schema %q has invalid JSON: %s", schema.Key, schema.JSONSchema)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestResponseSchemaJSONIsMutationSafe(t *testing.T) {
|
|
for _, key := range []ResponseSchemaKey{TestArtifactSchemaKey, TestValidatorDecisionSchemaKey} {
|
|
t.Run(string(key), func(t *testing.T) {
|
|
first := MustLookupResponseSchema(key)
|
|
first.JSONSchema[0] = '['
|
|
|
|
second := MustLookupResponseSchema(key)
|
|
if !json.Valid(second.JSONSchema) {
|
|
t.Fatalf("schema JSON was mutated: %s", second.JSONSchema)
|
|
}
|
|
if len(second.JSONSchema) > 0 && second.JSONSchema[0] == '[' {
|
|
t.Fatalf("schema JSON did not use defensive copy")
|
|
}
|
|
|
|
registered := RegisteredResponseSchemas()
|
|
for i := range registered {
|
|
if registered[i].Key == key {
|
|
registered[i].JSONSchema[0] = '['
|
|
}
|
|
}
|
|
again := MustLookupResponseSchema(key)
|
|
if !json.Valid(again.JSONSchema) || again.JSONSchema[0] == '[' {
|
|
t.Fatalf("registered schema JSON did not use defensive copy")
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestResponseSchemaDiagnosticsMapOmitsRawSchemaContent(t *testing.T) {
|
|
schema := MustLookupResponseSchema(TestValidatorDecisionSchemaKey)
|
|
diagnostics := schema.DiagnosticsMap()
|
|
|
|
for _, key := range []string{"id", "version", "name", "sha256"} {
|
|
if diagnostics[key] == "" {
|
|
t.Fatalf("expected diagnostics key %q, got %#v", key, diagnostics)
|
|
}
|
|
}
|
|
if _, ok := diagnostics["json_schema"]; ok {
|
|
t.Fatalf("diagnostics should omit raw schema content: %#v", diagnostics)
|
|
}
|
|
if _, ok := diagnostics["JSONSchema"]; ok {
|
|
t.Fatalf("diagnostics should omit raw schema content: %#v", diagnostics)
|
|
}
|
|
}
|