// 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"
"math"
"os"
"path/filepath"
"regexp"
"strings"
"testing"
"github.com/google/go-cmp/cmp"
"github.com/google/go-cmp/cmp/cmpopts"
)
func TestMarshalJSONConsistency(t *testing.T) {
// Test that MarshalJSON with value receiver ensures consistent JSON encoding
// regardless of how Schema is stored (fixes golang/go#22967, golang/go#33993, golang/go#55890)
// Create a test schema
testSchema := Schema{
Type: "object",
MinLength: Ptr(10),
Properties: map[string]*Schema{
"name": {Type: "string"},
"age": {Type: "integer"},
},
Required: []string{"name"},
}
// Expected JSON output
expectedJSON, err := json.Marshal(testSchema)
if err != nil {
t.Fatalf("Failed to marshal expected schema: %v", err)
}
if !strings.Contains(string(expectedJSON), "object") {
t.Fatalf("Expected JSON does not contain 'object': %s", string(expectedJSON))
}
t.Run("DirectValue", func(t *testing.T) {
// Test direct value marshaling
got, err := json.Marshal(testSchema)
if err != nil {
t.Fatalf("Failed to marshal direct value: %v", err)
}
if string(got) != string(expectedJSON) {
t.Errorf("Direct value marshaling mismatch\ngot: %s\nwant: %s", got, expectedJSON)
}
})
t.Run("Pointer", func(t *testing.T) {
// Test pointer marshaling
schemaPtr := &testSchema
got, err := json.Marshal(schemaPtr)
if err != nil {
t.Fatalf("Failed to marshal pointer: %v", err)
}
if string(got) != string(expectedJSON) {
t.Errorf("Pointer marshaling mismatch\ngot: %s\nwant: %s", got, expectedJSON)
}
})
t.Run("MapValue", func(t *testing.T) {
// Test marshaling when stored as map value (non-addressable)
// This is a key case that fails with pointer receiver
schemaMap := map[string]Schema{
"test": testSchema,
}
got, err := json.Marshal(schemaMap["test"])
if err != nil {
t.Fatalf("Failed to marshal map value: %v", err)
}
if string(got) != string(expectedJSON) {
t.Errorf("Map value marshaling mismatch\ngot: %s\nwant: %s", got, expectedJSON)
}
})
t.Run("MapWithSchemaValues", func(t *testing.T) {
// Test marshaling a map containing Schema values
schemaMap := map[string]Schema{
"schema1": testSchema,
"schema2": {Type: "string"},
}
got, err := json.Marshal(schemaMap)
if err != nil {
t.Fatalf("Failed to marshal map with Schema values: %v", err)
}
// Verify the map marshals correctly
var result map[string]json.RawMessage
if err := json.Unmarshal(got, &result); err != nil {
t.Fatalf("Failed to unmarshal result: %v", err)
}
// Check that schema1 matches expected
if string(result["schema1"]) != string(expectedJSON) {
t.Errorf("Map schema1 marshaling mismatch\ngot: %s\nwant: %s", result["schema1"], expectedJSON)
}
})
t.Run("SliceElement", func(t *testing.T) {
// Test marshaling when stored in a slice
schemas := []Schema{testSchema}
gotSlice, err := json.Marshal(schemas)
if err != nil {
t.Fatalf("Failed to marshal slice: %v", err)
}
var unmarshaledSlice []json.RawMessage
if err := json.Unmarshal(gotSlice, &unmarshaledSlice); err != nil {
t.Fatalf("Failed to unmarshal slice: %v", err)
}
if len(unmarshaledSlice) != 1 || string(unmarshaledSlice[0]) != string(expectedJSON) {
t.Errorf("Slice element marshaling mismatch\ngot: %s\nwant: %s",
unmarshaledSlice[0], expectedJSON)
}
})
t.Run("StructField", func(t *testing.T) {
// Test marshaling when embedded in another struct
type Container struct {
Schema Schema `json:"schema"`
Name string `json:"name"`
}
container := Container{
Schema: testSchema,
Name: "test",
}
got, err := json.Marshal(container)
if err != nil {
t.Fatalf("Failed to marshal struct with Schema field: %v", err)
}
var result map[string]json.RawMessage
if err := json.Unmarshal(got, &result); err != nil {
t.Fatalf("Failed to unmarshal struct result: %v", err)
}
if string(result["schema"]) != string(expectedJSON) {
t.Errorf("Struct field marshaling mismatch\ngot: %s\nwant: %s",
result["schema"], expectedJSON)
}
})
t.Run("InterfaceValue", func(t *testing.T) {
// Test marshaling when stored as interface{}
var iface any = testSchema
got, err := json.Marshal(iface)
if err != nil {
t.Fatalf("Failed to marshal interface value: %v", err)
}
if string(got) != string(expectedJSON) {
t.Errorf("Interface value marshaling mismatch\ngot: %s\nwant: %s", got, expectedJSON)
}
})
t.Run("EmptyPropertiesMap", func(t *testing.T) {
// Test that an empty map in Properties marshals as "{}".
s := &Schema{Type: "object", Properties: map[string]*Schema{}}
got, err := json.Marshal(s)
if err != nil {
t.Fatalf("Failed to marshal interface value: %v", err)
}
want := `{"type":"object","properties":{}}`
if string(got) != want {
t.Errorf("\ngot %s\nwant %s", got, want)
}
})
}
func TestGoRoundTrip(t *testing.T) {
// Verify that Go representations round-trip.
for _, s := range []*Schema{
{Type: "null"},
{Types: []string{"null", "number"}},
{Type: "string", MinLength: Ptr(20)},
{Minimum: Ptr(20.0)},
{Items: &Schema{Type: "integer"}},
{Const: Ptr(any(0))},
{Const: Ptr(any(nil))},
{Const: Ptr(any([]int{}))},
{Const: Ptr(any(map[string]any{}))},
{Default: mustMarshal(1)},
{Default: mustMarshal(nil)},
{Extra: map[string]any{"test": "value"}},
} {
data, err := json.Marshal(s)
if err != nil {
t.Fatal(err)
}
var got *Schema
mustUnmarshal(t, data, &got)
if !Equal(got, s) {
t.Errorf("got %s, want %s", got.json(), s.json())
if got.Const != nil && s.Const != nil {
t.Logf("Consts: got %#v (%[1]T), want %#v (%[2]T)", *got.Const, *s.Const)
}
}
}
}
func TestJSONRoundTrip(t *testing.T) {
// Verify that JSON texts for schemas marshal into equivalent forms.
// We don't expect everything to round-trip perfectly. For example, "true" and "false"
// will turn into their object equivalents.
// But most things should.
// Some of these cases test Schema.{UnM,M}arshalJSON.
// Most of others follow from the behavior of encoding/json, but they are still
// valuable as regression tests of this package's behavior.
for _, tt := range []struct {
in, want string
}{
{`true`, `true`},
{`false`, `false`},
{`{"type":"", "enum":null}`, `true`}, // empty fields are omitted
{`{"minimum":1}`, `{"minimum":1}`},
{`{"minimum":1.0}`, `{"minimum":1}`}, // floating-point integers lose their fractional part
{`{"minLength":1.0}`, `{"minLength":1}`}, // some floats are unmarshaled into ints, but you can't tell
{
// map keys are sorted
`{"$vocabulary":{"b":true, "a":false}}`,
`{"$vocabulary":{"a":false,"b":true}}`,
},
{`{"unk":0}`, `{"unk":0}`}, // unknown fields are not dropped
{
// known and unknown fields are not dropped
// note that the order will be by the declaration order in the anonymous struct inside MarshalJSON
`{"comment":"test","type":"example","unk":0}`,
`{"type":"example","comment":"test","unk":0}`,
},
{`{"extra":0}`, `{"extra":0}`}, // extra is not a special keyword and should not be dropped
{`{"Extra":0}`, `{"Extra":0}`}, // Extra is not a special keyword and should not be dropped
} {
var s Schema
mustUnmarshal(t, []byte(tt.in), &s)
data, err := json.Marshal(&s)
if err != nil {
t.Fatal(err)
}
if got := string(data); got != tt.want {
t.Errorf("%s:\ngot %s\nwant %s", tt.in, got, tt.want)
}
}
}
func TestUnmarshalErrors(t *testing.T) {
for _, tt := range []struct {
in string
want string // error must match this regexp
}{
{`1`, "cannot unmarshal number"},
{`{"type":1}`, `invalid value for "type"`},
{`{"minLength":1.5}`, `not an integer value`},
{`{"maxLength":1.5}`, `not an integer value`},
{`{"minItems":1.5}`, `not an integer value`},
{`{"maxItems":1.5}`, `not an integer value`},
{`{"minProperties":1.5}`, `not an integer value`},
{`{"maxProperties":1.5}`, `not an integer value`},
{`{"minContains":1.5}`, `not an integer value`},
{`{"maxContains":1.5}`, `not an integer value`},
{fmt.Sprintf(`{"maxContains":%d}`, int64(math.MaxInt32+1)), `out of range`},
{`{"minLength":9e99}`, `cannot be unmarshaled`},
{`{"minLength":"1.5"}`, `not a number`},
} {
var s Schema
err := json.Unmarshal([]byte(tt.in), &s)
if err == nil {
t.Fatalf("%s: no error but expected one", tt.in)
}
if !regexp.MustCompile(tt.want).MatchString(err.Error()) {
t.Errorf("%s: error %q does not match %q", tt.in, err, tt.want)
}
}
}
func TestMarshalOrder(t *testing.T) {
for _, tt := range []struct {
order []string
want string
wantErr bool
errMessage string
}{
{
[]string{"A", "B", "C", "D"},
`{"type":"object","properties":{"A":{"type":"integer"},"B":{"type":"integer"},"C":{"type":"integer"},"D":{"type":"integer"},"E":{"type":"integer"}}}`,
false,
"",
},
{
[]string{"A", "C", "B", "D"},
`{"type":"object","properties":{"A":{"type":"integer"},"C":{"type":"integer"},"B":{"type":"integer"},"D":{"type":"integer"},"E":{"type":"integer"}}}`,
false,
"",
},
{
[]string{"D", "C", "B", "A"},
`{"type":"object","properties":{"D":{"type":"integer"},"C":{"type":"integer"},"B":{"type":"integer"},"A":{"type":"integer"},"E":{"type":"integer"}}}`,
false,
"",
},
{
[]string{"A", "B", "C"},
`{"type":"object","properties":{"A":{"type":"integer"},"B":{"type":"integer"},"C":{"type":"integer"},"D":{"type":"integer"},"E":{"type":"integer"}}}`,
false,
"",
},
{
[]string{"A", "E", "C"},
`{"type":"object","properties":{"A":{"type":"integer"},"E":{"type":"integer"},"C":{"type":"integer"},"B":{"type":"integer"},"D":{"type":"integer"}}}`,
false,
"",
},
{
[]string{"A", "B", "C", "D", "D"},
"",
true,
"json: error calling MarshalJSON for type *jsonschema.Schema: property order slice cannot contain duplicate entries, found duplicate \"D\"",
},
} {
s := &Schema{
Type: "object",
Properties: map[string]*Schema{
"A": {Type: "integer"},
"B": {Type: "integer"},
"C": {Type: "integer"},
"D": {Type: "integer"},
"E": {Type: "integer"},
},
}
s.PropertyOrder = tt.order
gotBytes, err := json.Marshal(s)
if err != nil {
if !tt.wantErr {
t.Fatal(err)
}
if diff := cmp.Diff(tt.errMessage, err.Error()); diff != "" {
t.Fatalf("error message mismatch (-want +got):\n%s", diff)
}
continue
}
if diff := cmp.Diff(tt.want, string(gotBytes), cmpopts.IgnoreUnexported(Schema{})); diff != "" {
t.Fatalf("ForType mismatch (-want +got):\n%s", diff)
}
}
}
func mustUnmarshal(t *testing.T, data []byte, ptr any) {
t.Helper()
if err := json.Unmarshal(data, ptr); err != nil {
t.Fatal(err)
}
}
// json returns the schema in json format.
func (s *Schema) json() string {
data, err := json.Marshal(s)
if err != nil {
return fmt.Sprintf("<jsonschema.Schema:%v>", err)
}
return string(data)
}
// json returns the schema in json format, indented.
func (s *Schema) jsonIndent() string {
data, err := json.MarshalIndent(s, "", " ")
if err != nil {
return fmt.Sprintf("<jsonschema.Schema:%v>", err)
}
return string(data)
}
func TestCloneSchemas(t *testing.T) {
ss1 := &Schema{Type: "string"}
ss2 := &Schema{Type: "integer"}
ss3 := &Schema{Type: "boolean"}
ss4 := &Schema{Type: "number"}
ss5 := &Schema{Contains: ss4}
s1 := Schema{
Contains: ss1,
PrefixItems: []*Schema{ss2, ss3},
Properties: map[string]*Schema{"a": ss5},
}
s2 := s1.CloneSchemas()
// The clones should appear identical.
if g, w := s1.json(), s2.json(); g != w {
t.Errorf("\ngot %s\nwant %s", g, w)
}
// None of the schemas should overlap.
schemas1 := map[*Schema]bool{ss1: true, ss2: true, ss3: true, ss4: true, ss5: true}
for ss := range s2.all() {
if schemas1[ss] {
t.Errorf("uncloned schema %s", ss.json())
}
}
// s1's original schemas should be intact.
if s1.Contains != ss1 || s1.PrefixItems[0] != ss2 || s1.PrefixItems[1] != ss3 || ss5.Contains != ss4 || s1.Properties["a"] != ss5 {
t.Errorf("s1 modified")
}
}
func TestCloneMarshalDraft2020_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")
}
testCloneMarshalValidate(t, files, "")
}
func TestCloneMarshalDraft7(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")
}
testCloneMarshalValidate(t, files, "https://json-schema.org/draft-07/schema#")
}
func testCloneMarshalValidate(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
}
original := g.Schema.json()
clone := g.Schema.CloneSchemas()
if diff := cmp.Diff(original, clone.json()); diff != "" {
t.Fatalf("Schema mismatch (-want +got):\n%s", diff)
}
})
}
})
}
}