Exemple #1
0
        public void CacheKey_get_success()
        {
            var lookup = new CacheLookup <CacheItem>()
                         .Add(x => x.LookupKey);

            var key = lookup.CacheKey;

            Assert.That(key, Is.EqualTo("Lookup_CacheItem_LookupKey"));
        }
Exemple #2
0
        public void GetLookupKey_sucess()
        {
            var lookup = new CacheLookup <CacheItem>()
                         .Add(x => x.LookupKey)
                         .Add(x => x.LookupKeyOther);

            var key = lookup.GetLookupKey(new CacheItem {
                LookupKey = 1, LookupKeyOther = "other"
            });

            Assert.That(key, Is.EqualTo("1_other"));
        }
Exemple #3
0
        public async Task FetchAsync_lookup_test()
        {
            var root          = Substitute.For <ISite>();
            var cacheRegistry = new CacheRegistry(new TestCacheConfig());
            var cacheStore    = new CacheStore();
            var lookup        = new CacheLookup <CacheItem>().Add(x => x.LookupKey);
            var lookupOther   = new CacheLookup <CacheItem>().Add(x => x.LookupKeyOther);
            var cache         = new Cache(cacheStore, cacheRegistry, root);

            async Task <IEnumerable <CacheItem> > Task(ICache c) => await System.Threading.Tasks.Task.Run(() => new[]
            {
                new CacheItem {
                    LookupKey = 1, LookupKeyOther = "2"
                },
                new CacheItem {
                    LookupKey = 1, LookupKeyOther = "2"
                },
                new CacheItem {
                    LookupKey = 2, LookupKeyOther = "1"
                }
            }).ConfigureAwait(false);

            cacheRegistry.Add(Task).Lookup(lookup).Lookup(lookupOther).Span(300);

            var result = await cache.FetchAsync(lookup).ConfigureAwait(false);

            var resultOther = await cache.FetchAsync(lookupOther).ConfigureAwait(false);

            var item      = result["2"].First();
            var itemOther = resultOther["1"].First();

            Assert.That(result, Is.Not.Null);
            Assert.That(result.Count, Is.EqualTo(2));
            Assert.That(result["1"].Count(), Is.EqualTo(2));
            Assert.That(result["2"].Count(), Is.EqualTo(1));

            Assert.That(resultOther, Is.Not.Null);
            Assert.That(resultOther.Count, Is.EqualTo(2));
            Assert.That(resultOther["1"].Count(), Is.EqualTo(1));
            Assert.That(resultOther["2"].Count(), Is.EqualTo(2));

            Assert.That(item.Id, Is.EqualTo(itemOther.Id));
        }
Exemple #4
0
        public async Task Run_with_lookups_concurrent_run_single_result_success()
        {
            const int cacheTime = 300;
            var       cache     = Substitute.For <ICache>();
            var       items     = new Dictionary <string, object>();
            var       taskKey   = typeof(CacheItem).FullName;
            var       lookup    = new CacheLookup <CacheItem>().Add(x => x.LookupKey);

            var task = new CacheTask <CacheItem>(_task, taskKey).Span(cacheTime);

            task.Lookup(lookup);

            void Save(string key, object value)
            {
                items[key] = value;
            }

            await task.Run(cache, Save).ConfigureAwait(false);

            var lookups = items["Lookup_CacheItem_LookupKey"] as ILookup <string, CacheItem>;
            var all     = items[taskKey] as IEnumerable <CacheItem>;

            Assert.That(items.Count, Is.EqualTo(2));
            Assert.That(all.Count(), Is.EqualTo(3));
            Assert.That(lookups.Count(), Is.EqualTo(2));

            var lookupKey1 = lookup.GetLookupKey(new CacheItem {
                LookupKey = 1
            });
            var lookupKey2 = lookup.GetLookupKey(new CacheItem {
                LookupKey = 2
            });

            Assert.That(lookups[lookupKey1].Count(), Is.EqualTo(2));
            Assert.That(lookups[lookupKey2].Count(), Is.EqualTo(1));
        }
        public override int GetHashCode()
        {
            int hash = 1;

            if (RequestMethod.Length != 0)
            {
                hash ^= RequestMethod.GetHashCode();
            }
            if (RequestUrl.Length != 0)
            {
                hash ^= RequestUrl.GetHashCode();
            }
            if (RequestSize != 0L)
            {
                hash ^= RequestSize.GetHashCode();
            }
            if (Status != 0)
            {
                hash ^= Status.GetHashCode();
            }
            if (ResponseSize != 0L)
            {
                hash ^= ResponseSize.GetHashCode();
            }
            if (UserAgent.Length != 0)
            {
                hash ^= UserAgent.GetHashCode();
            }
            if (RemoteIp.Length != 0)
            {
                hash ^= RemoteIp.GetHashCode();
            }
            if (ServerIp.Length != 0)
            {
                hash ^= ServerIp.GetHashCode();
            }
            if (Referer.Length != 0)
            {
                hash ^= Referer.GetHashCode();
            }
            if (latency_ != null)
            {
                hash ^= Latency.GetHashCode();
            }
            if (CacheLookup != false)
            {
                hash ^= CacheLookup.GetHashCode();
            }
            if (CacheHit != false)
            {
                hash ^= CacheHit.GetHashCode();
            }
            if (CacheValidatedWithOriginServer != false)
            {
                hash ^= CacheValidatedWithOriginServer.GetHashCode();
            }
            if (CacheFillBytes != 0L)
            {
                hash ^= CacheFillBytes.GetHashCode();
            }
            return(hash);
        }