github.com/confluentinc/confluent-kafka-go@v1.9.2/schemaregistry/serde/protobuf/protobuf_test.go (about)

     1  /**
     2   * Copyright 2022 Confluent Inc.
     3   *
     4   * Licensed under the Apache License, Version 2.0 (the "License");
     5   * you may not use this file except in compliance with the License.
     6   * You may obtain a copy of the License at
     7   *
     8   * http://www.apache.org/licenses/LICENSE-2.0
     9   *
    10   * Unless required by applicable law or agreed to in writing, software
    11   * distributed under the License is distributed on an "AS IS" BASIS,
    12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13   * See the License for the specific language governing permissions and
    14   * limitations under the License.
    15   */
    16  
    17  package protobuf
    18  
    19  import (
    20  	"testing"
    21  
    22  	"github.com/confluentinc/confluent-kafka-go/schemaregistry"
    23  	"github.com/confluentinc/confluent-kafka-go/schemaregistry/serde"
    24  	"github.com/confluentinc/confluent-kafka-go/schemaregistry/test"
    25  	"google.golang.org/protobuf/proto"
    26  )
    27  
    28  func TestProtobufSerdeWithSimple(t *testing.T) {
    29  	serde.MaybeFail = serde.InitFailFunc(t)
    30  	var err error
    31  	conf := schemaregistry.NewConfig("mock://")
    32  
    33  	client, err := schemaregistry.NewClient(conf)
    34  	serde.MaybeFail("Schema Registry configuration", err)
    35  
    36  	ser, err := NewSerializer(client, serde.ValueSerde, NewSerializerConfig())
    37  	serde.MaybeFail("Serializer configuration", err)
    38  
    39  	obj := test.Author{
    40  		Name:  "Kafka",
    41  		Id:    123,
    42  		Works: []string{"The Castle", "The Trial"},
    43  	}
    44  	bytes, err := ser.Serialize("topic1", &obj)
    45  	serde.MaybeFail("serialization", err)
    46  
    47  	deser, err := NewDeserializer(client, serde.ValueSerde, NewDeserializerConfig())
    48  	serde.MaybeFail("Deserializer configuration", err)
    49  	deser.Client = ser.Client
    50  
    51  	deser.ProtoRegistry.RegisterMessage(obj.ProtoReflect().Type())
    52  
    53  	newobj, err := deser.Deserialize("topic1", bytes)
    54  	serde.MaybeFail("deserialization", err, serde.Expect(newobj.(proto.Message).ProtoReflect(), obj.ProtoReflect()))
    55  }
    56  
    57  func TestProtobufSerdeWithSecondMessage(t *testing.T) {
    58  	serde.MaybeFail = serde.InitFailFunc(t)
    59  	var err error
    60  	conf := schemaregistry.NewConfig("mock://")
    61  
    62  	client, err := schemaregistry.NewClient(conf)
    63  	serde.MaybeFail("Schema Registry configuration", err)
    64  
    65  	ser, err := NewSerializer(client, serde.ValueSerde, NewSerializerConfig())
    66  	serde.MaybeFail("Serializer configuration", err)
    67  
    68  	obj := test.Pizza{
    69  		Size:     "Extra extra large",
    70  		Toppings: []string{"anchovies", "mushrooms"},
    71  	}
    72  	bytes, err := ser.Serialize("topic1", &obj)
    73  	serde.MaybeFail("serialization", err)
    74  
    75  	deser, err := NewDeserializer(client, serde.ValueSerde, NewDeserializerConfig())
    76  	serde.MaybeFail("Deserializer configuration", err)
    77  	deser.Client = ser.Client
    78  
    79  	deser.ProtoRegistry.RegisterMessage(obj.ProtoReflect().Type())
    80  
    81  	newobj, err := deser.Deserialize("topic1", bytes)
    82  	serde.MaybeFail("deserialization", err, serde.Expect(newobj.(proto.Message).ProtoReflect(), obj.ProtoReflect()))
    83  }
    84  
    85  func TestProtobufSerdeWithNestedMessage(t *testing.T) {
    86  	serde.MaybeFail = serde.InitFailFunc(t)
    87  	var err error
    88  	conf := schemaregistry.NewConfig("mock://")
    89  
    90  	client, err := schemaregistry.NewClient(conf)
    91  	serde.MaybeFail("Schema Registry configuration", err)
    92  
    93  	ser, err := NewSerializer(client, serde.ValueSerde, NewSerializerConfig())
    94  	serde.MaybeFail("Serializer configuration", err)
    95  
    96  	obj := test.NestedMessage_InnerMessage{
    97  		Id: "inner",
    98  	}
    99  	bytes, err := ser.Serialize("topic1", &obj)
   100  	serde.MaybeFail("serialization", err)
   101  
   102  	deser, err := NewDeserializer(client, serde.ValueSerde, NewDeserializerConfig())
   103  	serde.MaybeFail("Deserializer configuration", err)
   104  	deser.Client = ser.Client
   105  
   106  	deser.ProtoRegistry.RegisterMessage(obj.ProtoReflect().Type())
   107  
   108  	newobj, err := deser.Deserialize("topic1", bytes)
   109  	serde.MaybeFail("deserialization", err, serde.Expect(newobj.(proto.Message).ProtoReflect(), obj.ProtoReflect()))
   110  }
   111  
   112  func TestProtobufSerdeWithReference(t *testing.T) {
   113  	serde.MaybeFail = serde.InitFailFunc(t)
   114  	var err error
   115  	conf := schemaregistry.NewConfig("mock://")
   116  
   117  	client, err := schemaregistry.NewClient(conf)
   118  	serde.MaybeFail("Schema Registry configuration", err)
   119  
   120  	ser, err := NewSerializer(client, serde.ValueSerde, NewSerializerConfig())
   121  	serde.MaybeFail("Serializer configuration", err)
   122  
   123  	msg := test.TestMessage{
   124  		TestString:   "hi",
   125  		TestBool:     true,
   126  		TestBytes:    []byte{1, 2},
   127  		TestDouble:   1.23,
   128  		TestFloat:    3.45,
   129  		TestFixed32:  67,
   130  		TestFixed64:  89,
   131  		TestInt32:    100,
   132  		TestInt64:    200,
   133  		TestSfixed32: 300,
   134  		TestSfixed64: 400,
   135  		TestSint32:   500,
   136  		TestSint64:   600,
   137  		TestUint32:   700,
   138  		TestUint64:   800,
   139  	}
   140  	obj := test.DependencyMessage{
   141  		IsActive:     true,
   142  		TestMesssage: &msg,
   143  	}
   144  	bytes, err := ser.Serialize("topic1", &obj)
   145  	serde.MaybeFail("serialization", err)
   146  
   147  	deser, err := NewDeserializer(client, serde.ValueSerde, NewDeserializerConfig())
   148  	serde.MaybeFail("Deserializer configuration", err)
   149  	deser.Client = ser.Client
   150  
   151  	deser.ProtoRegistry.RegisterMessage(obj.ProtoReflect().Type())
   152  
   153  	newobj, err := deser.Deserialize("topic1", bytes)
   154  	serde.MaybeFail("deserialization", err, serde.Expect(newobj.(proto.Message).ProtoReflect(), obj.ProtoReflect()))
   155  }
   156  
   157  func TestProtobufSerdeWithCycle(t *testing.T) {
   158  	serde.MaybeFail = serde.InitFailFunc(t)
   159  	var err error
   160  	conf := schemaregistry.NewConfig("mock://")
   161  
   162  	client, err := schemaregistry.NewClient(conf)
   163  	serde.MaybeFail("Schema Registry configuration", err)
   164  
   165  	ser, err := NewSerializer(client, serde.ValueSerde, NewSerializerConfig())
   166  	serde.MaybeFail("Serializer configuration", err)
   167  
   168  	inner := test.LinkedList{
   169  		Value: 100,
   170  	}
   171  	obj := test.LinkedList{
   172  		Value: 1,
   173  		Next:  &inner,
   174  	}
   175  	bytes, err := ser.Serialize("topic1", &obj)
   176  	serde.MaybeFail("serialization", err)
   177  
   178  	deser, err := NewDeserializer(client, serde.ValueSerde, NewDeserializerConfig())
   179  	serde.MaybeFail("Deserializer configuration", err)
   180  	deser.Client = ser.Client
   181  
   182  	deser.ProtoRegistry.RegisterMessage(obj.ProtoReflect().Type())
   183  
   184  	newobj, err := deser.Deserialize("topic1", bytes)
   185  	serde.MaybeFail("deserialization", err, serde.Expect(newobj.(proto.Message).ProtoReflect(), obj.ProtoReflect()))
   186  }