package jsonschema import ( "testing" "github.com/stretchr/testify/assert" ) func TestSchemaValidateTypeNames(t *testing.T) { var err error toSchema := func(s string) *Schema { return &Schema{ Properties: map[string]*Schema{ "foo": { Type: Type(s), }, }, } } err = toSchema("string").validate() assert.NoError(t, err) err = toSchema("boolean").validate() assert.NoError(t, err) err = toSchema("number").validate() assert.NoError(t, err) err = toSchema("integer").validate() assert.NoError(t, err) err = toSchema("int").validate() assert.EqualError(t, err, "type int is not a recognized json schema type. Please use \"integer\" instead") err = toSchema("float").validate() assert.EqualError(t, err, "type float is not a recognized json schema type. Please use \"number\" instead") err = toSchema("bool").validate() assert.EqualError(t, err, "type bool is not a recognized json schema type. Please use \"boolean\" instead") err = toSchema("foobar").validate() assert.EqualError(t, err, "type foobar is not a recognized json schema type") } func TestSchemaLoadIntegers(t *testing.T) { schema, err := Load("./testdata/schema-load-int/schema-valid.json") assert.NoError(t, err) assert.Equal(t, int64(1), schema.Properties["abc"].Default) assert.Equal(t, []any{int64(1), int64(2), int64(3)}, schema.Properties["abc"].Enum) } func TestSchemaLoadIntegersWithInvalidDefault(t *testing.T) { _, err := Load("./testdata/schema-load-int/schema-invalid-default.json") assert.EqualError(t, err, "failed to parse default value for property abc: expected integer value, got: 1.1") } func TestSchemaLoadIntegersWithInvalidEnums(t *testing.T) { _, err := Load("./testdata/schema-load-int/schema-invalid-enum.json") assert.EqualError(t, err, "failed to parse enum value 2.4 at index 1 for property abc: expected integer value, got: 2.4") } func TestSchemaValidateDefaultType(t *testing.T) { invalidSchema := &Schema{ Properties: map[string]*Schema{ "foo": { Type: "number", Default: "abc", }, }, } err := invalidSchema.validate() assert.EqualError(t, err, "type validation for default value of property foo failed: expected type float, but value is \"abc\"") validSchema := &Schema{ Properties: map[string]*Schema{ "foo": { Type: "boolean", Default: true, }, }, } err = validSchema.validate() assert.NoError(t, err) } func TestSchemaValidateEnumType(t *testing.T) { invalidSchema := &Schema{ Properties: map[string]*Schema{ "foo": { Type: "boolean", Enum: []any{true, "false"}, }, }, } err := invalidSchema.validate() assert.EqualError(t, err, "type validation for enum at index 1 failed for property foo: expected type boolean, but value is \"false\"") validSchema := &Schema{ Properties: map[string]*Schema{ "foo": { Type: "boolean", Enum: []any{true, false}, }, }, } err = validSchema.validate() assert.NoError(t, err) } func TestSchemaValidateErrorWhenDefaultValueIsNotInEnums(t *testing.T) { invalidSchema := &Schema{ Properties: map[string]*Schema{ "foo": { Type: "string", Default: "abc", Enum: []any{"def", "ghi"}, }, }, } err := invalidSchema.validate() assert.EqualError(t, err, "list of enum values for property foo does not contain default value abc: [def ghi]") validSchema := &Schema{ Properties: map[string]*Schema{ "foo": { Type: "string", Default: "abc", Enum: []any{"def", "ghi", "abc"}, }, }, } err = validSchema.validate() assert.NoError(t, err) } func TestSchemaValidatePatternType(t *testing.T) { s := &Schema{ Properties: map[string]*Schema{ "foo": { Type: "number", Pattern: "abc", }, }, } assert.EqualError(t, s.validate(), "property \"foo\" has a non-empty regex pattern \"abc\" specified. Patterns are only supported for string properties") s = &Schema{ Properties: map[string]*Schema{ "foo": { Type: "string", Pattern: "abc", }, }, } assert.NoError(t, s.validate()) } func TestSchemaValidateIncorrectRegex(t *testing.T) { s := &Schema{ Properties: map[string]*Schema{ "foo": { Type: "string", // invalid regex, missing the closing brace Pattern: "(abc", }, }, } assert.EqualError(t, s.validate(), "invalid regex pattern \"(abc\" provided for property \"foo\": error parsing regexp: missing closing ): `(abc`") } func TestSchemaValidatePatternDefault(t *testing.T) { s := &Schema{ Properties: map[string]*Schema{ "foo": { Type: "string", Pattern: "abc", Default: "def", }, }, } assert.EqualError(t, s.validate(), "default value \"def\" for property \"foo\" does not match specified regex pattern: \"abc\"") s = &Schema{ Properties: map[string]*Schema{ "foo": { Type: "string", Pattern: "a.*d", Default: "axyzd", }, }, } assert.NoError(t, s.validate()) } func TestSchemaValidatePatternEnum(t *testing.T) { s := &Schema{ Properties: map[string]*Schema{ "foo": { Type: "string", Pattern: "a.*c", Enum: []any{"abc", "def", "abbc"}, }, }, } assert.EqualError(t, s.validate(), "enum value \"def\" at index 1 for property \"foo\" does not match specified regex pattern: \"a.*c\"") s = &Schema{ Properties: map[string]*Schema{ "foo": { Type: "string", Pattern: "a.*d", Enum: []any{"abd", "axybgd", "abbd"}, }, }, } assert.NoError(t, s.validate()) }