public void StringShouldNotBeSerializedTwiceAsType()
{
var instance1 = new ClassWithGenericInt {
Value = 123
};
var instance2 = new ClassWithGenericInt {
Value = 321
};
var instance = new List <object> {
instance1
};
var bytes = KrakenSerializer.Serialize(instance);
var deserializedValue = KrakenSerializer.Deserialize <List <object> >(bytes);
Assert.Equal(instance, deserializedValue);
instance = new List <object> {
instance1, instance2
};
var bytesTwice = KrakenSerializer.Serialize(instance);
deserializedValue = KrakenSerializer.Deserialize <List <object> >(bytesTwice);
Assert.Equal(instance, deserializedValue);
Assert.True(bytes.Length + 500 > bytesTwice.Length);
}
public void ObjectRetrievedFromFirstLevelCacheShouldNotBeClonedIfTheyAreFromASpecificNameSpace()
{
var namespaceCloningProvider = new NamespacesBasedCloningProvider(new [] { "System" });
var cache = new SquirrelCache(_config, namespaceCloningProvider, _serializationProvider);
var testObject2 = EqualityComparer <string> .Default;
var serializedTestObject2 = KrakenSerializer.Serialize(testObject2);
var key1 = RandomKey();
var key2 = RandomKey();
cache.Set(key1, _serializedTestObject);
cache.Set(key2, serializedTestObject2);
var obj1_1 = cache.Get <object>(key1).Value;
var obj1_2 = cache.Get <object>(key1).Value;
Assert.NotNull(obj1_1);
Assert.True(ReferenceEquals(obj1_1, obj1_2));
var obj2_1 = cache.Get <object>(key2).Value;
var obj2_2 = cache.Get <object>(key2).Value;
Assert.NotNull(obj2_1);
Assert.False(ReferenceEquals(obj2_1, obj2_2));
}
public void SerializeClassWithAllPrimitiveTypes()
{
var instance = new ClassWithAllPrimitiveTypes();
var bytes = KrakenSerializer.Serialize(instance);
var deserializedValue = KrakenSerializer.Deserialize <ClassWithAllPrimitiveTypes>(bytes);
instance.Should().BeEquivalentTo(deserializedValue);
}
public RedisIntegrationTest()
{
_testObject = new CachingTestClass();
_serializedTestObject = KrakenSerializer.Serialize(_testObject);
_redisRetryPolicy = new RedisRetryPolicy(50, 100, 150);
_connection = new RedisConnection(RedisConnectionString, _redisRetryPolicy);
}
public SquirrelCacheTest()
{
_config.AbsoluteExpiration = TimeSpan.FromSeconds(5);
_config.MaximumMemorySize = 1000;
_config.TimerInterval = TimeSpan.FromSeconds(1);
_cacheRepository = new SquirrelCache(_config, _noCloningProvider, _serializationProvider);
_testObject = new CachingTestClass();
_serializedTestObject = KrakenSerializer.Serialize(_testObject);
}
public void KrakenSerializerShouldWork()
{
var instance = new GenericBaseClass <IQueryable> {
Value = null
};
var bytes = KrakenSerializer.Serialize(instance);
var deserializedValue = KrakenSerializer.Deserialize <GenericBaseClass <IQueryable> >(bytes);
Assert.NotNull(deserializedValue);
Assert.Null(deserializedValue.Value);
}
public void SetAnObjectWithTtlSync()
{
var key = RandomKey();
_connection.Set(key, _serializedTestObject, ttl: TimeSpan.FromSeconds(30));
var redisVal = _connection.Get(key);
Assert.NotNull(redisVal);
var obj = KrakenSerializer.Deserialize <CachingTestClass>(redisVal);
Assert.Equal(_testObject.Value, obj.Value);
Assert.True(_connection.GetTimeToLive(key).TimeToLive > TimeSpan.FromSeconds(25));
}
public async Task SetAnObjectWithTtlAsync()
{
var key = RandomKey();
await _connection.SetAsync(key, _serializedTestObject, ttl : TimeSpan.FromSeconds(30)).ConfigureAwait(false);
var redisVal = await _connection.GetAsync(key).ConfigureAwait(false);
Assert.NotNull(redisVal);
var obj = KrakenSerializer.Deserialize <CachingTestClass>(redisVal);
Assert.Equal(_testObject.Value, obj.Value);
Assert.True((await _connection.GetTimeToLiveAsync(key).ConfigureAwait(false)).TimeToLive > TimeSpan.FromSeconds(25));
}
public void StringShouldNotBeSerializedTwice2Properties()
{
var str = RandomString(1000);
var instance1 = new ClassWith2Property <string>(str, null);
var instance2 = new ClassWith2Property <string>(str, str);
var bytes = KrakenSerializer.Serialize(instance1);
var deserializedValue = KrakenSerializer.Deserialize <ClassWith2Property <string> >(bytes);
instance1.Should().BeEquivalentTo(deserializedValue);
var bytesTwice = KrakenSerializer.Serialize(instance2);
deserializedValue = KrakenSerializer.Deserialize <ClassWith2Property <string> >(bytesTwice);
instance2.Should().BeEquivalentTo(deserializedValue);
Assert.True(bytes.Length + 500 > bytesTwice.Length);
}
public void SetAnObjectWithoutTtlSync()
{
var key = RandomKey();
try
{
_connection.Set(key, _serializedTestObject);
var redisVal = _connection.Get(key);
Assert.NotNull(redisVal);
var obj = KrakenSerializer.Deserialize <CachingTestClass>(redisVal);
Assert.Equal(_testObject.Value, obj.Value);
Assert.Null(_connection.GetTimeToLive(key).TimeToLive);
}
finally
{
_connection.Remove(key);
}
}
public void ObjectShouldBeReplaced()
{
var bigTestObject = new CachingTestClass()
{
ByteArray = new bool[800]
};
var bigSerializedTestObject = KrakenSerializer.Serialize(bigTestObject);
var key = Guid.NewGuid().ToString();
_cacheRepository.Set(key, _serializedTestObject);
WaitFor(0.5);
Assert.Equal(_serializedTestObject.Length, _cacheRepository.EstimatedMemorySize);
_cacheRepository.Set(key, bigSerializedTestObject);
WaitFor(0.5);
Assert.Equal(bigSerializedTestObject.Length, _cacheRepository.EstimatedMemorySize);
Assert.Equal(1, _cacheRepository.NumberOfObjects);
}
public void ObjectShouldBeRemovedFromTheCacheBecauseTheCacheIsOverTheConfiguredMemoryLimit()
{
var bigTestObject = new CachingTestClass()
{
ByteArray = new bool[1000]
};
var bigSerializedTestObject = KrakenSerializer.Serialize(bigTestObject);
var key = Guid.NewGuid().ToString();
_cacheRepository.Set(key, bigSerializedTestObject);
Assert.True(_cacheRepository.EstimatedMemorySize > _config.MaximumMemorySize);
WaitFor(_config.TimerInterval.TotalSeconds * 2);
Assert.Equal(0, _cacheRepository.EstimatedMemorySize);
Assert.Equal(0, _cacheRepository.NumberOfObjects);
}
public async Task SetAnObjectWithoutTtlAsync()
{
var key = RandomKey();
try
{
await _connection.SetAsync(key, _serializedTestObject).ConfigureAwait(false);
var redisVal = await _connection.GetAsync(key).ConfigureAwait(false);
Assert.NotNull(redisVal);
var obj = KrakenSerializer.Deserialize <CachingTestClass>(redisVal);
Assert.Equal(_testObject.Value, obj.Value);
Assert.Null((await _connection.GetTimeToLiveAsync(key).ConfigureAwait(false)).TimeToLive);
}
finally
{
_connection.Remove(key);
}
}
public void StringShouldNotBeSerializedTwiceAsADictionaryValue()
{
var str = RandomString(1000);
var instance1 = new Dictionary <int, string> {
{ 123, str }
};
var instance2 = new Dictionary <int, string> {
{ 123, str }, { 1235, str }
};
var bytes = KrakenSerializer.Serialize(instance1);
var deserializedValue = KrakenSerializer.Deserialize <Dictionary <int, string> >(bytes);
instance1.Should().BeEquivalentTo(deserializedValue);
var bytesTwice = KrakenSerializer.Serialize(instance2);
deserializedValue = KrakenSerializer.Deserialize <Dictionary <int, string> >(bytesTwice);
instance2.Should().BeEquivalentTo(deserializedValue);
Assert.True(bytes.Length + 500 > bytesTwice.Length);
}
public void StringShouldNotBeSerializedTwiceInsideAList()
{
var str = RandomString(1000);
var instance = new List <string> {
str
};
var bytes = KrakenSerializer.Serialize(instance);
var deserializedValue = KrakenSerializer.Deserialize <List <string> >(bytes);
Assert.Equal(instance, deserializedValue);
instance = new List <string> {
str, str
};
var bytesTwice = KrakenSerializer.Serialize(instance);
deserializedValue = KrakenSerializer.Deserialize <List <string> >(bytesTwice);
Assert.Equal(instance, deserializedValue);
Assert.True(bytes.Length + 500 > bytesTwice.Length);
}
public void OmittedRootTypeCanBeDeserialized()
{
var instance = new ClassWithAllPrimitiveTypes();
var bytesWithType = KrakenSerializer.Serialize(instance);
var bytesWithOmittedType = KrakenSerializer.Serialize(instance, new SerializationOptions()
{
OmitRootTypeName = true
});
Assert.True(bytesWithOmittedType.Length < bytesWithType.Length);
var deserializedValue = KrakenSerializer.Deserialize <ClassWithAllPrimitiveTypes>(bytesWithType);
var deserializedValueFromOmitted = KrakenSerializer.Deserialize <ClassWithAllPrimitiveTypes>(bytesWithOmittedType, new SerializationOptions()
{
OmitRootTypeName = true
});
instance.Should().BeEquivalentTo(deserializedValue);
deserializedValueFromOmitted.Should().BeEquivalentTo(deserializedValue);
}
public void ObjectsShouldBeRemovedInTheOrderTheyWereAddedOnceTheCacheisOverTheConfiguredMemoryLimit()
{
var bigTestObject = new CachingTestClass()
{
ByteArray = new bool[800]
};
var bigSerializedTestObject = KrakenSerializer.Serialize(bigTestObject);
var key1 = Guid.NewGuid().ToString();
var key2 = Guid.NewGuid().ToString();
_cacheRepository.Set(key1, _serializedTestObject);
_cacheRepository.Set(key2, bigSerializedTestObject);
Assert.True(_cacheRepository.EstimatedMemorySize > _config.MaximumMemorySize);
WaitFor(_config.TimerInterval.TotalSeconds * 2);
Assert.Equal(bigSerializedTestObject.Length, _cacheRepository.EstimatedMemorySize);
Assert.Equal(1, _cacheRepository.NumberOfObjects);
Assert.True(_cacheRepository.Get <CachingTestClass>(key2).IsSuccessful);
Assert.NotNull(_cacheRepository.Get <CachingTestClass>(key2).Value);
}
/// <inheritdoc/>
public T Deserialize <T>(byte[] bytes)
where T : class
{
return(KrakenSerializer.Deserialize <T>(bytes));
}
/// <inheritdoc/>
public object Deserialize(byte[] bytes)
{
return(KrakenSerializer.Deserialize(bytes));
}
/// <inheritdoc/>
public byte[] Serialize <T>(T value)
where T : class
{
return(KrakenSerializer.Serialize(value));
}
