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());
}
