public void Memory_Cache_Simple_Tests_Succeed()
{
ICacheProvider provider = new MemoryCacheProvider();
var user = provider.Get <User>("user_1");
Assert.IsNull(user);
var user1 = provider.Get("user_1", () => new User(1, Guid.NewGuid()));
var user2 = provider.Get("user_1", () => new User(1, Guid.NewGuid()));
var user3 = provider.Get("user_3", () => new User(1, Guid.NewGuid()));
Assert.AreEqual(user1.Guid, user2.Guid);
Assert.AreNotEqual(user1.Guid, user3.Guid);
Assert.IsFalse(provider.IsSet("user_4"));
Assert.IsTrue(provider.IsSet("user_3"));
provider.Remove("user_1");
Assert.IsFalse(provider.IsSet("user_1"));
provider.Clear();
Assert.IsFalse(provider.IsSet("user_2"));
Assert.IsFalse(provider.IsSet("user_3"));
}
public async Task GetItemThatDoesNotExistTest()
{
_cacheProvider.Initialize("test", _enabledSettings);
const string key = "TestKey";
var results = await _cacheProvider.Get(key, "FirstRegion");
Assert.IsNull(results);
}
public void MemoryCache_Remove()
{
var key = Guid.NewGuid().ToString("N");
using (var memoryCache = new MemoryCacheProvider("test"))
{
memoryCache.Set(key, "something");
Assert.Equal("something", memoryCache.Get <string>(key));
memoryCache.Remove(key);
Assert.Null(memoryCache.Get <string>(key));
}
}
public void should_absolutly_expired()
{
var cacheProvider = new MemoryCacheProvider();
cacheProvider.Put("key", new Boo {
Num = 13
}, 5.Seconds());
Thread.Sleep(3000);
cacheProvider.Get <Boo>("key");
Thread.Sleep(3000);
Assert.Throws <InvalidOperationException>(() => cacheProvider.Get <Boo>("key"), "Объект должен быть удален из кеша.");
}
public void Memory_Cache_Expiration_Tests_Succeed()
{
ICacheProvider provider = new MemoryCacheProvider();
var user1 = provider.Get("user_1", () => new User(1, Guid.NewGuid()), 1);//expiration time of one minute
Assert.IsNotNull(user1);
var user1Reloaded = provider.Get("user_1", () => new User(1, Guid.NewGuid()), 1);
Assert.AreSame(user1, user1Reloaded);
Thread.Sleep(60 * 1000); //one minute sleep
user1Reloaded = provider.Get("user_1", () => new User(1, Guid.NewGuid()), 1);
Assert.AreNotSame(user1, user1Reloaded);
}
public void Can_set_and_get_object_from_cache()
{
var cacheManager = new MemoryCacheProvider();
cacheManager.Set("some_key_1", 3, int.MaxValue);
cacheManager.Get <int>("some_key_1").ShouldEqual(3);
}
public void Get()
{
MemoryCacheProvider cachePro = new MemoryCacheProvider();
var ch1 = cachePro.Get <int>("tetcache", () => 123, new TimeSpan(0, 0, 3));
Assert.AreEqual(123, ch1, "默认缓存");
Thread.Sleep(4);
Assert.AreEqual(false, MemoryCache.Default.Contains("tetcache"), "缓存已经过期");
}
public void should_return_value()
{
var cacheProvider = new MemoryCacheProvider();
cacheProvider.Put("key", new Boo {
Num = 13
}, 5.Seconds());
var value = cacheProvider.Get <Boo>("key");
value.Num.Should().
Be(13);
}
public void Get_should_return_null_on_unknown_key()
{
#if PORTABLE
MemoryCacheImplementation memoryCache = new Microsoft.Extensions.Caching.Memory.MemoryCache(new Microsoft.Extensions.Caching.Memory.MemoryCacheOptions());
#else
MemoryCacheImplementation memoryCache = System.Runtime.Caching.MemoryCache.Default;
#endif
MemoryCacheProvider provider = new MemoryCacheProvider(memoryCache);
object got = provider.Get(Guid.NewGuid().ToString());
got.Should().BeNull();
}
public void Adds_Function_Correctly()
{
var collection = new List<KeyValuePair<string, CachedValue<string>>>
{
new KeyValuePair<string, CachedValue<string>>("key2", new CachedValue<string>("value2")),
new KeyValuePair<string, CachedValue<string>>("key3", new CachedValue<string>("value3")),
};
using (var provider = new MemoryCacheProvider<string, string>())
{
provider.Add("key1", new CachedValue<string>("value2"));
provider.Add("key1", new CachedValue<string>("value1"));
provider.Add(collection);
Assert.AreEqual(3, provider.Count());
Assert.AreEqual("value1", provider.Get("key1").Value);
Assert.IsTrue(provider.Get("non-existant").IsExpired);
foreach (var value in provider.Get(new List<string> { "key2", "key3" }))
{
Assert.IsTrue(collection.Any(item => item.Value.Value == value.Value));
}
}
}
public void GetTest()
{
var provider = new MemoryCacheProvider();
var cacheKey = new CacheKey("GetTest" + DateTime.Now.Ticks);
var value = "Get Value " + DateTime.Now;
var cachePolicy = new CachePolicy();
bool result = provider.Add(cacheKey, value, cachePolicy);
result.Should().BeTrue();
var existing = provider.Get(cacheKey);
existing.Should().NotBeNull();
existing.Should().BeSameAs(value);
}
public void Enumerable_Function_Correctly()
{
var provider = new MemoryCacheProvider<string, string>()
{
{ "key1", new CachedValue<string>("value1") },
{ "key2", new CachedValue<string>("value2") },
{ "key3", new CachedValue<string>("value3") },
};
foreach (var item in provider)
{
Assert.AreEqual(item.Value, provider.Get(item.Key));
}
// for code coverage sake
var enumerator = ((System.Collections.IEnumerable)provider).GetEnumerator();
}
public void Get_should_return_instance_previously_stored_in_cache()
{
#if PORTABLE
MemoryCacheImplementation memoryCache = new Microsoft.Extensions.Caching.Memory.MemoryCache(new Microsoft.Extensions.Caching.Memory.MemoryCacheOptions());
#else
MemoryCacheImplementation memoryCache = System.Runtime.Caching.MemoryCache.Default;
#endif
string key = "anything";
object value = new object();
#if PORTABLE
using (Microsoft.Extensions.Caching.Memory.ICacheEntry entry = memoryCache.CreateEntry(key)) {
entry.AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(10);
entry.Value = value;
}
#else
memoryCache[key] = value;
#endif
MemoryCacheProvider provider = new MemoryCacheProvider(memoryCache);
object got = provider.Get(key);
got.Should().BeSameAs(value);
}
private static void Cache()
{
ICacheManager cache = new MemoryCacheProvider();
int[] array = { 1, 2, 3 };
//cache.Set("cache","Test",60);
//string str = cache.Get<string>("cache");
//Console.Write(str);
//cache.Remove("cache");
//string str2 = cache.Get<string>("cache");
//Console.Write("空："+str2);
cache.Set("cacheTest", array, 60);
var arr = cache.Get<int[]>("cacheTest");
Console.Write(arr[1]);
}
public void ExpireTest()
{
var cache = MemoryCache.Default;
// purge all values
foreach (KeyValuePair <string, object> pair in cache)
{
cache.Remove(pair.Key);
}
var provider = new MemoryCacheProvider();
string key = "AddTest" + DateTime.Now.Ticks;
var tags = new[] { "a", "b" };
var cacheKey = new CacheKey(key, tags);
var value = "Test Value " + DateTime.Now;
var cachePolicy = new CachePolicy();
bool result = provider.Add(cacheKey, value, cachePolicy);
result.Should().BeTrue();
// add second value with same tag
string key2 = "AddTest2" + DateTime.Now.Ticks;
var tags2 = new[] { "a", "c" };
var cacheKey2 = new CacheKey(key2, tags2);
var value2 = "Test Value 2 " + DateTime.Now;
var cachePolicy2 = new CachePolicy();
bool result2 = provider.Add(cacheKey2, value2, cachePolicy2);
result2.Should().BeTrue();
// add third value with same tag
string key3 = "AddTest3" + DateTime.Now.Ticks;
var tags3 = new[] { "b", "c" };
var cacheKey3 = new CacheKey(key3, tags3);
var value3 = "Test Value 3 " + DateTime.Now;
var cachePolicy3 = new CachePolicy();
bool result3 = provider.Add(cacheKey3, value3, cachePolicy3);
result3.Should().BeTrue();
var cacheTag = new CacheTag("a");
string tagKey = MemoryCacheProvider.GetTagKey(cacheTag);
tagKey.Should().NotBeNullOrEmpty();
// underlying cache
cache.GetCount().Should().Be(6);
var cachedTag = cache.Get(tagKey);
cachedTag.Should().NotBeNull();
// expire actually just changes the value for tag key
provider.Expire(cacheTag);
var expiredTag = cache.Get(tagKey);
expiredTag.Should().NotBeNull();
expiredTag.Should().NotBe(cachedTag);
// items should have been removed
var expiredValue = provider.Get(cacheKey);
expiredValue.Should().BeNull();
var expiredValue2 = provider.Get(cacheKey2);
expiredValue2.Should().BeNull();
var expiredValue3 = provider.Get(cacheKey3);
expiredValue3.Should().NotBeNull();
cache.GetCount().Should().Be(4);
}
public void should_return_value()
{
var cacheProvider = new MemoryCacheProvider();
cacheProvider.Put("key", new Boo { Num = 13 }, 5.Seconds());
var value = cacheProvider.Get<Boo>("key");
value.Num.Should().
Be(13);
}
public void should_absolutly_expired()
{
var cacheProvider = new MemoryCacheProvider();
cacheProvider.Put("key", new Boo { Num = 13 }, 5.Seconds());
Thread.Sleep(3000);
cacheProvider.Get<Boo>("key");
Thread.Sleep(3000);
Assert.Throws<InvalidOperationException>(() => cacheProvider.Get<Boo>("key"), "Объект должен быть удален из кеша.");
}