public object Remove(string key)
{
var old = cache.Get <object>(key);
cache.Set <object>(key, null);
return(old);
}
public void DistributedCacheEmulator_SetWithExpiration_WorksProperly()
{
using (new MunqContext())
{
var registrar = Dependency.Resolve <IDependencyRegistrar>();
DateTimeProvider.StaticProvider = null;
DateTime now = DateTime.Now;
var dateTime = A.Fake <IDateTimeProvider>();
A.CallTo(() => dateTime.Now).ReturnsLazily(() => now);
registrar.RegisterInstance(dateTime);
var cache = new DistributedCacheEmulator();
cache.Set("SomeInt", 13579, TimeSpan.FromSeconds(5));
var actualInt = cache.Get <int>("SomeInt");
Assert.Equal(13579, actualInt);
now = now.AddSeconds(1);
var notExpiredInt = cache.Get <int>("SomeInt");
Assert.Equal(13579, notExpiredInt);
now = now.AddSeconds(6);
var expiredInt = cache.Get <int>("SomeInt");
Assert.Equal(0, expiredInt);
}
}
public void DistributedCacheEmulator_SetWithExpiration_WorksMultiThreaded()
{
var cache = new DistributedCacheEmulator();
var threads = new int[100];
for (var i = 0; i < threads.Length; i++)
{
threads[i] = i;
}
Parallel.ForEach(threads, x =>
{
cache.Set("MultiThreadedValue" + x, x * 7, TimeSpan.FromMilliseconds(100));
});
Thread.Sleep(1);
for (var i = 0; i < threads.Length; i++)
{
var actual = cache.Get <int>("MultiThreadedValue" + threads[i]);
Assert.Equal(threads[i] * 7, actual);
}
Thread.Sleep(110);
for (var i = 0; i < threads.Length; i++)
{
var actual = cache.Get <int>("MultiThreadedValue" + threads[i]);
Assert.Equal(0, actual);
}
}
public void DistributedCacheEmulator_Get_ReturnsDefaultIfValueNotInCache()
{
var cache = new DistributedCacheEmulator();
var actualInt = cache.Get<int>("NonExistingInt");
Assert.Equal(0, actualInt);
var actualStr = cache.Get<string>("NonExistingString");
Assert.Equal(null, actualStr);
var actualBool = cache.Get<bool>("NonExistingBoolean");
Assert.Equal(false, actualBool);
}
public void DistributedCacheEmulator_Get_ReturnsDefaultIfValueNotInCache()
{
var cache = new DistributedCacheEmulator();
var actualInt = cache.Get <int>("NonExistingInt");
Assert.Equal(0, actualInt);
var actualStr = cache.Get <string>("NonExistingString");
Assert.Equal(null, actualStr);
var actualBool = cache.Get <bool>("NonExistingBoolean");
Assert.Equal(false, actualBool);
}
public void DistributedCacheEmulator_Increment_SetsValueToOneIfKeyNotInCache()
{
var cache = new DistributedCacheEmulator();
var actual = cache.Increment("NotExistingValue", 7);
Assert.Equal(1, actual);
var inCache = cache.Get<long>("NotExistingValue");
Assert.Equal(1, inCache);
}
public void DistributedCacheEmulator_Set_WorksProperly()
{
var cache = new DistributedCacheEmulator();
cache.Set("SomeInt", 13579);
var actualInt = cache.Get <int>("SomeInt");
Assert.Equal(13579, actualInt);
cache.Set("SomeStr", "abc");
var actualStr = cache.Get <string>("SomeStr");
Assert.Equal("abc", actualStr);
cache.Set("SomeBool", true);
var actualBool = cache.Get <bool>("SomeBool");
Assert.Equal(true, actualBool);
}
public void DistributedCacheEmulator_SetWithExpiration_WorksMultiThreaded()
{
using (new MunqContext())
{
DateTimeProvider.StaticProvider = null;
var registrar = Dependency.Resolve <IDependencyRegistrar>();
DateTime now = DateTime.Now;
var dateTime = A.Fake <IDateTimeProvider>();
A.CallTo(() => dateTime.Now).ReturnsLazily(() => now);
registrar.RegisterInstance(dateTime);
var cache = new DistributedCacheEmulator();
var threads = new int[100];
for (var i = 0; i < threads.Length; i++)
{
threads[i] = i;
}
Parallel.ForEach(threads, x =>
{
cache.Set("MultiThreadedValue" + x, x * 7, TimeSpan.FromSeconds(5));
});
now = now.AddSeconds(1);
for (var i = 0; i < threads.Length; i++)
{
var actual = cache.Get <int>("MultiThreadedValue" + threads[i]);
Assert.Equal(threads[i] * 7, actual);
}
now = now.AddSeconds(6);
for (var i = 0; i < threads.Length; i++)
{
var actual = cache.Get <int>("MultiThreadedValue" + threads[i]);
Assert.Equal(0, actual);
}
}
}
public void DistributedCacheEmulator_Increment_ProperlyIncrementsValueInCache()
{
var cache = new DistributedCacheEmulator();
cache.Set("ExistingValue", 100);
var actual = cache.Increment("ExistingValue", 3);
Assert.Equal(103, actual);
var inCache = cache.Get<long>("ExistingValue");
Assert.Equal(103, inCache);
}
public void DistributedCacheEmulator_Increment_SetsValueToOneIfKeyNotInCache()
{
var cache = new DistributedCacheEmulator();
var actual = cache.Increment("NotExistingValue", 7);
Assert.Equal(1, actual);
var inCache = cache.Get <long>("NotExistingValue");
Assert.Equal(1, inCache);
}
public void DistributedCacheEmulator_SetWithExpiration_WorksProperly()
{
var cache = new DistributedCacheEmulator();
cache.Set("SomeInt", 13579, TimeSpan.FromMilliseconds(100));
var actualInt = cache.Get <int>("SomeInt");
Assert.Equal(13579, actualInt);
Thread.Sleep(1);
var notExpiredInt = cache.Get <int>("SomeInt");
Assert.Equal(13579, notExpiredInt);
Thread.Sleep(110);
var expiredInt = cache.Get <int>("SomeInt");
Assert.Equal(0, expiredInt);
}
public void DistributedCacheEmulator_Increment_ProperlyIncrementsValueInCache()
{
var cache = new DistributedCacheEmulator();
cache.Set("ExistingValue", 100);
var actual = cache.Increment("ExistingValue", 3);
Assert.Equal(103, actual);
var inCache = cache.Get <long>("ExistingValue");
Assert.Equal(103, inCache);
}
public void DistributedCacheEmulator_Get_WorksMultiThreaded()
{
var cache = new DistributedCacheEmulator();
cache.Set("MultiThreadedValue", 12345);
var values = new HashSet<int>();
Parallel.ForEach(new int[100], x =>
{
var result = cache.Get<int>("MultiThreadedValue");
lock (values)
values.Add(result);
});
Assert.Equal(12345, values.First());
}
public void DistributedCacheEmulator_Get_WorksMultiThreaded()
{
var cache = new DistributedCacheEmulator();
cache.Set("MultiThreadedValue", 12345);
var values = new HashSet <int>();
Parallel.ForEach(new int[100], x =>
{
var result = cache.Get <int>("MultiThreadedValue");
lock (values)
values.Add(result);
});
Assert.Equal(12345, values.First());
}
public void DistributedCacheEmulator_Set_WorksMultiThreaded()
{
var cache = new DistributedCacheEmulator();
var threads = new int[100];
for (var i = 0; i < threads.Length; i++)
{
threads[i] = i;
}
Parallel.ForEach(threads, x =>
{
cache.Set("MultiThreadedValue" + x, x * 7);
});
for (var i = 0; i < threads.Length; i++)
{
var actual = cache.Get <int>("MultiThreadedValue" + threads[i]);
Assert.Equal(threads[i] * 7, actual);
}
}
public void DistributedCacheEmulator_Reset_ClearsCacheItems()
{
var cache = new DistributedCacheEmulator();
cache.Set("SomeInt", 1);
cache.Set("SomeStr", "str");
cache.Set("WithExpiration", true, TimeSpan.FromHours(10));
Assert.Equal(1, cache.Get <int?>("SomeInt"));
Assert.Equal("str", cache.Get <string>("SomeStr"));
Assert.True(cache.Get <bool?>("WithExpiration"));
cache.Reset();
Assert.Null(cache.Get <int?>("SomeInt"));
Assert.Null(cache.Get <string>("SomeStr"));
Assert.Null(cache.Get <bool?>("WithExpiration"));
}
public void DistributedCacheEmulatorTests()
{
DependencyContext.Using(c =>
{
var dateTimeProvider = new FakeDateTimeProvider();
var cacheEmulator = new DistributedCacheEmulator();
var key = "test";
var value = new object();
var cacheTimeout = 30;
dateTimeProvider.Now = new DateTime(2000, 1, 1, 0, 0, 0);
A.CallTo(() => c.Resolver.TryResolve<IDateTimeProvider>())
.ReturnsLazily(() => dateTimeProvider);
Assert.Null(cacheEmulator.Get<object>(key));
cacheEmulator.Set(key, value, TimeSpan.FromSeconds(cacheTimeout));
Assert.Equal(value, cacheEmulator.Get<object>(key));
dateTimeProvider.Now = dateTimeProvider.Now.AddSeconds(60);
Assert.Null(cacheEmulator.Get<object>(key));
cacheEmulator.Set(key, value, TimeSpan.FromSeconds(cacheTimeout));
Assert.Equal(value, cacheEmulator.Get<object>(key));
cacheEmulator.Set(key, value);
dateTimeProvider.Now = dateTimeProvider.Now.AddSeconds(60);
Assert.Equal(value, cacheEmulator.Get<object>(key));
cacheEmulator.Reset();
Assert.Null(cacheEmulator.Get<object>(key));
Assert.Equal(1, cacheEmulator.Increment(key));
Assert.Equal(2, cacheEmulator.Increment(key));
cacheEmulator.Reset();
Assert.Equal(2, cacheEmulator.Increment(key, 2));
});
}
public void DistributedCacheEmulator_SetWithExpiration_WorksProperly()
{
var cache = new DistributedCacheEmulator();
cache.Set("SomeInt", 13579, TimeSpan.FromMilliseconds(100));
var actualInt = cache.Get<int>("SomeInt");
Assert.Equal(13579, actualInt);
Thread.Sleep(1);
var notExpiredInt = cache.Get<int>("SomeInt");
Assert.Equal(13579, notExpiredInt);
Thread.Sleep(110);
var expiredInt = cache.Get<int>("SomeInt");
Assert.Equal(0, expiredInt);
}
public void DistributedCacheEmulator_SetWithExpiration_WorksMultiThreaded()
{
using (new MunqContext())
{
DateTimeProvider.StaticProvider = null;
var registrar = Dependency.Resolve<IDependencyRegistrar>();
DateTime now = DateTime.Now;
var dateTime = A.Fake<IDateTimeProvider>();
A.CallTo(() => dateTime.Now).ReturnsLazily(() => now);
registrar.RegisterInstance(dateTime);
var cache = new DistributedCacheEmulator();
var threads = new int[100];
for (var i = 0; i < threads.Length; i++)
threads[i] = i;
Parallel.ForEach(threads, x =>
{
cache.Set("MultiThreadedValue" + x, x * 7, TimeSpan.FromSeconds(5));
});
now = now.AddSeconds(1);
for (var i = 0; i < threads.Length; i++)
{
var actual = cache.Get<int>("MultiThreadedValue" + threads[i]);
Assert.Equal(threads[i] * 7, actual);
}
now = now.AddSeconds(6);
for (var i = 0; i < threads.Length; i++)
{
var actual = cache.Get<int>("MultiThreadedValue" + threads[i]);
Assert.Equal(0, actual);
}
}
}
public void DistributedCacheEmulator_SetWithExpiration_WorksProperly()
{
using (new MunqContext())
{
var registrar = Dependency.Resolve<IDependencyRegistrar>();
DateTimeProvider.StaticProvider = null;
DateTime now = DateTime.Now;
var dateTime = A.Fake<IDateTimeProvider>();
A.CallTo(() => dateTime.Now).ReturnsLazily(() => now);
registrar.RegisterInstance(dateTime);
var cache = new DistributedCacheEmulator();
cache.Set("SomeInt", 13579, TimeSpan.FromSeconds(5));
var actualInt = cache.Get<int>("SomeInt");
Assert.Equal(13579, actualInt);
now = now.AddSeconds(1);
var notExpiredInt = cache.Get<int>("SomeInt");
Assert.Equal(13579, notExpiredInt);
now = now.AddSeconds(6);
var expiredInt = cache.Get<int>("SomeInt");
Assert.Equal(0, expiredInt);
}
}
public void DistributedCacheEmulator_Set_WorksMultiThreaded()
{
var cache = new DistributedCacheEmulator();
var threads = new int[100];
for (var i = 0; i < threads.Length; i++)
threads[i] = i;
Parallel.ForEach(threads, x =>
{
cache.Set("MultiThreadedValue" + x, x * 7);
});
for (var i = 0; i < threads.Length; i++)
{
var actual = cache.Get<int>("MultiThreadedValue" + threads[i]);
Assert.Equal(threads[i] * 7, actual);
}
}
public void DistributedCacheEmulator_Set_WorksProperly()
{
var cache = new DistributedCacheEmulator();
cache.Set("SomeInt", 13579);
var actualInt = cache.Get<int>("SomeInt");
Assert.Equal(13579, actualInt);
cache.Set("SomeStr", "abc");
var actualStr = cache.Get<string>("SomeStr");
Assert.Equal("abc", actualStr);
cache.Set("SomeBool", true);
var actualBool = cache.Get<bool>("SomeBool");
Assert.Equal(true, actualBool);
}
public void DistributedCacheEmulator_SetWithExpiration_WorksMultiThreaded()
{
var cache = new DistributedCacheEmulator();
var threads = new int[100];
for (var i = 0; i < threads.Length; i++)
threads[i] = i;
Parallel.ForEach(threads, x =>
{
cache.Set("MultiThreadedValue" + x, x * 7, TimeSpan.FromMilliseconds(100));
});
Thread.Sleep(1);
for (var i = 0; i < threads.Length; i++)
{
var actual = cache.Get<int>("MultiThreadedValue" + threads[i]);
Assert.Equal(threads[i] * 7, actual);
}
Thread.Sleep(110);
for (var i = 0; i < threads.Length; i++)
{
var actual = cache.Get<int>("MultiThreadedValue" + threads[i]);
Assert.Equal(0, actual);
}
}