public void Deserialize_CustomSchema_OnlyValuesFromCustomSchemaAreReturned()
{
//Arrange
var expectedResult = new List <User>();
expectedResult.Add(new User
{
name = "Alyssa",
favorite_number = 256,
favorite_color = null
});
expectedResult.Add(new User
{
name = "Ben",
favorite_number = 7,
favorite_color = "red"
});
//Act
var result = AvroConvert.Deserialize <List <User> >(_avroBytes);
//Assert
Assert.Equal(expectedResult, result);
}
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);
}
public void SerializeList_ThenDeserialize_ListsAreEqual()
{
//Arrange
SomeTestClass someTestClass = new SomeTestClass
{
objectProperty = new NestedTestClass
{
justSomeProperty = "spoko",
andLongProperty = 2137
},
simpleProperty = 111111
};
SomeTestClass dupa2 = new SomeTestClass
{
objectProperty = new NestedTestClass
{
justSomeProperty = "loko",
andLongProperty = 2137
},
simpleProperty = 2135
};
SomeTestClass[] someTestClasses = new SomeTestClass[2];
someTestClasses[0] = someTestClass;
someTestClasses[1] = dupa2;
//Act
var serialized = AvroConvert.Serialize(someTestClasses);
var deserialized = AvroConvert.Deserialize <List <SomeTestClass> >(serialized);
//Assert
Assert.NotNull(deserialized);
}
public void Serialize_MultiThreadSerialization_NoExceptionIsThrown()
{
//Arrange
VeryComplexClass testClass = _fixture.Create <VeryComplexClass>();
//Act
List <Task> listOfTasks = new List <Task>();
for (var counter = 0; counter < 10; counter++)
{
listOfTasks.Add(Task.Run(() =>
{
for (var iMessagesCntr = 0; iMessagesCntr < 100; iMessagesCntr++)
{
var result = AvroConvert.Serialize(testClass);
var deserialized = AvroConvert.Deserialize <VeryComplexClass>(result);
//Assert
Assert.Equal(testClass, deserialized);
Thread.Sleep(counter
);
}
}));
}
Task.WaitAll(listOfTasks.ToArray());
}
public void Component_PrivatePropertyIsMarkedAsDataMember_ItIsSerialized()
{
//Arrange
long expectedValue = 2137;
AttributeClass toSerialize = _fixture.Create <AttributeClass>();
typeof(AttributeClass)
.GetFields(BindingFlags.NonPublic | BindingFlags.Instance).FirstOrDefault(f => f.Name.Contains("privateProperty"))?
.SetValue(toSerialize, expectedValue);
//Act
var result = AvroConvert.Serialize(toSerialize);
var deserialized = AvroConvert.Deserialize <AttributeClass>(result);
//Assert
Assert.NotNull(result);
Assert.NotNull(deserialized);
var resultValue = typeof(AttributeClass)
.GetFields(BindingFlags.NonPublic | BindingFlags.Instance).FirstOrDefault(f => f.Name.Contains("privateProperty"))?
.GetValue(deserialized);
Assert.Equal(expectedValue, resultValue);
}
public void Deserialize_ValidBytes_SetOfPropertiesAreReturned()
{
//Arrange
Dictionary <string, object> result1 = new Dictionary <string, object>();
result1.Add("name", "Alyssa");
result1.Add("favorite_number", 256);
result1.Add("favorite_color", null);
Dictionary <string, object> result2 = new Dictionary <string, object>();
result2.Add("name", "Ben");
result2.Add("favorite_number", 7);
result2.Add("favorite_color", "red");
List <object> expectedResult = new List <object>();
expectedResult.Add(result1);
expectedResult.Add(result2);
//Act
var result = AvroConvert.Deserialize(_avroBytes);
//Assert
Assert.Equal(expectedResult, result);
}
private static async Task <TResponse> SendAvroAsync <TContent, TResponse>(this HttpClient httpClient, string url, HttpMethod httpMethod, TContent content = null) where TContent : class
{
HttpRequestMessage httpRequest = new HttpRequestMessage(httpMethod, url);
if (content != null)
{
var avroContent = AvroConvert.Serialize(content);
HttpContent httpContent = new ByteArrayContent(avroContent);
httpContent.Headers.Remove("Content-Type");
httpContent.Headers.ContentType = new MediaTypeHeaderValue("application/avro");
httpRequest.Content = httpContent;
}
var response = await httpClient.SendAsync(httpRequest);
if (response.IsSuccessStatusCode == false)
{
HandleErrors();
}
var responseContent = await response.Content.ReadAsByteArrayAsync();
return(AvroConvert.Deserialize <TResponse>(responseContent));
}
public void Deserialize_SnappyCodedFile_DataIsDeserialized()
{
//Arrange
List <TwitterModel> expected = new List <TwitterModel>();
expected.Add(new TwitterModel
{
Timestamp = 1366150681,
Tweet = "Rock: Nerf paper, scissors is fine.",
Username = "******"
});
expected.Add(new TwitterModel
{
Timestamp = 1366154481,
Tweet = "Works as intended. Terran is IMBA.",
Username = "******"
});
//Act
var result = AvroConvert.Deserialize <List <TwitterModel> >(_snappy);
//Assert
Assert.Equal(expected, result);
}
public void Merge_MultipleObject_AllOfThemAreMerged()
{
//Arrange
var users = _fixture.CreateMany <User>();
var avroObjects = users.Select(AvroConvert.Serialize);
//Act
var result = AvroConvert.Merge <User>(avroObjects);
//Assert
var deserializedResult = AvroConvert.Deserialize <List <User> >(result);
Assert.NotNull(deserializedResult);
Assert.Equal(users.Count(), deserializedResult.Count);
foreach (var user in users)
{
var resultUser = deserializedResult.FirstOrDefault(r => r.name == user.name);
Assert.NotNull(resultUser);
Assert.Equal(user, resultUser);
}
}
public void Serialize_ByteArray_ResultIsTheSameAsInput()
{
//Arrange
var testObject = new byte[]
{
0,
1,
2,
3,
4,
5,
6,
7,
8,
9
};
//Act
var result = AvroConvert.Serialize(testObject);
var deserialized = AvroConvert.Deserialize <byte[]>(result);
//Assert
Assert.NotNull(result);
Assert.NotNull(deserialized);
Assert.Equal(testObject, deserialized);
}
public static async Task <T> GetAsAvro <T>(this HttpClient httpClient, string requestUri)
{
var response = await httpClient.GetByteArrayAsync(requestUri);
T result = AvroConvert.Deserialize <T>(response);
return(result);
}
public void Avro_Brotli()
{
var serialized = AvroConvert.Serialize(data, CodecType.Brotli);
AvroConvert.Deserialize <List <User> >(serialized);
var path = $"C:\\test\\disk-size.{nameof(Avro_Brotli).ToLower()}.txt";
File.WriteAllText(path, ConstructSizeLog(serialized.Length));
}
public void Deserialize_SnappyFile5_NoExceptionIsThrown()
{
//Arrange
//Act
var result = Record.Exception(() => AvroConvert.Deserialize <List <ModelItem> >(System.IO.File.ReadAllBytes(userData5)));
//Assert
Assert.Null(result);
}
public void Deserialize_FileContainsNoAvroData_NoExceptionIsThrown()
{
//Arrange
//Act
var result = AvroConvert.Deserialize(_schemaOnlyAvroBytes, typeof(List <UserNameClass>));
//Assert
Assert.Equal(null, result);
}
public override async Task <InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context)
{
await using MemoryStream ms = new MemoryStream();
await context.HttpContext.Request.Body.CopyToAsync(ms);
var type = context.ModelType;
object result = AvroConvert.Deserialize(ms.ToArray(), type);
return(await InputFormatterResult.SuccessAsync(result));
}
public void Deserialize_FileWithMultipleBlocks_EveryItemIsRead()
{
//Arrange
//Act
var result = AvroConvert.Deserialize <List <kylosample> >((File.ReadAllBytes("userdata1.avro")));
//Assert
result.Should().HaveCount(1000);
}
public void Deserialize_ValidBytes_SetOfPropertiesAreReturned()
{
//Arrange
//Act
var result = AvroConvert.Deserialize(_avroBytes);
var xd = result;
//Assert
// Assert.Equal(_example2schema, schema);
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
Fixture fixture = new Fixture();
var data = fixture.Build <User>().With(u => u.Offerings, fixture.CreateMany <Offering>(50).ToList).CreateMany(100).ToArray();
var serialized = AvroConvert.Serialize(data);
var deserialized = AvroConvert.Deserialize <List <User> >(serialized);
Console.WriteLine("end World!");
Console.ReadLine();
}
public void Component_Decimal_ResultIsTheSameAsInput(string test)
{
//Arrange
var testDecimal = decimal.Parse(test, CultureInfo.InvariantCulture);
//Act
var result = AvroConvert.Serialize(testDecimal);
var deserialized = AvroConvert.Deserialize <decimal>(result);
//Assert
Assert.NotNull(result);
Assert.Equal(testDecimal, deserialized);
}
public void Component_Double_ResultIsTheSameAsInput(double testObject)
{
//Arrange
//Act
var result = AvroConvert.Serialize(testObject);
var deserialized = AvroConvert.Deserialize <double>(result);
//Assert
Assert.NotNull(result);
Assert.Equal(testObject, deserialized);
}
public void Component_ClassWithList_ListsAreEqual()
{
//Arrange
var someTestClasses = _fixture.CreateMany <BaseTestClass>().ToList();
//Act
var serialized = AvroConvert.Serialize(someTestClasses);
var deserialized = AvroConvert.Deserialize <List <BaseTestClass> >(serialized);
//Assert
Assert.NotNull(deserialized);
Assert.Equal(someTestClasses, deserialized);
}
public void Deserialize_InvalidFile_InvalidAvroObjectExceptionIsThrown()
{
//Arrange
byte[] invalidBytes = new byte[2137];
//Act
var result = Record.Exception(() => AvroConvert.Deserialize <int>(invalidBytes));
//Assert
Assert.IsType <InvalidAvroObjectException>(result);
}
public void Component_EmptyGuid_ResultIsTheSameAsInput()
{
//Arrange
Guid testClass = Guid.Empty;
//Act
var result = AvroConvert.Serialize(testClass);
var deserialized = AvroConvert.Deserialize <Guid>(result);
//Assert
Assert.NotNull(result);
Assert.Equal(testClass, deserialized);
}
public void Serialize_MinInt_ResultIsTheSameAsInput()
{
//Arrange
int testObject = int.MinValue;
//Act
var result = AvroConvert.Serialize(testObject);
var deserialized = AvroConvert.Deserialize <int>(result);
//Assert
Assert.NotNull(result);
Assert.Equal(testObject, deserialized);
}
public void Serialize_Decimal_ResultIsTheSameAsInput()
{
//Arrange
decimal testObject = 21.37m;
//Act
var result = AvroConvert.Serialize(testObject);
var deserialized = AvroConvert.Deserialize <decimal>(result);
//Assert
Assert.NotNull(result);
Assert.Equal(testObject, deserialized);
}
public void Serialize_BoolFalse_ResultIsTheSameAsInput()
{
//Arrange
bool testObject = false;
//Act
var result = AvroConvert.Serialize(testObject);
var deserialized = AvroConvert.Deserialize <bool>(result);
//Assert
Assert.NotNull(result);
Assert.Equal(testObject, deserialized);
}
public void Component_ObjectIsList_ResultIsTheSameAsInput()
{
//Arrange
List <int> dictionary = _fixture.Create <List <int> >();
//Act
var result = AvroConvert.Serialize(dictionary);
var deserialized = AvroConvert.Deserialize <List <int> >(result);
//Assert
Assert.NotNull(result);
Assert.NotNull(deserialized);
Assert.Equal(dictionary, deserialized);
}
public void Component_ObjectContainsLists_ResultIsTheSameAsInput()
{
//Arrange
ClassWithSimpleList testClass = _fixture.Create <ClassWithSimpleList>();
//Act
var result = AvroConvert.Serialize(testClass);
var deserialized = AvroConvert.Deserialize <ClassWithSimpleList>(result);
//Assert
Assert.NotNull(result);
Assert.NotNull(deserialized);
Assert.Equal(testClass.someList.Count, deserialized.someList.Count);
}
public void Component_ObjectIsIImmutableSet_ResultIsTheSameAsInput()
{
//Arrange
IImmutableSet <BaseTestClass> set = _fixture.Create <IEnumerable <BaseTestClass> >().ToImmutableHashSet();
//Act
var result = AvroConvert.Serialize(set);
var deserialized = AvroConvert.Deserialize <ImmutableHashSet <BaseTestClass> >(result);
//Assert
Assert.NotNull(result);
Assert.NotNull(deserialized);
Assert.Equal(set, deserialized);
}
public void Component_ObjectIsHashSet_ResultIsTheSameAsInput()
{
//Arrange
HashSet <int> hashset = _fixture.Create <HashSet <int> >();
//Act
var result = AvroConvert.Serialize(hashset);
var deserialized = AvroConvert.Deserialize <HashSet <int> >(result);
//Assert
Assert.NotNull(result);
Assert.NotNull(deserialized);
Assert.Equal(hashset, deserialized);
}
