public void TestExpiration() { var cache = DefaultProvider.BuildCache("foo", null) as CoreDistributedCache; Assert.That(cache, Is.Not.Null, "pre-configured foo cache not found"); Assert.That(cache.Expiration, Is.EqualTo(TimeSpan.FromSeconds(500)), "Unexpected expiration value for foo region"); cache = (CoreDistributedCache)DefaultProvider.BuildCache("noExplicitExpiration", null); Assert.That(cache.Expiration, Is.EqualTo(TimeSpan.FromSeconds(300)), "Unexpected expiration value for noExplicitExpiration region"); Assert.That(cache.UseSlidingExpiration, Is.True, "Unexpected sliding value for noExplicitExpiration region"); cache = (CoreDistributedCache)DefaultProvider .BuildCache("noExplicitExpiration", new Dictionary <string, string> { { "expiration", "100" } }); Assert.That(cache.Expiration, Is.EqualTo(TimeSpan.FromSeconds(100)), "Unexpected expiration value for noExplicitExpiration region with default expiration"); cache = (CoreDistributedCache)DefaultProvider .BuildCache("noExplicitExpiration", new Dictionary <string, string> { { Cfg.Environment.CacheDefaultExpiration, "50" } }); Assert.That(cache.Expiration, Is.EqualTo(TimeSpan.FromSeconds(50)), "Unexpected expiration value for noExplicitExpiration region with cache.default_expiration"); }
protected CacheBase GetDefaultCache() { var cache = (CacheBase)DefaultProvider.BuildCache(DefaultRegion, GetDefaultProperties()); Assert.That(cache, Is.Not.Null, "No default cache returned"); return(cache); }
public void TestSlidingExpiration() { if (!SupportsSlidingExpiration) { Assert.Ignore("Provider does not support sliding expiration settings"); } const int expirySeconds = 3; const string key = "keyTestSlidingExpiration"; var obj = new SomeObject { Id = 2 }; var props = GetPropertiesForExpiration(Cfg.Environment.CacheDefaultExpiration, expirySeconds.ToString()); props["cache.use_sliding_expiration"] = "true"; var cache = DefaultProvider.BuildCache("TestObjectExpiration", props); cache.Put(key, obj); // Wait up to 1 sec before expiration Thread.Sleep(TimeSpan.FromSeconds(expirySeconds - 1)); Assert.That(cache.Get(key), Is.Not.Null, "Missing entry for key"); // Wait up to 1 sec before expiration again Thread.Sleep(TimeSpan.FromSeconds(expirySeconds - 1)); Assert.That(cache.Get(key), Is.Not.Null, "Missing entry for key after get and wait less than expiration"); // Wait expiration Thread.Sleep(TimeSpan.FromSeconds(expirySeconds + 1)); // Check it expired Assert.That(cache.Get(key), Is.Null, "Unexpected entry for key after expiration"); }
protected ICache GetCacheForExpiration(string cacheRegion, string expirationSetting, int expirySeconds) { var props = GetPropertiesForExpiration(expirationSetting, expirySeconds.ToString()); var cache = DefaultProvider.BuildCache(cacheRegion, props); return(cache); }
public void TestExpiration() { var cache = DefaultProvider.BuildCache("foo", null) as SysCacheRegion; Assert.That(cache, Is.Not.Null, "pre-configured foo cache not found"); Assert.That(RelativeExpirationField.GetValue(cache), Is.EqualTo(TimeSpan.FromSeconds(500)), "Unexpected expiration value for foo region"); // In the case of SysCache2, due to the SQL notification callbacks which may be set up for each configured region, // the build provider handles a global region cache and guarantees uniqueness of yielded cache region per region name // for the whole application. cache = DefaultProvider.BuildCache("noExplicitExpiration1", null) as SysCacheRegion; Assert.That(RelativeExpirationField.GetValue(cache), Is.EqualTo(TimeSpan.FromSeconds(300)), "Unexpected expiration value for noExplicitExpiration1 region"); Assert.That(UseSlidingExpirationField.GetValue(cache), Is.True, "Unexpected sliding value for noExplicitExpiration1 region"); cache = DefaultProvider .BuildCache("noExplicitExpiration2", new Dictionary <string, string> { { "expiration", "100" } }) as SysCacheRegion; Assert.That(RelativeExpirationField.GetValue(cache), Is.EqualTo(TimeSpan.FromSeconds(100)), "Unexpected expiration value for noExplicitExpiration2 region with default expiration"); cache = DefaultProvider .BuildCache("noExplicitExpiration3", new Dictionary <string, string> { { Cfg.Environment.CacheDefaultExpiration, "50" } }) as SysCacheRegion; Assert.That(RelativeExpirationField.GetValue(cache), Is.EqualTo(TimeSpan.FromSeconds(50)), "Unexpected expiration value for noExplicitExpiration3 region with cache.default_expiration"); }
public void TestExpiration() { var cache = DefaultProvider.BuildCache("foo", null) as RedisCache; Assert.That(cache, Is.Not.Null, "pre-configured foo cache not found"); var strategy = cache.RegionStrategy; Assert.That(strategy, Is.Not.Null, "strategy was not set for the pre-configured foo cache"); Assert.That(strategy, Is.TypeOf <DefaultRegionStrategy>(), "unexpected strategy type for foo region"); Assert.That(strategy.Expiration, Is.EqualTo(TimeSpan.FromSeconds(500)), "unexpected expiration value for foo region"); cache = (RedisCache)DefaultProvider.BuildCache("noExplicitExpiration", null); Assert.That(cache.RegionStrategy.Expiration, Is.EqualTo(TimeSpan.FromSeconds(300)), "unexpected expiration value for noExplicitExpiration region"); Assert.That(cache.RegionStrategy.UseSlidingExpiration, Is.True, "unexpected sliding value for noExplicitExpiration region"); cache = (RedisCache)DefaultProvider .BuildCache("noExplicitExpiration", new Dictionary <string, string> { { "expiration", "100" } }); Assert.That(cache.RegionStrategy.Expiration, Is.EqualTo(TimeSpan.FromSeconds(100)), "unexpected expiration value for noExplicitExpiration region with default expiration"); cache = (RedisCache)DefaultProvider .BuildCache("noExplicitExpiration", new Dictionary <string, string> { { Cfg.Environment.CacheDefaultExpiration, "50" } }); Assert.That(cache.RegionStrategy.Expiration, Is.EqualTo(TimeSpan.FromSeconds(50)), "unexpected expiration value for noExplicitExpiration region with cache.default_expiration"); }
public void TestNoExpiration() { var props = GetDefaultProperties(); props["expiration"] = "0"; Assert.Throws <CacheException>(() => DefaultProvider.BuildCache(DefaultRegion, props), "default region strategy should not allow to have no expiration"); }
public void TestPriorityOutOfRange() { var props = GetDefaultProperties(); props["priority"] = 7.ToString(); Assert.That(() => DefaultProvider.BuildCache("TestPriorityOutOfRange", props), Throws.TypeOf <IndexOutOfRangeException>()); }
private RedisCache GetDefaultRedisCache(Dictionary <string, string> properties = null) { var props = GetDefaultProperties(); foreach (var property in properties ?? new Dictionary <string, string>()) { props[property.Key] = property.Value; } return((RedisCache)DefaultProvider.BuildCache(DefaultRegion, props)); }
private RedisCache GetFastRedisCache(Dictionary <string, string> properties = null) { var props = GetDefaultProperties(); foreach (var property in properties ?? new Dictionary <string, string>()) { props[property.Key] = property.Value; } props["strategy"] = typeof(FastRegionStrategy).AssemblyQualifiedName; return((RedisCache)DefaultProvider.BuildCache(DefaultRegion, props)); }
public void TestBadRelativeExpiration([ValueSource(nameof(ExpirationSettingNames))] string expirationSetting) { if (!SupportsDefaultExpiration) { Assert.Ignore("Provider does not support default expiration settings"); } var props = GetPropertiesForExpiration(expirationSetting, "foobar"); Assert.That( () => DefaultProvider.BuildCache("TestBadRelativeExpiration", props), Throws.ArgumentException.Or.TypeOf <FormatException>(), expirationSetting); }
public void TestMaxAllowedVersion() { var cache = (RedisCache)GetDefaultCache(); var strategy = (DefaultRegionStrategy)cache.RegionStrategy; var version = strategy.CurrentVersion; var props = GetDefaultProperties(); props.Add("cache.region_strategy.default.max_allowed_version", version.ToString()); cache = (RedisCache)DefaultProvider.BuildCache(DefaultRegion, props); strategy = (DefaultRegionStrategy)cache.RegionStrategy; cache.Clear(); Assert.That(strategy.CurrentVersion, Is.EqualTo(1L), "the version was not reset to 1"); }
public async Task TestRegionsAsync() { const string key = "keyTestRegions"; var props = GetDefaultProperties(); var cache1 = DefaultProvider.BuildCache("TestRegions1", props); var cache2 = DefaultProvider.BuildCache("TestRegions2", props); const string s1 = "test1"; const string s2 = "test2"; await(cache1.PutAsync(key, s1, CancellationToken.None)); await(cache2.PutAsync(key, s2, CancellationToken.None)); var get1 = await(cache1.GetAsync(key, CancellationToken.None)); var get2 = await(cache2.GetAsync(key, CancellationToken.None)); Assert.That(get1, Is.EqualTo(s1), "Unexpected value in cache1"); Assert.That(get2, Is.EqualTo(s2), "Unexpected value in cache2"); }
public void TestRegions() { const string key = "keyTestRegions"; var props = GetDefaultProperties(); var cache1 = DefaultProvider.BuildCache("TestRegions1", props); var cache2 = DefaultProvider.BuildCache("TestRegions2", props); const string s1 = "test1"; const string s2 = "test2"; cache1.Put(key, s1); cache2.Put(key, s2); var get1 = cache1.Get(key); var get2 = cache2.Get(key); Assert.That(get1, Is.EqualTo(s1), "Unexpected value in cache1"); Assert.That(get2, Is.EqualTo(s2), "Unexpected value in cache2"); }
public void TestAppendHashcodeToKey() { Assert.That(CoreDistributedCacheProvider.AppendHashcodeToKey, Is.True, "Default is not true"); var cache = DefaultProvider.BuildCache("foo", null) as CoreDistributedCache; Assert.That(cache.AppendHashcodeToKey, Is.True, "First built cache not correctly set"); CoreDistributedCacheProvider.AppendHashcodeToKey = false; try { cache = DefaultProvider.BuildCache("foo", null) as CoreDistributedCache; Assert.That(cache.AppendHashcodeToKey, Is.False, "Second built cache not correctly set"); } finally { CoreDistributedCacheProvider.AppendHashcodeToKey = true; } }
public void TestRemove144() { string key = "keyTestRemove144"; string value = "value"; //memcached 1.4+ drops support for expiration time specified for Delete operations //therefore if you install memcached 1.4.4 this test will fail unless corresponding fix is implemented in MemCacheClient.cs //the test will fail because Remove won't actually delete the item from the cache! //the error you will see in the log is: "Error deleting key: nunit@key1. Server response: CLIENT_ERROR bad command line format. Usage: delete <key> [noreply]" //Now, Memcached.ClientLibrary incorrectly divides expiration time for Delete operation by 1000 //(for Add and Set operations the expiration time is calculated correctly) //that's why we need to set expiration to 20000, otherwise it will be treated as 20ms which is too small to be sent to server (the minimum value is 1 second) var props = GetDefaultProperties(); props["expiration"] = "20000"; //disabling lingering delete will cause the item to get immediately deleted //this parameter is NEW and the code to make it work is part of the proposed fix props.Add("lingering_delete_disabled", "true"); var cache = DefaultProvider.BuildCache("TestRemove144", props); Assert.That(cache, Is.Not.Null, "no cache returned"); // add the item cache.Put(key, value); Thread.Sleep(1000); // make sure it's there var item = cache.Get(key); Assert.That(item, Is.Not.Null, "item just added is not there"); // remove it cache.Remove(key); // make sure it's not there item = cache.Get(key); Assert.That(item, Is.Null, "item still exists in cache"); }
public void TestClearWithMultipleClientsAndNoPubSub() { const string key = "keyTestClear"; const string value = "valueClear"; var props = GetDefaultProperties(); props.Add("cache.region_strategy.default.use_pubsub", "false"); var cache = (RedisCache)DefaultProvider.BuildCache(DefaultRegion, props); var strategy = (DefaultRegionStrategy)cache.RegionStrategy; var cache2 = (RedisCache)DefaultProvider.BuildCache(DefaultRegion, props); var strategy2 = (DefaultRegionStrategy)cache2.RegionStrategy; // add the item cache.Put(key, value); // make sure it's there var item = cache.Get(key); Assert.That(item, Is.Not.Null, "couldn't find item in cache"); item = cache2.Get(key); Assert.That(item, Is.Not.Null, "couldn't find item in second cache"); var version = strategy.CurrentVersion; // clear the cache cache.Clear(); Assert.That(strategy.CurrentVersion, Is.EqualTo(version + 1), "the version has not been updated"); Thread.Sleep(TimeSpan.FromSeconds(2)); Assert.That(strategy2.CurrentVersion, Is.EqualTo(version), "the version should not be updated"); // make sure we don't get an item item = cache.Get(key); Assert.That(item, Is.Null, "item still exists in cache after clear"); item = cache2.Get(key); Assert.That(item, Is.Null, "item still exists in the second cache after clear"); }
public virtual void TestEmptyProperties() { var cache = DefaultProvider.BuildCache("TestEmptyProperties", new Dictionary <string, string>()); Assert.That(cache, Is.Not.Null); }
public void TestBuildCacheNoRegionNoProperties() { var cache = DefaultProvider.BuildCache(null, null); Assert.That(cache, Is.Not.Null, "no cache returned"); }
public void TestBuildCacheRegionWithProperties() { var cache = DefaultProvider.BuildCache("TestBuildCacheWithProperties", GetDefaultProperties()); Assert.That(cache, Is.Not.Null, "no cache returned"); }
public void TestBuildCacheFromConfig() { var cache = DefaultProvider.BuildCache("foo", null); Assert.That(cache, Is.Not.Null, "pre-configured cache not found"); }