public async Task VerifyGenericSerialization()
{
var order = new MainDataOne();
order.Name = "G_Test";
await Redis.Client.AddRecord <IMainData>(new ObjectKey("order"), order).ConfigureAwait(false);
var result = (MainDataOne)await Redis.Client.GetRecords <IMainData>(new ObjectKey("order")).LastOrDefaultAsync();
Assert.AreEqual(order.Name, result.Name);
}
public void SerializeObject()
{
var order = new MainDataOne();
order.Name = "Test";
var serializerTests = new BinaryDataSerializer();
var data = serializerTests.Serialize(order);
var orderResult = (IMainData)serializerTests.Deserialize(typeof(MainDataOne), data);
Assert.AreNotSame(order, orderResult);
Assert.AreEqual("Test", orderResult.Name);
}
public void Serialize()
{
var order = new MainDataOne();
order.Name = "Test";
var serializerTests = new ZipBinaryDataSerializer();
var data = serializerTests.Serialize(order);
var orderResult = serializerTests.Deserialize <MainDataOne>(data);
Assert.AreNotSame(order, orderResult);
Assert.AreEqual("Test", orderResult.Name);
}
public void SerializeWellknown()
{
var order = new MainDataOne();
order.Name = "Test";
FlatProtoDataSerializer serializer = new FlatProtoDataSerializer(true, stream);
var data = serializer.Serialize(order);
var orderResult = serializer.Deserialize <MainDataOne>(data);
Assert.AreNotSame(order, orderResult);
Assert.AreEqual(36, data.Length);
Assert.AreEqual("Test", orderResult.Name);
}
public void SerializeObject()
{
var order = new MainDataOne();
order.Name = "Test";
var serializerTests = new FlatProtoDataSerializer(false, stream);
var data = serializerTests.Serialize <IMainData>(order);
var orderResult = (IMainData)serializerTests.Deserialize(typeof(IMainData), data);
Assert.AreNotSame(order, orderResult);
Assert.AreEqual(116, data.Length);
Assert.AreEqual("Test", orderResult.Name);
}
public void SerializeObject(bool serialize, int size)
{
var order = new MainDataOne();
order.Name = "Test";
var serializerTests = new XmlDataSerializer(serialize);
var data = serializerTests.Serialize(order);
var orderResult = (IMainData)serializerTests.Deserialize(typeof(MainDataOne), data);
Assert.AreNotSame(order, orderResult);
Assert.AreEqual(size, data.Length);
Assert.AreEqual("Test", orderResult.Name);
}
public void Setup()
{
data = new MainDataOne();
indexManager = new Mock <IMainIndexManager>();
redisSetList = new Mock <IRedisSetList>();
key = new ObjectKey("Test");
redis = new Mock <IRedisLink>();
redis.Setup(item => item.Resilience).Returns(new ResilienceHandler(new NullLogger <ResilienceHandler>(), new ResilienceConfig()));
redis.Setup(item => item.State).Returns(ChannelState.Open);
redis.Setup(item => item.LinkId).Returns(0);
redis.Setup(item => item.Generator).Returns(new ScriptGenerator());
serializer = new Mock <IDataSerializer>();
database = new Mock <IDatabaseAsync>();
instance = new ListSerialization <MainDataOne>(new NullLogger <ListSerialization <MainDataOne> >(), redis.Object, redisSetList.Object, indexManager.Object, serializer.Object);
}
public async Task GetRecords()
{
Assert.ThrowsAsync <ArgumentNullException>(async() => await instance.GetRecords(database.Object, null));
Assert.ThrowsAsync <ArgumentNullException>(async() => await instance.GetRecords(null, key));
var dataInstance = new MainDataOne();
dataInstance.Name = "Test";
serializer.Setup(item => item.Deserialize <MainDataOne>(It.IsAny <byte[]>())).Returns(dataInstance);
redisSetList.Setup(
item =>
item.GetRedisValues(It.IsAny <IDatabaseAsync>(), It.IsAny <RedisKey>(), 0, -1))
.Returns(Task.FromResult(new RedisValue[] { new byte[] { 1 } }));
var records = await instance.GetRecords(database.Object, key).ToArray();
Assert.AreEqual(1, records.Count());
}
