// Copyright 2025 The JSON Schema Go Project Authors. All rights reserved.
// Use of this source code is governed by an MIT-style
// license that can be found in the LICENSE file.
package jsonschema
import (
"encoding/json"
"fmt"
"net/url"
"os"
"path/filepath"
"reflect"
"strings"
"testing"
"github.com/google/go-cmp/cmp"
"github.com/google/go-cmp/cmp/cmpopts"
)
// The test for validation uses the official test suite, expressed as a set of JSON files.
// Each file is an array of group objects.
// A testGroup consists of a schema and some tests on it.
type testGroup struct {
Description string
Schema *Schema
Tests []test
}
// A test consists of a JSON instance to be validated and the expected result.
type test struct {
Description string
Data any
Valid bool
ErrContains string
}
func TestValidateDraft2020_12(t *testing.T) {
files, err := filepath.Glob(filepath.FromSlash("testdata/draft2020-12/*.json"))
if err != nil {
t.Fatal(err)
}
if len(files) == 0 {
t.Fatal("no files")
}
testValidate(t, files, "")
}
func TestValidateDraft7(t *testing.T) {
files, err := filepath.Glob(filepath.FromSlash("testdata/draft7/*.json"))
if err != nil {
t.Fatal(err)
}
if len(files) == 0 {
t.Fatal("no files")
}
testValidate(t, files, "https://json-schema.org/draft-07/schema#")
}
func testValidate(t *testing.T, files []string, draft string) {
for _, file := range files {
base := filepath.Base(file)
t.Run(base, func(t *testing.T) {
data, err := os.ReadFile(file)
if err != nil {
t.Fatal(err)
}
var groups []testGroup
if err := json.Unmarshal(data, &groups); err != nil {
t.Fatal(err)
}
for _, g := range groups {
t.Run(g.Description, func(t *testing.T) {
if g.Schema.Schema == "" {
g.Schema.Schema = draft
}
rs, err := g.Schema.Resolve(&ResolveOptions{Loader: loadRemote})
if err != nil {
t.Fatal(err)
}
for _, test := range g.Tests {
t.Run(test.Description, func(t *testing.T) {
err = rs.Validate(test.Data)
if err != nil && test.Valid {
t.Errorf("wanted success, but failed with: %v", err)
}
if err == nil && !test.Valid {
t.Error("succeeded but wanted failure")
}
if err != nil && test.ErrContains != "" {
if !strings.Contains(err.Error(), test.ErrContains) {
t.Errorf("got error %q, want containing %q", err, test.ErrContains)
}
}
if t.Failed() {
t.Errorf("schema: %s", g.Schema.json())
t.Fatalf("instance: %v (%[1]T)", test.Data)
}
})
}
})
}
})
}
}
func TestValidateErrors(t *testing.T) {
schema := &Schema{
PrefixItems: []*Schema{{Contains: &Schema{Type: "integer"}}},
}
rs, err := schema.Resolve(nil)
if err != nil {
t.Fatal(err)
}
err = rs.Validate([]any{[]any{"1"}})
want := "prefixItems/0"
if err == nil || !strings.Contains(err.Error(), want) {
t.Errorf("error:\n%s\ndoes not contain %q", err, want)
}
}
func TestValidateDefaults(t *testing.T) {
s := &Schema{
Properties: map[string]*Schema{
"a": {Type: "integer", Default: mustMarshal(1)},
"b": {Type: "string", Default: mustMarshal("s")},
},
Default: mustMarshal(map[string]any{"a": 1, "b": "two"}),
}
if _, err := s.Resolve(&ResolveOptions{ValidateDefaults: true}); err != nil {
t.Fatal(err)
}
s = &Schema{
Properties: map[string]*Schema{
"a": {Type: "integer", Default: mustMarshal(3)},
"b": {Type: "string", Default: mustMarshal("s")},
},
Default: mustMarshal(map[string]any{"a": 1, "b": 2}),
}
_, err := s.Resolve(&ResolveOptions{ValidateDefaults: true})
want := `has type "integer", want "string"`
if err == nil || !strings.Contains(err.Error(), want) {
t.Errorf("Resolve returned error %q, want %q", err, want)
}
}
func TestApplyDefaults(t *testing.T) {
schema := &Schema{
Properties: map[string]*Schema{
"A": {Default: mustMarshal(1)},
"B": {Default: mustMarshal(2)},
"C": {Default: mustMarshal(3)},
},
Required: []string{"C"},
}
rs, err := schema.Resolve(&ResolveOptions{ValidateDefaults: true})
if err != nil {
t.Fatal(err)
}
for _, tt := range []struct {
instancep any // pointer to instance value
want any // desired value (not a pointer)
}{
{
&map[string]any{"B": 0},
map[string]any{
"A": float64(1), // filled from default
"B": 0, // untouched: it was already there
// "C" not added: it is required (Validate will catch that)
},
},
} {
if err := rs.ApplyDefaults(tt.instancep); err != nil {
t.Fatal(err)
}
got := reflect.ValueOf(tt.instancep).Elem().Interface() // dereference the pointer
if !reflect.DeepEqual(got, tt.want) {
t.Errorf("\ngot %#v\nwant %#v", got, tt.want)
}
}
}
func TestApplyNestedDefaults(t *testing.T) {
base := &Schema{
Type: "object",
Properties: map[string]*Schema{
"A": {
Type: "object",
Properties: map[string]*Schema{
"B": {Type: "string", Default: mustMarshal("foo")},
},
},
},
}
// Variant where parent A has its own default object; recursion should still fill B.
withParentDefault := &Schema{
Type: "object",
Properties: map[string]*Schema{
"A": {
Type: "object",
Default: mustMarshal(map[string]any{"X": 1}),
Properties: map[string]*Schema{
"B": {Type: "string", Default: mustMarshal("foo")},
},
},
},
}
for _, tc := range []struct {
name string
schema *Schema
instancep any
want any
}{
{
name: "MapMissingParent",
schema: base,
instancep: &map[string]any{},
want: map[string]any{"A": map[string]any{"B": "foo"}},
},
{
name: "MapEmptyParent",
schema: base,
instancep: &map[string]any{"A": map[string]any{}},
want: map[string]any{"A": map[string]any{"B": "foo"}},
},
{
name: "MapParentHasDefaultObjectMissing",
schema: withParentDefault,
instancep: &map[string]any{},
want: map[string]any{"A": map[string]any{"X": float64(1), "B": "foo"}},
},
{
name: "MapParentHasDefaultObjectPresent",
schema: withParentDefault,
instancep: &map[string]any{"A": map[string]any{}},
// Parent default is applied only when the property is missing, so
// with the key present (even if empty), we apply only the nested defaults.
want: map[string]any{"A": map[string]any{"B": "foo"}},
},
{
name: "MapValueMapMissingParentTyped",
schema: base,
instancep: &map[string]map[string]any{},
want: map[string]map[string]any{"A": {"B": "foo"}},
},
} {
t.Run(tc.name, func(t *testing.T) {
rs, err := tc.schema.Resolve(&ResolveOptions{ValidateDefaults: true})
if err != nil {
t.Fatal(err)
}
if err := rs.ApplyDefaults(tc.instancep); err != nil {
t.Fatal(err)
}
got := reflect.ValueOf(tc.instancep).Elem().Interface()
if !reflect.DeepEqual(got, tc.want) {
t.Errorf("nested defaults:\n got %#v\n want %#v", got, tc.want)
}
})
}
}
func TestStructInstance(t *testing.T) {
instance := struct {
I int
B bool `json:"b"`
P *int // either missing or nil
u int // unexported: not a property
}{1, true, nil, 0}
for _, tt := range []struct {
s Schema
want bool
}{
{
Schema{MinProperties: Ptr(4)},
false,
},
{
Schema{MinProperties: Ptr(3)},
true, // P interpreted as present
},
{
Schema{MaxProperties: Ptr(1)},
false,
},
{
Schema{MaxProperties: Ptr(2)},
true, // P interpreted as absent
},
{
Schema{Required: []string{"i"}}, // the name is "I"
false,
},
{
Schema{Required: []string{"B"}}, // the name is "b"
false,
},
{
Schema{PropertyNames: &Schema{MinLength: Ptr(2)}},
false,
},
{
Schema{Properties: map[string]*Schema{"b": {Type: "boolean"}}},
true,
},
{
Schema{Properties: map[string]*Schema{"b": {Type: "number"}}},
false,
},
{
Schema{Required: []string{"I"}},
true,
},
{
Schema{Required: []string{"I", "P"}},
true, // P interpreted as present
},
{
Schema{Required: []string{"I", "P"}, Properties: map[string]*Schema{"P": {Type: "number"}}},
false, // P interpreted as present, but not a number
},
{
Schema{Required: []string{"I"}, Properties: map[string]*Schema{"P": {Type: "number"}}},
true, // P not required, so interpreted as absent
},
{
Schema{Required: []string{"I"}, AdditionalProperties: falseSchema()},
false,
},
{
Schema{DependentRequired: map[string][]string{"b": {"u"}}},
false,
},
{
Schema{DependentSchemas: map[string]*Schema{"b": falseSchema()}},
false,
},
{
Schema{UnevaluatedProperties: falseSchema()},
false,
},
} {
res, err := tt.s.Resolve(nil)
if err != nil {
t.Fatal(err)
}
err = res.Validate(instance)
// Validating a struct always fails.
if err == nil {
t.Error("struct validation succeeded")
}
}
}
func TestStructEmbedding(t *testing.T) {
// For exported pointer embedding
type Apple struct {
ID string `json:"id"`
Name string `json:"name"`
}
type Banana struct {
*Apple // Pointer embedded - should flatten.
Extra string `json:"extra"`
}
// For unexported pointer embedding
type cranberry struct {
ID string `json:"id"`
Name string `json:"name"`
}
type Durian struct {
*cranberry // Pointer embedded - should flatten.
Extra string `json:"extra"`
}
// For exported value embedding
type Elderberry struct {
ID string `json:"id"`
Name string `json:"name"`
}
type Fig struct {
Elderberry // Value embedded - should flatten.
Extra string `json:"extra"`
}
// For unexported value embedding
type grape struct {
ID string `json:"id"`
Name string `json:"name"`
}
type Honeyberry struct {
grape // Value embedded - should flatten.
Extra string `json:"extra"`
}
// For outer field shadowing a pointer embed
type Inner struct {
Conflict string `json:"conflict_field"` // This string field should be ignored.
InnerOnly string `json:"inner_only"`
}
type Outer struct {
*Inner
Conflict int `json:"conflict_field"` // This int field should take precedence.
}
testCases := []struct {
name string
targetType reflect.Type
wantSchema *Schema
validInstance any
}{
{
name: "Slice",
targetType: reflect.TypeOf([]Banana{}),
wantSchema: &Schema{
Types: []string{"null", "array"},
Items: &Schema{
Type: "object",
Properties: map[string]*Schema{
"id": {Type: "string"},
"name": {Type: "string"},
"extra": {Type: "string"},
},
Required: []string{"id", "name", "extra"},
AdditionalProperties: falseSchema(),
PropertyOrder: []string{"id", "name", "extra"},
},
},
validInstance: []Banana{
{Apple: &Apple{ID: "foo1", Name: "Test Foo 2"}, Extra: "additional data 1"},
{Apple: &Apple{ID: "foo2", Name: "Test Foo 2"}, Extra: "additional data 2"},
},
},
{
name: "Array",
targetType: reflect.TypeOf([2]Banana{}),
wantSchema: &Schema{
Type: "array",
MinItems: Ptr(2),
MaxItems: Ptr(2),
Items: &Schema{
Type: "object",
Properties: map[string]*Schema{
"id": {Type: "string"},
"name": {Type: "string"},
"extra": {Type: "string"},
},
Required: []string{"id", "name", "extra"},
AdditionalProperties: falseSchema(),
PropertyOrder: []string{"id", "name", "extra"},
},
},
validInstance: [2]Banana{
{Apple: &Apple{ID: "foo1", Name: "Test Foo 2"}, Extra: "additional data 1"},
{Apple: &Apple{ID: "foo2", Name: "Test Foo 2"}, Extra: "additional data 2"},
},
},
{
name: "UnExportedPointer",
targetType: reflect.TypeOf([]Durian{}),
wantSchema: &Schema{
Types: []string{"null", "array"},
Items: &Schema{
Type: "object",
Properties: map[string]*Schema{
"id": {Type: "string"},
"name": {Type: "string"},
"extra": {Type: "string"},
},
Required: []string{"id", "name", "extra"},
AdditionalProperties: falseSchema(),
PropertyOrder: []string{"id", "name", "extra"},
},
},
validInstance: []Durian{
{cranberry: &cranberry{ID: "foo1", Name: "Test Foo 2"}, Extra: "additional data 1"},
{cranberry: &cranberry{ID: "foo2", Name: "Test Foo 2"}, Extra: "additional data 2"},
},
},
{
name: "ExportedValue",
targetType: reflect.TypeOf([]Fig{}),
wantSchema: &Schema{
Types: []string{"null", "array"},
Items: &Schema{
Type: "object",
Properties: map[string]*Schema{
"id": {Type: "string"},
"name": {Type: "string"},
"extra": {Type: "string"},
},
Required: []string{"id", "name", "extra"},
AdditionalProperties: falseSchema(),
PropertyOrder: []string{"id", "name", "extra"},
},
},
validInstance: []Fig{
{Elderberry: Elderberry{ID: "foo1", Name: "Test Foo 2"}, Extra: "additional data 1"},
{Elderberry: Elderberry{ID: "foo2", Name: "Test Foo 2"}, Extra: "additional data 2"},
},
},
{
name: "UnExportedValue",
targetType: reflect.TypeOf([]Honeyberry{}),
wantSchema: &Schema{
Types: []string{"null", "array"},
Items: &Schema{
Type: "object",
Properties: map[string]*Schema{
"id": {Type: "string"},
"name": {Type: "string"},
"extra": {Type: "string"},
},
Required: []string{"id", "name", "extra"},
AdditionalProperties: falseSchema(),
PropertyOrder: []string{"id", "name", "extra"},
},
},
validInstance: []Honeyberry{
{grape: grape{ID: "foo1", Name: "Test Foo 2"}, Extra: "additional data 1"},
{grape: grape{ID: "foo2", Name: "Test Foo 2"}, Extra: "additional data 2"},
},
},
{
name: "FieldShadowing",
targetType: reflect.TypeOf(Outer{}),
wantSchema: &Schema{
Type: "object",
Properties: map[string]*Schema{
// The "integer" from the Outer struct takes precedence.
"conflict_field": {Type: "integer"},
// The non-conflicting field from the Inner struct is still present.
"inner_only": {Type: "string"},
},
Required: []string{"inner_only", "conflict_field"},
AdditionalProperties: falseSchema(),
PropertyOrder: []string{"inner_only", "conflict_field"},
},
validInstance: Outer{Inner: &Inner{InnerOnly: "data"}, Conflict: 123},
},
}
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
schema, err := ForType(tc.targetType, &ForOptions{})
if err != nil {
t.Fatalf("ForType() returned an unexpected error: %v", err)
}
if diff := cmp.Diff(tc.wantSchema, schema, cmpopts.IgnoreUnexported(Schema{})); diff != "" {
t.Fatalf("Schema mismatch (-want +got):\n%s", diff)
}
resolved, err := schema.Resolve(nil)
if err != nil {
t.Fatalf("schema.Resolve() failed: %v", err)
}
// Validate a correct instance against the generated schema.
// Struct validation always fails.
if err := resolved.Validate(tc.validInstance); err == nil {
t.Error("struct validation succeeded")
}
})
}
}
func mustMarshal(x any) json.RawMessage {
data, err := json.Marshal(x)
if err != nil {
panic(err)
}
return json.RawMessage(data)
}
// loadRemote loads a remote reference used in the test suite.
func loadRemote(uri *url.URL) (*Schema, error) {
// Anything with localhost:1234 refers to the remotes directory in the test suite repo.
if uri.Host == "localhost:1234" {
return loadSchemaFromFile(filepath.FromSlash(filepath.Join("testdata/remotes", uri.Path)))
}
// One test needs the meta-schema files.
const metaPrefix = "https://json-schema.org/draft/2020-12/"
if after, ok := strings.CutPrefix(uri.String(), metaPrefix); ok {
return loadSchemaFromFile(filepath.FromSlash("meta-schemas/draft2020-12/" + after + ".json"))
}
const metaPrefixDraft7 = "https://json-schema.org/draft-07/"
if after, ok := strings.CutPrefix(uri.String(), metaPrefixDraft7); ok {
return loadSchemaFromFile(filepath.FromSlash("meta-schemas/draft7/" + after + ".json"))
}
const metaPrefixDraft7s = "http://json-schema.org/draft-07/"
if after, ok := strings.CutPrefix(uri.String(), metaPrefixDraft7s); ok {
return loadSchemaFromFile(filepath.FromSlash("meta-schemas/draft7/" + after + ".json"))
}
return nil, fmt.Errorf("don't know how to load %s", uri)
}
func loadSchemaFromFile(filename string) (*Schema, error) {
data, err := os.ReadFile(filename)
if err != nil {
return nil, err
}
var s Schema
if err := json.Unmarshal(data, &s); err != nil {
return nil, fmt.Errorf("unmarshaling JSON at %s: %w", filename, err)
}
return &s, nil
}