Example #1
0
        private static ConcurrentDictionary <string, object> GetDefaultCacheValues()
        {
            var expiredSingleValue = new InMemoryCacheItem
            {
                Data       = JsonConvert.SerializeObject("testValue"),
                ExpiryDate = DateTime.Now.AddSeconds(-60),
            };

            var simpleObjectCacheItem = new InMemoryCacheItem
            {
                Data = JsonConvert.SerializeObject(new SampleConfiguration
                {
                    DataField1 = "value1",
                    DataField2 = "value2",
                    DataField3 = "value3",
                }),
                ExpiryDate = DateTime.Now.AddSeconds(60),
            };

            var result = new ConcurrentDictionary <string, object>();

            result.TryAdd(SingleValueKey, expiredSingleValue);
            result.TryAdd(SimpleObjectKey, simpleObjectCacheItem);

            return(result);
        }
Example #2
0
        public void SetupTest()
        {
            var helper = _container.Resolve <IDemoHelper>();
            var list   = helper.GenerateDemoObjects(1000);
            var key    = Guid.NewGuid().ToString();
            var item   = new InMemoryCacheItem(list, TimeSpan.FromMinutes(15));

            _observer.OnBeforeGet(key, TimeSpan.FromSeconds(3));
            _observer.OnAfterGet(key);
            _observer.OnAfterDelete(key);
            _observer.OnBeforeSet(key, item);
            _observer.OnAfterSet(key);
            _observer.OnBeforeDelete(key);
            _observer.OnRemoteSet(key, TestConstants.CacheObserverName);
            _observer.OnRemoteDelete(key, TestConstants.CacheObserverName);
        }
        public void SetConfig(string key, object value)
        {
            var expiryDatetime = DateTime.UtcNow;

            if (TimeSpan.TryParse(this.settings.InMemoryCacheTimeToLiveTimeSpan, out var parsedTimespan))
            {
                expiryDatetime = expiryDatetime.Add(parsedTimespan);
            }

            var cacheItem = new InMemoryCacheItem
            {
                Data       = JsonConvert.SerializeObject(value),
                ExpiryDate = expiryDatetime,
            };

            this.cache.TryAdd(key, cacheItem);
        }
        public void When_set_som_objects_it_should_call_CacheManager_and_when_get_it_back_it_should_be_same_instance()
        {
            var list = _demoHelper.GenerateDemoObjects(1000);

            _cache.Set(DemoObjectListKey, list, CacheTime.FifteenMinutes);
            Thread.Sleep(500);
            var item = new InMemoryCacheItem(list, CacheTime.FifteenMinutes);

            Assert.AreEqual(item, _onBeforeSetItem);
            Assert.AreEqual(DemoObjectListKey, _onBeforeSetKey);
            Assert.AreEqual(DemoObjectListKey, _onAfterSetKey);
            //_mockCacheManager.Received().OnBeforeSet(Arg.Is(DemoObjectListKey), Arg.Any<InMemoryCacheItem>());
            //_mockCacheManager.Received().OnAfterSet(Arg.Is(DemoObjectListKey));
            var cachedList = _cache.Get <List <DemoObject> >(DemoObjectListKey, TimeSpan.FromSeconds(3));

            Thread.Sleep(500);
            Assert.AreEqual(DemoObjectListKey, _onBeforeGetKey);
            Assert.AreEqual(DemoObjectListKey, _onAfterGetKey);
            Assert.AreEqual(TimeSpan.FromSeconds(3), _onBeforeGetTimeout);
            Assert.NotNull(cachedList);
            Assert.AreSame(list, cachedList);
        }
 private void _cache_OnBeforeSet(string key, InMemoryCacheItem item)
 {
     _onBeforeSetKey  = key;
     _onBeforeSetItem = item;
 }