public void GenerateClass_ClassWithEnum_GeneratedModelIsAsExpected()
{
//Arrange
var schema = AvroConvert.GenerateSchema(typeof(ClassWithEnum));
//Act
string resultSchema = AvroConvert.GenerateModel(schema);
//Assert
Assert.Equal(
"public class ClassWithEnum\r\n" +
"{\r\n" +
"\tpublic TestEnum? EnumProp { get; set; }\r\n" +
"}\r\n" +
"\r\n" +
"public enum TestEnum\r\n" +
"{\r\n" +
"\ta,\r\n" +
"\tbe,\r\n" +
"\tca,\r\n" +
"\tdlo\r\n" +
"}\r\n" +
"\r\n",
resultSchema);
}
public void GenerateClass_NestedClass_OutputIsEqualToExpected()
{
//Arrange
var schema = AvroConvert.GenerateSchema(typeof(BaseTestClass));
//Act
string resultSchema = AvroConvert.GenerateModel(schema);
//Assert
Assert.Equal(
"public class BaseTestClass\r\n" +
"{\r\n" +
"\tpublic string justSomeProperty { get; set; }\r\n" +
"\tpublic long andLongProperty { get; set; }\r\n" +
"\tpublic User objectProperty { get; set; }\r\n" +
"}\r\n" +
"\r\n" +
"public class User\r\n" +
"{\r\n" +
"\tpublic string name { get; set; }\r\n" +
"\tpublic int? favorite_number { get; set; }\r\n" +
"\tpublic string favorite_color { get; set; }\r\n" +
"}\r\n" +
"\r\n",
resultSchema);
}
public void Component_HeadlessList_ResultIsTheSameAsInput()
{
//Arrange
List <int> list = _fixture.Create <List <int> >();
var schema = AvroConvert.GenerateSchema(typeof(List <int>));
//Act
var serialized = AvroConvert.SerializeHeadless(list, schema);
var result = new List <int>();
using (var reader = AvroConvert.OpenDeserializer <int>(new MemoryStream(serialized)))
{
while (reader.HasNext())
{
var item = reader.ReadNext();
result.Add(item);
}
}
//Assert
Assert.NotNull(result);
Assert.NotNull(serialized);
Assert.Equal(list, result);
}
public void Component_AvroAttributeClass_ResultIsEqualToInput()
{
//Arrange
AttributeClass toSerialize = new AttributeClass
{
AndAnotherString = "anotherString",
NullableIntProperty = 1,
NullableIntPropertyWithDefaultValue = null,
NullableStringProperty = "nullableString"
};
string schema = AvroConvert.GenerateSchema(typeof(AttributeClass));
//Act
var result = AvroConvert.SerializeHeadless(toSerialize, schema);
var deserialized = AvroConvert.DeserializeHeadless <AttributeClass>(result, schema);
//Assert
Assert.NotNull(result);
Assert.NotNull(deserialized);
Assert.Equal(toSerialize.NullableIntProperty, deserialized.NullableIntProperty);
Assert.Equal(toSerialize.AndAnotherString, deserialized.AndAnotherString);
Assert.Equal(toSerialize.NullableStringProperty, deserialized.NullableStringProperty);
Assert.Equal(2137, deserialized.NullableIntPropertyWithDefaultValue);
}
public void Deserialize_CustomSchema_OnlyValuesFromCustomSchemaAreReturned()
{
//Arrange
string customSchema = AvroConvert.GenerateSchema(typeof(UserNameClass));
Dictionary <string, object> result1 = new Dictionary <string, object>();
result1.Add("name", "Alyssa");
Dictionary <string, object> result2 = new Dictionary <string, object>();
result2.Add("name", "Ben");
List <object> expectedResult = new List <object>();
expectedResult.Add(result1);
expectedResult.Add(result2);
//Act
var result = AvroConvert.Deserialize(_avroBytes, customSchema);
//Assert
Assert.Equal(expectedResult, result);
}
static void Main(string[] args)
{
IntegrationTest.Invoke();
var fixture = new Fixture();
var data = fixture.CreateMany <Dataset>(30000).ToArray();
Console.WriteLine("AvroConvert Benchmark - fire!");
Console.WriteLine("");
Console.WriteLine("The Benchmark compares Apache.Avro, AvroConvert (nuget version) and AvroConvert local version");
int noOfRuns = 30;
Console.WriteLine($"Number of runs: {noOfRuns}");
string schema = AvroConvert.GenerateSchema(typeof(Dataset[]));
//Act
List <BenchmarkResult> benchmarkResults = new List <BenchmarkResult>();
for (int i = 0; i < noOfRuns; i++)
{
benchmarkResults.Add(RunBenchmark(data, schema));
if ((i + 1) % 10 == 0)
{
Console.WriteLine($"Progress: {i + 1}/{noOfRuns}");
}
}
BenchmarkResult mean = new BenchmarkResult();
mean.AvroConvertVNextGzipSerializeTime = benchmarkResults.Sum(r => r.AvroConvertVNextGzipSerializeTime) / noOfRuns;
mean.AvroConvertVNextGzipDeserializeTime = benchmarkResults.Sum(r => r.AvroConvertVNextGzipDeserializeTime) / noOfRuns;
mean.AvroConvertVNextGzipSize = benchmarkResults.Sum(r => r.AvroConvertVNextGzipSize) / noOfRuns;
mean.ApacheAvroSerializeTime = benchmarkResults.Sum(r => r.ApacheAvroSerializeTime) / noOfRuns;
mean.ApacheAvroDeserializeTime = benchmarkResults.Sum(r => r.ApacheAvroDeserializeTime) / noOfRuns;
mean.ApacheAvroSize = benchmarkResults.Sum(r => r.ApacheAvroSize) / noOfRuns;
mean.AvroConvertHeadlessSerializeTime = benchmarkResults.Sum(r => r.AvroConvertHeadlessSerializeTime) / noOfRuns;
mean.AvroConvertHeadlessDeserializeTime = benchmarkResults.Sum(r => r.AvroConvertHeadlessDeserializeTime) / noOfRuns;
mean.AvroConvertHeadlessSize = benchmarkResults.Sum(r => r.AvroConvertHeadlessSize) / noOfRuns;
mean.AvroConvertGzipSerializeTime = benchmarkResults.Sum(r => r.AvroConvertGzipSerializeTime) / noOfRuns;
mean.AvroConvertGzipDeserializeTime = benchmarkResults.Sum(r => r.AvroConvertGzipDeserializeTime) / noOfRuns;
mean.AvroConvertGzipSize = benchmarkResults.Sum(r => r.AvroConvertGzipSize) / noOfRuns;
mean.AvroConvertVNextHeadlessSerializeTime = benchmarkResults.Sum(r => r.AvroConvertVNextHeadlessSerializeTime) / noOfRuns;
mean.AvroConvertVNextHeadlessDeserializeTime = benchmarkResults.Sum(r => r.AvroConvertVNextHeadlessDeserializeTime) / noOfRuns;
mean.AvroConvertVNextSize = benchmarkResults.Sum(r => r.AvroConvertVNextSize) / noOfRuns;
ConstructLog(mean);
Console.ReadLine();
}
public void GenerateSchema_PropertiesAreSystemNullable_SchemaIndicatesFieldIsNullable()
{
//Arrange
//Act
string schema = AvroConvert.GenerateSchema(typeof(User));
// Assert
Assert.Contains("{\"name\":\"favorite_number\",\"type\":[\"null\",\"int\"]}", schema);
}
public void GenerateSchema_PropertiesAreDecoratedWithDefaultValueAttributes_SchemaPositionsOriginalTypeBeforeNullWhenDefaultIsNotNull()
{
//Arrange
//Act
string schema = AvroConvert.GenerateSchema(typeof(DefaultValueClass));
//Assert
Assert.Contains("{\"name\":\"justSomeProperty\",\"type\":[\"string\",\"null\"],\"default\":\"Let's go\"}", schema);
}
public void GenerateSchema_Enum_SchemaIsCorrect()
{
//Arrange
//Act
string schema = AvroConvert.GenerateSchema(typeof(TestEnum));
//Assert
Assert.Contains("{\"type\":\"enum\",\"name\":\"TestEnum\",\"namespace\":\"AvroConvertComponentTests\",\"symbols\":[\"a\",\"be\",\"ca\",\"dlo\"]}", schema);
}
public void GenerateSchema_ClassWithMixedMembersAttributesAndNon_AfterIncludingOnlyMembersNonAttributedAreIgnored()
{
//Arrange
//Act
string schema = AvroConvert.GenerateSchema(typeof(MixedDataMembers), includeOnlyDataContractMembers: true);
//Assert
Assert.Contains("{\"type\":\"record\",\"name\":\"MixedDataMembers\",\"namespace\":\"AvroConvertComponentTests\",\"fields\":[{\"name\":\"savedValues\",\"type\":{\"type\":\"array\",\"items\":\"int\"}},{\"name\":\"andAnother\",\"type\":[\"null\",\"long\"]}]}", schema);
}
public void GenerateSchema_PropertiesIncludeNullableVersionsOfTypes_SchemaIncludesNullTypeInTypesArray()
{
//Arrange
//Act
string schema = AvroConvert.GenerateSchema(typeof(DefaultValueClass));
//Assert
Assert.Contains("{\"name\":\"andLongProperty\",\"type\":[\"null\",\"long\"]", schema);
}
public void GenerateSchema_PropertiesAreDecoratedWithDefaultValueAttributes_SchemaPositionsNullTypeAfterOtherInTheTypeArrayWhenDefaultIsNotNull()
{
//Arrange
//Act
string schema = AvroConvert.GenerateSchema(typeof(DefaultValueClass));
//Assert
Assert.Contains("{\"name\":\"andLongBigDefaultedProperty\",\"type\":[\"long\",\"null\"],\"default\":9200000000000000007}", schema);
}
public void GenerateSchema_PropertiesAreDecoratedWithNullableSchemaAttribute_SchemaIndicatesFieldIsNullable()
{
//Arrange
//Act
string schema = AvroConvert.GenerateSchema(typeof(AttributeClass));
// Assert
Assert.Contains("{\"name\":\"favorite_number\",\"aliases\":[\"NullableIntProperty\"],\"type\":[\"null\",\"int\"]}",
schema);
}
public void GenerateSchema_PropertiesAreNullableReferenceTypes_SchemaIndicatesMembersAreNullable()
{
//Arrange
//Act
string schema = AvroConvert.GenerateSchema(typeof(ClassWithNullableMembers));
// Assert
Assert.Contains("{\"name\":\"NullableStringProperty\",\"type\":[\"null\",\"string\"]}", schema);
Assert.Contains("{\"name\":\"NullableField\",\"type\":[\"null\",\"string\"]}", schema);
}
public void GenerateSchema_PropertiesAreDecoratedWithDefaultValueAttributes_SchemaPositionsTypesEffectivelyRegardlessOfMismatchBetweenDefaultValueAndPropertyType()
{
//Arrange
//Act
string schema = AvroConvert.GenerateSchema(typeof(DefaultValueClass));
// Assert - The DefaultValue is an int, (100) but the property is a long, matching
// isn't necessary, all that's required is that the 'not null' type is first in the schema list
Assert.Contains("{\"name\":\"andLongSmallDefaultedProperty\",\"type\":[\"long\",\"null\"],\"default\":100}", schema);
}
public void GenerateSchema_ClassIsChildOfAbstractClass_SchemaIsGenerated()
{
//Arrange
//Act
string schema = AvroConvert.GenerateSchema(typeof(Farm));
//Assert
Assert.Equal(@"{""type"":""record"",""name"":""Farm"",""namespace"":""AvroConvertComponentTests.GenerateSchema"",""fields"":[{""name"":""Name"",""type"":""string""},{""name"":""Animals"",""type"":{""type"":""array"",""items"":{""type"":""record"",""name"":""Animal"",""namespace"":""AvroConvertComponentTests.GenerateSchema"",""fields"":[{""name"":""IsOutside"",""type"":""boolean""}]}}},{""name"":""Plants"",""type"":{""type"":""array"",""items"":{""type"":""record"",""name"":""IPlant"",""namespace"":""AvroConvertComponentTests.GenerateSchema"",""fields"":[{""name"":""Color"",""type"":""string""}]}}}]}", schema);
}
public void GenerateSchema_PropertiesAreDecoratedWithDefaultValueAttributes_SchemaContainsDefaultFieldForMembers()
{
//Arrange
//Act
string schema = AvroConvert.GenerateSchema(typeof(DefaultValueClass));
//Assert
Assert.Contains("\"default\":\"Let's go\"", schema);
Assert.Contains("\"default\":9200000000000000007", schema);
Assert.Contains("\"default\":null", schema);
}
//Decimals are handled atm as strings
// [InlineData(typeof(decimal?), @"[""null"",{""type"":""bytes"",""logicalType"":""decimal"",""precision"":29,""scale"":14}]")]
// [InlineData(typeof(decimal), @"{""type"":""bytes"",""logicalType"":""decimal"",""precision"":29,""scale"":14}")]
public void GenerateSchema_DotNetTypeCompatibleWithLogicType(Type type, string schema)
{
//Arrange
//Act
var result = AvroConvert.GenerateSchema(type);
//Assert
Assert.Equal(schema, result);
}
public void GenerateSchema_ClassContainsNoDefaultConstructor_SchemaIsGenerated()
{
//Arrange
//Act
string schema = AvroConvert.GenerateSchema(typeof(ClassWithoutDefaultConstructor));
//Assert
Assert.Equal(@"{""type"":""record"",""name"":""ClassWithoutDefaultConstructor"",""namespace"":""AvroConvertComponentTests"",""fields"":[{""name"":""Name"",""type"":""string""}]}", schema);
}
public async Task <byte[]> SerializeAsync(T data, SerializationContext context)
{
string subject = $"{context.Topic }-{context.Component}";
int id = 0;
var schema = AvroConvert.GenerateSchema(typeof(T));
if (cache.ContainsKey(subject))
{
id = cache[subject];
}
else
{
var existingSchema = await RegistryClient.GetLatestSchemaAsync(subject);
if (existingSchema.SchemaString == schema)
{
cache.AddOrUpdate(subject, existingSchema.Id, (key, oldValue) => existingSchema.Id);
}
else
{
Confluent.SchemaRegistry.Schema confluentSchema = new Confluent.SchemaRegistry.Schema(
subject,
existingSchema.Version + 1,
0,
schema
);
id = await RegistryClient.RegisterSchemaAsync(subject, confluentSchema.ToString());
cache.AddOrUpdate(subject, id, (key, oldValue) => id);
}
}
using (var stream = new MemoryStream())
{
//Confluent Kafka format:
//https://docs.confluent.io/current/schema-registry/docs/serializer-formatter.html#wire-format
//Magic number
stream.WriteByte(0x00);
//Id
var idAsBytes = BitConverter.GetBytes(id);
stream.Write(idAsBytes, 0, idAsBytes.Length);
//Data
var serializedData = AvroConvert.SerializeHeadless(data, schema);
stream.Write(serializedData, 0, serializedData.Length);
return(stream.ToArray());
}
}
public void Component_DeserializeWithMissingFields_NoError()
{
//Arrange
BaseTestClass toSerialize = _fixture.Create <BaseTestClass>();
string schema = AvroConvert.GenerateSchema(typeof(BaseTestClass));
//Act
var result = AvroConvert.SerializeHeadless(toSerialize, schema);
var deserialized = AvroConvert.DeserializeHeadless <ReducedBaseTestClass>(result, schema);
//Assert
Assert.NotNull(result);
Assert.NotNull(deserialized);
Assert.Equal(toSerialize.justSomeProperty, deserialized.justSomeProperty);
}
public void Component_SerializeHeadlessBiggerObjectAndReadSmaller_NoError()
{
//Arrange
VeryComplexClass toSerialize = _fixture.Create <VeryComplexClass>();
string schema = AvroConvert.GenerateSchema(typeof(VeryComplexClass));
//Act
var result = AvroConvert.SerializeHeadless(toSerialize, schema);
var deserialized = AvroConvert.DeserializeHeadless <VeryComplexClass>(result, schema);
//Assert
Assert.NotNull(result);
Assert.NotNull(deserialized);
Assert.Equal(toSerialize, deserialized);
}
public void Component_SerializeHeadlessBiggerObjectAndReadSmaller_NoError()
{
//Arrange
ExtendedBaseTestClass toSerialize = _fixture.Create <ExtendedBaseTestClass>();
string schema = AvroConvert.GenerateSchema(typeof(BaseTestClass));
//Act
var result = AvroConvert.SerializeHeadless(toSerialize, schema);
var deserialized = AvroConvert.DeserializeHeadless <BaseTestClass>(result, schema);
//Assert
Assert.NotNull(result);
Assert.NotNull(deserialized);
Assert.Equal(toSerialize.andLongProperty, deserialized.andLongProperty);
Assert.Equal(toSerialize.justSomeProperty, deserialized.justSomeProperty);
}
public void Avro2Json_ConvertArray_ProducedDesiredJson()
{
//Arrange
var arrayTestObject = new int[] { 2, 1, 3, 7, 453, 1, 6, };
var expectedJson = JsonConvert.SerializeObject(arrayTestObject);
var schema = AvroConvert.GenerateSchema(arrayTestObject.GetType());
var avroSerialized = AvroConvert.SerializeHeadless(arrayTestObject, schema);
//Act
var resultJson = AvroConvert.Avro2Json(avroSerialized, schema);
//Assert
Assert.Equal(expectedJson, resultJson);
}
public void Avro2Json_ConvertDouble_ProducedDesiredJson()
{
//Arrange
var doubleTestObject = 21.34;
var expectedJson = JsonConvert.SerializeObject(doubleTestObject);
var schema = AvroConvert.GenerateSchema(doubleTestObject.GetType());
var avroSerialized = AvroConvert.SerializeHeadless(doubleTestObject, schema);
//Act
var resultJson = AvroConvert.Avro2Json(avroSerialized, schema);
//Assert
Assert.Equal(expectedJson, resultJson);
}
public void Avro2Json_ConvertNull_ProducedDesiredJson()
{
//Arrange
string nullTestObject = null;
var expectedJson = JsonConvert.SerializeObject(nullTestObject);
var schema = AvroConvert.GenerateSchema(nullTestObject?.GetType());
var avroSerialized = AvroConvert.SerializeHeadless(nullTestObject, schema);
//Act
var resultJson = AvroConvert.Avro2Json(avroSerialized, schema);
//Assert
Assert.Equal(expectedJson, resultJson);
}
public void Avro2Json_ConvertInt_ProducedDesiredJson()
{
//Arrange
var @int = 2137;
var expectedJson = JsonConvert.SerializeObject(@int);
var schema = AvroConvert.GenerateSchema(@int.GetType());
var avroSerialized = AvroConvert.SerializeHeadless(@int, schema);
//Act
var resultJson = AvroConvert.Avro2Json(avroSerialized, schema);
//Assert
Assert.Equal(expectedJson, resultJson);
}
public void Avro2Json_ConvertString_ProducedDesiredJson()
{
//Arrange
var @string = "I am the serialization string";
var expectedJson = JsonConvert.SerializeObject(@string);
var schema = AvroConvert.GenerateSchema(@string.GetType());
var avroSerialized = AvroConvert.SerializeHeadless(@string, schema);
//Act
var resultJson = AvroConvert.Avro2Json(avroSerialized, schema);
//Assert
Assert.Equal(expectedJson, resultJson);
}
public void GenerateClass_ClassWithLogicalTypes_OutputIsEqualToExpected()
{
//Arrange
var schema = AvroConvert.GenerateSchema(typeof(LogicalTypesClass));
//Act
string resultSchema = AvroConvert.GenerateModel(schema);
//Assert
Assert.Equal(
"public class LogicalTypesClass\r\n" +
"{\r\n" +
"\tpublic decimal One { get; set; }\r\n" +
"\tpublic Guid? Two { get; set; }\r\n" +
"\tpublic TimeSpan Three { get; set; }\r\n" +
"\tpublic DateTime? Four { get; set; }\r\n" +
"\tpublic DateTime Five { get; set; }\r\n" +
"}\r\n" +
"\r\n",
resultSchema);
}
public void Avro2Json_ConvertComplexType_ProducedDesiredJson()
{
//Arrange
var user = new User();
user.favorite_color = "blue";
user.favorite_number = 2137;
user.name = "red";
var expectedJson = JsonConvert.SerializeObject(user);
var schema = AvroConvert.GenerateSchema(user.GetType());
var avroSerialized = AvroConvert.SerializeHeadless(user, schema);
//Act
var resultJson = AvroConvert.Avro2Json(avroSerialized, schema);
//Assert
Assert.Equal(expectedJson, resultJson);
}
