Files
promptkit/internal/validate/preparation_test.go

104 lines
3.9 KiB
Go

package validate
import (
"context"
"encoding/json"
"errors"
"reflect"
"testing"
"testing/fstest"
"go.maximumdirect.net/promptkit/internal/domain"
)
func TestPrepareInlineAndBoundDocuments(t *testing.T) {
for _, tc := range []struct {
name string
document any
file string
instance string
status domain.ValidationStatus
}{
{"object", map[string]any{"type": "object", "required": []any{"x"}}, `{"type":"object","required":["x"]}`, `{"x":1}`, domain.ValidationPassed},
{"reject object", map[string]any{"type": "object"}, `{"type":"object"}`, `1`, domain.ValidationFailed},
{"true", true, `true`, `null`, domain.ValidationPassed},
{"false", false, `false`, `null`, domain.ValidationFailed},
} {
t.Run(tc.name, func(t *testing.T) {
validator := NewValidator()
contract := domain.OutputContract{ValidationMode: domain.ValidationJSONSchema, Schema: tc.document}
inline, err := validator.PrepareValidation(context.Background(), Input{Contract: contract})
if err != nil {
t.Fatal(err)
}
contract.Schema = nil
file := &domain.ResourceBinding{FS: fstest.MapFS{"schema.json": {Data: []byte(tc.file)}}, Path: "schema.json"}
bound, err := validator.PrepareValidation(context.Background(), Input{Contract: contract, File: file})
if err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(inline.SchemaDocument(), bound.SchemaDocument()) {
t.Fatalf("documents differ: %#v %#v", inline.SchemaDocument(), bound.SchemaDocument())
}
for _, plan := range []PreparedValidation{inline, bound} {
result, err := plan.Validate(context.Background(), &domain.Artifact{Body: []byte(tc.instance)})
if err != nil || result.Status != tc.status {
t.Fatalf("result = %+v, %v", result, err)
}
}
})
}
}
func TestPrepareSchemaReferencesAndDialects(t *testing.T) {
for _, tc := range []struct {
name string
document any
valid bool
}{
{"internal ref", map[string]any{"$defs": map[string]any{"n": map[string]any{"type": "integer"}}, "$ref": "#/$defs/n"}, true},
{"external ref", map[string]any{"$ref": "https://example.invalid/schema"}, false},
{"invalid schema", map[string]any{"type": "invalid"}, false},
{"invalid dialect", map[string]any{"$schema": "https://invalid.example/schema"}, false},
} {
t.Run(tc.name, func(t *testing.T) {
_, err := NewValidator().PrepareValidation(context.Background(), Input{Contract: domain.OutputContract{ValidationMode: domain.ValidationJSONSchema, Schema: tc.document}})
if (err == nil) != tc.valid {
t.Fatalf("preparation error = %v", err)
}
})
}
}
func TestPrepareBoundSchemaPreservesNumbersAndCancellation(t *testing.T) {
file := &domain.ResourceBinding{FS: fstest.MapFS{"schema.json": {Data: []byte(`{"const":9007199254740993}`)}}, Path: "schema.json"}
input := Input{Contract: domain.OutputContract{ValidationMode: domain.ValidationJSONSchema}, File: file}
plan, err := NewValidator().PrepareValidation(context.Background(), input)
if err != nil {
t.Fatal(err)
}
if got := plan.SchemaDocument().(map[string]any)["const"]; got != json.Number("9007199254740993") {
t.Fatalf("number = %#v", got)
}
ctx, cancel := context.WithCancel(context.Background())
cancel()
if _, err := NewValidator().PrepareValidation(ctx, input); !errors.Is(err, context.Canceled) {
t.Fatalf("cancellation = %v", err)
}
}
func TestExternalReferencesDoNotOpenAdditionalResources(t *testing.T) {
files := &countingSchemaFS{FS: fstest.MapFS{
"root.json": {Data: []byte(`{"$ref":"child.json"}`)},
"child.json": {Data: []byte(`{"type":"string"}`)},
}}
input := Input{Contract: domain.OutputContract{ValidationMode: domain.ValidationJSONSchema}, File: &domain.ResourceBinding{FS: files, Path: "root.json"}}
_, err := NewValidator().PrepareValidation(context.Background(), input)
if err == nil {
t.Fatal("external reference was accepted")
}
if opens := files.opens.Load(); opens != 1 {
t.Fatalf("schema file opens = %d, want one", opens)
}
}