private static void MultiThreadWithConcurency_InvokesGetValueFunctionOnce_Test(int maxThreads, bool sta)
{
// arrange
var cache = new CacheProviderStub();
var cache_key = Guid.NewGuid().ToString();
var exec_count = 0;
var start_event = new ManualResetEvent(false);
var results = new string[maxThreads];
var threads = Enumerable.Range(0, maxThreads).Select
(x =>
{
var thread = new Thread
(() =>
{
start_event.WaitOne();
results[x] = cache.GetAsync
(cache_key,
() => Task.Run
(async() =>
{
await Task.Delay(TimeSpan.FromMilliseconds(100)).ConfigureAwait(false);
Interlocked.Increment(ref exec_count);
return(new CachableResult <string>("aaa", CachingParameters.FromMinutes(1)));
})).Result;
});
thread.IsBackground = true;
if (sta)
{
thread.SetApartmentState(ApartmentState.STA);
}
return(thread);
})
.ToList();
// act
threads.ForEach(t => t.Start());
start_event.Set();
threads.ForEach(t => t.Join());
// assert
cache.Values
.Should().HaveCount(1)
.And.ContainKey(cache_key)
.WhichValue.Value.Should().Be("aaa");
results.Should().OnlyContain(x => x == "aaa");
exec_count.Should().Be(1);
GetWithLockExtensions.Locks.Should().BeEmpty();
}
public void ResultDataIsNull_CachesIt()
{
// arrange
var cache = new CacheProviderStub();
var cache_key = Guid.NewGuid().ToString();
var exec_count = 0;
var create_result = new Func <CachableResult <string> >
(() =>
{
exec_count++;
return(new CachableResult <string> (null, CachingParameters.FromMinutes(1)));
});
// act
var result = cache.Get(cache_key, create_result);
var result2 = cache.Get(cache_key, create_result);
// assert
cache.Values.Should().HaveCount(1);
result.Should().BeNull();
result2.Should().BeNull();
exec_count.Should().Be(1);
GetWithLockExtensions.Locks.Should().BeEmpty();
}
public void SingleThread_InvokesGetValueFunctionOnce()
{
// arrange
var cache = new CacheProviderStub();
var cache_key = Guid.NewGuid().ToString();
var exec_count = 0;
// act
var actual = cache.Get
(cache_key,
() =>
{
exec_count++;
return(new CachableResult <string> ("aaa", CachingParameters.FromMinutes(1)));
});
// assert
actual.Should().Be("aaa");
cache.Values
.Should().HaveCount(1)
.And.ContainKey(cache_key)
.WhichValue.Value.Should().Be("aaa");
exec_count.Should().Be(1);
GetWithLockExtensions.Locks.Should().BeEmpty();
}
public Task <IReadOnlyList <Order> > GetAllAsync()
{
return(_cacheProvider.GetAsync(nameof(OrdersSnapshotReaderService),
async() => new CachableResult <IReadOnlyList <Order> >(
(IReadOnlyList <Order>) await _blobRepository.ReadAsync <List <Order> >(
LykkeConstants.StateBlobContainer, BlobName) ?? Array.Empty <Order>(),
CachingParameters.FromSeconds(10))));
}
private static async Task MultiTaskWithConcurency_InvokesGetValueFunctionOnce_Test(int maxTasks)
{
// arrange
var cache = new CacheProviderStub();
var cache_key = Guid.NewGuid().ToString();
var exec_count = 0;
var start_event = new SemaphoreSlim(0, maxTasks);
var results = new string[maxTasks];
var task_factory = Task.Factory;
var tasks = Enumerable.Range(0, maxTasks).Select
(x => task_factory.StartNew
(async() =>
{
await start_event.WaitAsync();
await Task.Delay(TimeSpan.FromMilliseconds(100));
Interlocked.Increment(ref exec_count);
var result = cache.Get
(cache_key,
() =>
{
Task.Delay(100).Wait();
return(new CachableResult <string> ("aaa", CachingParameters.FromMinutes(10)));
});
return(result);
}
).Unwrap()).ToList();
// act
start_event.Release(maxTasks);
await Task.WhenAll(tasks);
// assert
cache.Values
.Should().HaveCount(1)
.And.ContainKey(cache_key)
.WhichValue.Value.Should().Be("aaa");
results.Should().OnlyContain(x => x == "aaa");
exec_count.Should().Be(1);
GetWithLockExtensions.Locks.Should().BeEmpty();
}
private Task <Dictionary <string, OrderBook> > GetOrderBookStateAsync()
{
return(_cacheProvider.GetAsync(nameof(OrderBookSnapshotReaderService),
async() =>
{
var orderbookState = await _blobRepository.ReadAsync <Dictionary <string, OrderBook> >(
LykkeConstants.StateBlobContainer, BlobName) ??
new Dictionary <string, OrderBook>();
return new CachableResult <Dictionary <string, OrderBook> >(orderbookState,
CachingParameters.FromSeconds(10));
}));
}
public void Clone_ReturnsDeepClone()
{
// arrange
var source = new CachingParameters(TimeSpan.FromDays(123), true, CachePriority.High);
// act
var result = source.Clone();
// assert
result.ShouldBeEquivalentTo(source);
}
public void Add(string key, object value, CachingParameters parameters)
{
if (value == null)
{
this.Remove(key);
return;
}
this.Values[key] = new CacheItem
{
Value = value,
Parameters = parameters
};
}
public void Add_Null_WasNotPresentBefore_DoesNotAddsIt()
{
// arrange
var cache = this.CreateSut();
var key = "key";
var parameters = new CachingParameters(TimeSpan.FromDays(1));
// act
cache.Clear();
cache.Add(key, null, parameters);
var result = cache.Get(key);
// assert
result.Should().BeNull();
}
public void Add_Item_WasNotPresentBefore_AddsIt()
{
// arrange
var cache = this.CreateSut();
var key = "key";
var item = "item";
var parameters = new CachingParameters(TimeSpan.FromDays(1));
// act
cache.Clear();
cache.Add(key, item, parameters);
var result = cache.Get(key);
// assert
result.Should().Be(item);
}
public void Remove_Exists_RemovesIt()
{
// arrange
var cache = this.CreateSut();
var key = "key";
var item = "item";
var parameters = new CachingParameters(TimeSpan.FromDays(1));
// act
cache.Clear();
cache.Add(key, item, parameters);
cache.Remove(key);
var result = cache.Get(key);
// assert
result.Should().BeNull();
}
public void Add_SlidingExpiration_ReturnsNullAfterTimePassed()
{
// arrange
var cache = this.CreateSut();
var key = "key";
var item = "item";
var parameters = new CachingParameters(TimeSpan.FromMilliseconds(100), sliding: true);
// act
cache.Clear();
cache.Add(key, item, parameters);
Thread.Sleep(TimeSpan.FromMilliseconds(200));
var result = cache.Get(key);
// assert
result.Should().BeNull();
}
public async Task NestedCalls_ReturnsItem()
{
// arrange
var cache = new CacheProviderStub();
var cache_key = Guid.NewGuid().ToString();
var exec_count_a = 0;
var exec_count_b = 0;
// act
var result = await cache.GetAsync
(cache_key,
() => Task.Run
(async() =>
{
exec_count_a++;
var res = await cache.GetAsync
("NestedCalls_ReturnsItem",
() => Task.Run(() =>
{
exec_count_b++;
return(new CachableResult <string>
("bbb",
CachingParameters.FromDays(1)));
}));
return(new CachableResult <string>(res, CachingParameters.FromDays(1)));
}));
// assert
result.Should().Be("bbb");
cache.Values.Should().HaveCount(2);
exec_count_a.Should().Be(1);
exec_count_b.Should().Be(1);
GetWithLockExtensions.Locks.Should().BeEmpty();
}
/// <summary>
/// Adds or updates object in the cache.
/// </summary>
/// <param name="key">Object key. Can not be null.</param>
/// <param name="value">Object value.</param>
/// <param name="parameters">Caching parameters. Can not be null.</param>
public void Add(string key, object value, CachingParameters parameters)
{
}
