public void TestSerializeMetadataRequest()
        {
            var meta = new TopicRequest
            {
                Topics = new[] { "poulpe", "banana" }
            };

            using (var serialized = meta.Serialize(new ReusableMemoryStream(null), 61, ClientId, null))
            {
                CheckHeader(Basics.ApiKey.MetadataRequest, 0, 61, TheClientId, serialized);
                Assert.AreEqual(2, BigEndianConverter.ReadInt32(serialized));
                Assert.AreEqual("poulpe", Basics.DeserializeString(serialized));
                Assert.AreEqual("banana", Basics.DeserializeString(serialized));
            }

            meta = new TopicRequest
            {
                Topics = null
            };
            using (var serialized = meta.Serialize(new ReusableMemoryStream(null), 61, ClientId, null))
            {
                CheckHeader(Basics.ApiKey.MetadataRequest, 0, 61, TheClientId, serialized);
                Assert.AreEqual(0, BigEndianConverter.ReadInt32(serialized));
                Assert.AreEqual(serialized.Length, serialized.Position);
            }
        }
 private static void CheckHeader(
     Basics.ApiKey apiKey,
     short apiVersion,
     int correlationId,
     string clientId,
     ReusableMemoryStream stream)
 {
     Assert.AreEqual(stream.Length - 4, BigEndianConverter.ReadInt32(stream)); // Size
     Assert.AreEqual((short)apiKey, BigEndianConverter.ReadInt16(stream));
     Assert.AreEqual(apiVersion, BigEndianConverter.ReadInt16(stream));
     Assert.AreEqual(correlationId, BigEndianConverter.ReadInt32(stream));
     Assert.AreEqual(clientId, Basics.DeserializeString(stream));
 }
        public void TestSerializeProduceRequest()
        {
            var produce = new ProduceRequest
            {
                Timeout      = 1223,
                RequiredAcks = 1,
                TopicsData   = new[]
                {
                    new TopicData <PartitionData>
                    {
                        TopicName      = "barbu",
                        PartitionsData = new[]
                        {
                            new PartitionData
                            {
                                Partition        = 22,
                                CompressionCodec = CompressionCodec.None,
                                Messages         = new[]
                                {
                                    new Message {
                                        Value = TheValue
                                    }
                                },
                            }
                        }
                    },
                }
            };
            var config = new SerializationConfig();

            config.SetSerializersForTopic("barbu", new StringSerializer(), new StringSerializer());
            config.SetDeserializersForTopic("barbu", new StringDeserializer(), new StringDeserializer());
            using (var serialized = produce.Serialize(new ReusableMemoryStream(null), 321, ClientId, config))
            {
                CheckHeader(Basics.ApiKey.ProduceRequest, 0, 321, TheClientId, serialized);
                Assert.AreEqual(produce.RequiredAcks, BigEndianConverter.ReadInt16(serialized));
                Assert.AreEqual(produce.Timeout, BigEndianConverter.ReadInt32(serialized));
                Assert.AreEqual(1, BigEndianConverter.ReadInt32(serialized)); // 1 topic data
                Assert.AreEqual("barbu", Basics.DeserializeString(serialized));
                Assert.AreEqual(1, BigEndianConverter.ReadInt32(serialized)); // 1 partition data
                Assert.AreEqual(22, BigEndianConverter.ReadInt32(serialized));
                var msgs = FetchPartitionResponse.DeserializeMessageSet(serialized, config.GetDeserializersForTopic("barbu"));
                Assert.AreEqual(1, msgs.Count);
                //Assert.AreEqual(TheValue, Encoding.UTF8.GetString(msgs[0].Message.Value));
                Assert.AreEqual(TheValue, msgs[0].Message.Value as string);
            }
        }
        public void Test004_DeserializeString()
        {
            using (var serialized = new ReusableMemoryStream(null))
            {
                // Non null string
                BigEndianConverter.Write(serialized, (short)Value.Length);
                serialized.Write(Value, 0, Value.Length);
                serialized.Position = 0;

                Assert.AreEqual(TheValue, Basics.DeserializeString(serialized));

                // Null string
                serialized.SetLength(0);
                serialized.WriteByte(0xFF);
                serialized.WriteByte(0xFF);
                serialized.Position = 0;

                Assert.IsNull(Basics.DeserializeString(serialized));
            }
        }
        public void TestSerializeOffsetRequest()
        {
            var offset = new OffsetRequest
            {
                TopicsData = new[]
                {
                    new TopicData <OffsetPartitionData>
                    {
                        TopicName      = "boloss",
                        PartitionsData = new[]
                        {
                            new OffsetPartitionData
                            {
                                MaxNumberOfOffsets = 3,
                                Partition          = 123,
                                Time = 21341
                            }
                        }
                    }
                }
            };

            using (var serialized = offset.Serialize(new ReusableMemoryStream(null), 1235, ClientId, null))
            {
                CheckHeader(Basics.ApiKey.OffsetRequest, 0, 1235, TheClientId, serialized);
                Assert.AreEqual(-1, BigEndianConverter.ReadInt32(serialized)); // ReplicaId
                Assert.AreEqual(1, BigEndianConverter.ReadInt32(serialized));  // 1 topic data
                Assert.AreEqual(offset.TopicsData.First().TopicName, Basics.DeserializeString(serialized));
                Assert.AreEqual(1, BigEndianConverter.ReadInt32(serialized));  // 1 partition data
                var od = new OffsetPartitionData();
                od.Deserialize(serialized, null);
                Assert.AreEqual(123, od.Partition);
                Assert.AreEqual(21341, od.Time);
                Assert.AreEqual(3, od.MaxNumberOfOffsets);
            }
        }