Fix json validation during serialization

schemaregistry/serde/avro/avro_generic.go

@@ -67,7 +67,7 @@ func (s *GenericSerializer) Serialize(topic string, msg interface{}) ([]byte, er
 	info := schemaregistry.SchemaInfo{
 		Schema: avroType.String(),
 	}
-	id, err := s.GetID(topic, msg, info)
+	id, err := s.GetID(topic, msg, &info)
 	if err != nil {
 		return nil, err
 	}

schemaregistry/serde/avro/avro_specific.go

@@ -76,7 +76,7 @@ func (s *SpecificSerializer) Serialize(topic string, msg interface{}) ([]byte, e
 	info := schemaregistry.SchemaInfo{
 		Schema: avroMsg.Schema(),
 	}
-	id, err := s.GetID(topic, avroMsg, info)
+	id, err := s.GetID(topic, avroMsg, &info)
 	if err != nil {
 		return nil, err
 	}

schemaregistry/serde/jsonschema/json_schema.go

@@ -68,7 +68,7 @@ func (s *Serializer) Serialize(topic string, msg interface{}) ([]byte, error) {
 		Schema:     string(raw),
 		SchemaType: "JSON",
 	}
-	id, err := s.GetID(topic, msg, info)
+	id, err := s.GetID(topic, msg, &info)
 	if err != nil {
 		return nil, err
 	}

schemaregistry/serde/jsonschema/json_schema_test.go

@@ -17,6 +17,9 @@
 package jsonschema
 
 import (
+	"encoding/json"
+	"github.com/invopop/jsonschema"
+	"strings"
 	"testing"
 
 	"github.com/confluentinc/confluent-kafka-go/v2/schemaregistry"
@@ -85,6 +88,63 @@ func TestJSONSchemaSerdeWithNested(t *testing.T) {
 	serde.MaybeFail("deserialization", err, serde.Expect(newobj, obj))
 }
 
+func TestFailingJSONSchemaValidationWithSimple(t *testing.T) {
+	serde.MaybeFail = serde.InitFailFunc(t)
+	var err error
+	conf := schemaregistry.NewConfig("mock://")
+
+	client, err := schemaregistry.NewClient(conf)
+	serde.MaybeFail("Schema Registry configuration", err)
+
+	serConfig := NewSerializerConfig()
+	serConfig.EnableValidation = true
+	// We don't want to risk registering one instead of using the already registered one
+	serConfig.AutoRegisterSchemas = false
+	serConfig.UseLatestVersion = true
+	ser, err := NewSerializer(client, serde.ValueSerde, serConfig)
+	serde.MaybeFail("Serializer configuration", err)
+
+	obj := JSONDemoSchema{}
+	jschema := jsonschema.Reflect(obj)
+	raw, err := json.Marshal(jschema)
+	serde.MaybeFail("Schema marshalling", err)
+	info := schemaregistry.SchemaInfo{
+		Schema:     string(raw),
+		SchemaType: "JSON",
+	}
+
+	id, err := client.Register("topic1-value", info, false)
+	serde.MaybeFail("Schema registration", err)
+	if id <= 0 {
+		t.Errorf("Expected valid schema id, found %d", id)
+	}
+
+	_, err = ser.Serialize("topic1", &obj)
+	if err != nil {
+		t.Errorf("Expected no validation error, found %s", err)
+	}
+
+	diffObj := DifferentJSONDemoSchema{}
+	_, err = ser.Serialize("topic1", &diffObj)
+	if err == nil || !strings.Contains(err.Error(), "jsonschema") {
+		t.Errorf("Expected validation error, found %s", err)
+	}
+}
+
+type DifferentJSONDemoSchema struct {
+	IntField int32 `json:"IntField"`
+
+	ExtraStringField string `json:"ExtraStringField"`
+
+	DoubleField float64 `json:"DoubleField"`
+
+	StringField string `json:"StringField"`
+
+	BoolFieldThatsActuallyString string `json:"BoolField"`
+
+	BytesField test.Bytes `json:"BytesField"`
+}
+
 type JSONDemoSchema struct {
 	IntField int32 `json:"IntField"`
 

schemaregistry/serde/protobuf/protobuf.go

@@ -177,7 +177,7 @@ func (s *Serializer) Serialize(topic string, msg interface{}) ([]byte, error) {
 		SchemaType: metadata.SchemaType,
 		References: metadata.References,
 	}
-	id, err := s.GetID(topic, protoMsg, info)
+	id, err := s.GetID(topic, protoMsg, &info)
 	if err != nil {
 		return nil, err
 	}

schemaregistry/serde/serde.go

@@ -128,28 +128,28 @@ func TopicNameStrategy(topic string, serdeType Type, schema schemaregistry.Schem
 }
 
 // GetID returns a schema ID for the given schema
-func (s *BaseSerializer) GetID(topic string, msg interface{}, info schemaregistry.SchemaInfo) (int, error) {
+func (s *BaseSerializer) GetID(topic string, msg interface{}, info *schemaregistry.SchemaInfo) (int, error) {
 	autoRegister := s.Conf.AutoRegisterSchemas
 	useSchemaID := s.Conf.UseSchemaID
 	useLatest := s.Conf.UseLatestVersion
 	normalizeSchema := s.Conf.NormalizeSchemas
 
 	var id = -1
-	subject, err := s.SubjectNameStrategy(topic, s.SerdeType, info)
+	subject, err := s.SubjectNameStrategy(topic, s.SerdeType, *info)
 	if err != nil {
 		return -1, err
 	}
 	if autoRegister {
-		id, err = s.Client.Register(subject, info, normalizeSchema)
+		id, err = s.Client.Register(subject, *info, normalizeSchema)
 		if err != nil {
 			return -1, err
 		}
 	} else if useSchemaID >= 0 {
-		info, err = s.Client.GetBySubjectAndID(subject, useSchemaID)
+		*info, err = s.Client.GetBySubjectAndID(subject, useSchemaID)
 		if err != nil {
 			return -1, err
 		}
-		id, err = s.Client.GetID(subject, info, false)
+		id, err = s.Client.GetID(subject, *info, false)
 		if err != nil {
 			return -1, err
 		}
@@ -161,17 +161,17 @@ func (s *BaseSerializer) GetID(topic string, msg interface{}, info schemaregistr
 		if err != nil {
 			return -1, err
 		}
-		info = schemaregistry.SchemaInfo{
+		*info = schemaregistry.SchemaInfo{
 			Schema:     metadata.Schema,
 			SchemaType: metadata.SchemaType,
 			References: metadata.References,
 		}
-		id, err = s.Client.GetID(subject, info, false)
+		id, err = s.Client.GetID(subject, *info, false)
 		if err != nil {
 			return -1, err
 		}
 	} else {
-		id, err = s.Client.GetID(subject, info, normalizeSchema)
+		id, err = s.Client.GetID(subject, *info, normalizeSchema)
 		if err != nil {
 			return -1, err
 		}