public void CacheManagerTests_GetThroughTestables_Gets() { var memoryCache = new TestMemoryCache(); var cache = new CacheManager(memoryCache); Assert.Equal("A", cache.Get("hi").ToString()); Assert.Null(cache.Get("not hi")); }
public void MissingKey() { var cache = new TestMemoryCache(); var key = GetKey(); cache.TryGetValue(key, out var value); Assert.Null(value); }
public void NullKey() { var cache = new TestMemoryCache(); Assert.Throws <ArgumentNullException>(() => { cache.TryGetValue(key: null, out var result); }); }
public void NullKey() { var cache = new TestMemoryCache(); Assert.Throws <ArgumentNullException>(() => { var value = cache.Get(key: null); }); }
public void MissingKey() { var cache = new TestMemoryCache(); var key = GetKey(); var value = cache.Get(key); Assert.Null(value); }
public When_saving_fails() { _testRep = new TestRepository(); _cache = new TestMemoryCache(); _rep = new CacheRepository(_testRep, new TestInMemoryEventStore(), _cache); _aggregate = _testRep.Get <TestAggregate>(Guid.NewGuid()); _aggregate.DoSomething(); try { _rep.Save(_aggregate, 100); } catch (Exception) {} }
public When_saving_same_aggregate_in_parallel() { _cache = new TestMemoryCache(); // This will clear the cache between runs. //var cacheKeys = _cache. (.Select(kvp => kvp.Key).ToList(); //foreach (var cacheKey in cacheKeys) // MemoryCache.Default.Remove(cacheKey); _testStore = new TestInMemoryEventStore(); _rep1 = new CacheRepository(new Repository(_testStore), _testStore, _cache); _rep2 = new CacheRepository(new Repository(_testStore), _testStore, _cache); _aggregate = new TestAggregate(Guid.NewGuid()); _rep1.Save(_aggregate); var t1 = new Task(() => { for (var i = 0; i < 100; i++) { var aggregate = _rep1.Get <TestAggregate>(_aggregate.Id); aggregate.DoSomething(); _rep1.Save(aggregate); } }); var t2 = new Task(() => { for (var i = 0; i < 100; i++) { var aggregate = _rep2.Get <TestAggregate>(_aggregate.Id); aggregate.DoSomething(); _rep2.Save(aggregate); } }); var t3 = new Task(() => { for (var i = 0; i < 100; i++) { var aggregate = _rep2.Get <TestAggregate>(_aggregate.Id); aggregate.DoSomething(); _rep2.Save(aggregate); } }); t1.Start(); t2.Start(); t3.Start(); Task.WaitAll(t1, t2, t3); }
public void BasicAdd() { var cache = new TestMemoryCache(); var key = GetKey(); var value = new List <uint> { 1, 2, 3 }; cache.Set(key, value); cache.TryGetValue(key, out var result); Assert.Same(value, result); }
public void LastAccessIsUpdated() { var cache = new TestMemoryCache(); var key = GetKey(); var value = new List <uint>(); cache.Set(key, value); var oldAccessTime = cache.GetAccessTime(key); Thread.Sleep(millisecondsTimeout: 10); cache.TryGetValue(key, out _); var newAccessTime = cache.GetAccessTime(key); Assert.True(newAccessTime > oldAccessTime, "New AccessTime should be greater than old"); }
public async Task ProcessAsync_AwaitersUseTheResultOfExecutor() { // Arrange var expected = "Hello world"; var cache = new TestMemoryCache(); var encoder = new HtmlTestEncoder(); // The two instances represent two instances of the same cache tag helper appearance in the page. var cacheTagHelper1 = new CacheTagHelper(new CacheTagHelperMemoryCacheFactory(cache), encoder) { ViewContext = GetViewContext(), Enabled = true }; var cacheTagHelper2 = new CacheTagHelper(new CacheTagHelperMemoryCacheFactory(cache), encoder) { ViewContext = GetViewContext(), Enabled = true }; var invokeCount = 0; Func <bool, HtmlEncoder, Task <TagHelperContent> > getChildContentAsync = (useCachedResult, _) => { invokeCount++; var content = new DefaultTagHelperContent(); content.SetContent(expected); return(Task.FromResult <TagHelperContent>(content)); }; var tagHelperOutput1 = new TagHelperOutput("cache", new TagHelperAttributeList(), getChildContentAsync); var tagHelperOutput2 = new TagHelperOutput("cache", new TagHelperAttributeList(), getChildContentAsync); // Act var task1 = Task.Run(() => cacheTagHelper1.ProcessAsync(GetTagHelperContext(cache.Key1), tagHelperOutput1)); var task2 = Task.Run(() => cacheTagHelper2.ProcessAsync(GetTagHelperContext(cache.Key2), tagHelperOutput2)); // Assert await Task.WhenAll(task1, task2); Assert.Equal(1, invokeCount); // We expect getChildContentAsync to be invoked exactly once. Assert.Equal(encoder.Encode(expected), tagHelperOutput1.Content.GetContent()); Assert.Equal(encoder.Encode(expected), tagHelperOutput2.Content.GetContent()); }
public async Task ConcurrentSets_DoesNotThrow() { // Arrange var cache = new TestMemoryCache(); var entries = Enumerable.Range(0, 500); var repeatCount = 4; // 1111 2222 3333 4444 ... var repeatedEntries = entries.SelectMany(entry => Enumerable.Repeat(entry, repeatCount)); var tasks = repeatedEntries.Select(async entry => { // 2 is an arbitrarily low number, we're just trying to emulate concurrency await Task.Delay(2); cache.Set(entry.ToString(CultureInfo.InvariantCulture), Array.Empty <uint>()); }); // Act & Assert await Task.WhenAll(tasks); }
public void Compaction() { var cache = new TestMemoryCache(); var sizeLimit = TestMemoryCache.SizeLimit; for (var i = 0; i < sizeLimit; i++) { var key = GetKey(); var value = new List <uint> { (uint)i }; cache.Set(key, value); Assert.False(cache.WasCompacted, "It got compacted early."); } cache.Set(GetKey(), new List <uint> { (uint)sizeLimit + 1 }); Assert.True(cache.WasCompacted, "Compaction is not happening"); }
public async Task ProcessAsync_ThrowsExceptionForAwaiters_IfExecutorEncountersAnException() { // Arrange var expected = new DivideByZeroException(); var cache = new TestMemoryCache(); // The two instances represent two instances of the same cache tag helper appearance in the page. var cacheTagHelper1 = new CacheTagHelper(new CacheTagHelperMemoryCacheFactory(cache), new HtmlTestEncoder()) { ViewContext = GetViewContext(), Enabled = true }; var cacheTagHelper2 = new CacheTagHelper(new CacheTagHelperMemoryCacheFactory(cache), new HtmlTestEncoder()) { ViewContext = GetViewContext(), Enabled = true }; var invokeCount = 0; var tagHelperOutput = new TagHelperOutput( "cache", new TagHelperAttributeList(), getChildContentAsync: (useCachedResult, _) => { invokeCount++; throw expected; }); // Act var task1 = Task.Run(() => cacheTagHelper1.ProcessAsync(GetTagHelperContext(cache.Key1), tagHelperOutput)); var task2 = Task.Run(() => cacheTagHelper2.ProcessAsync(GetTagHelperContext(cache.Key2), tagHelperOutput)); // Assert await Assert.ThrowsAsync <DivideByZeroException>(() => task1); await Assert.ThrowsAsync <DivideByZeroException>(() => task2); Assert.Equal(1, invokeCount); }
public When_getting_earlier_than_expected_events_from_event_store() { _cache = new TestMemoryCache(); _rep = new CacheRepository(new TestRepository(), new TestEventStoreWithBugs(), _cache); _aggregate = _rep.Get <TestAggregate>(Guid.NewGuid()); }