public async Task FunctionalTest_RoutingMiddleware_ThrowsDeprecateCacheIsExpiredOrMissingException_NoCache()
{
HttpContext ctx = new DefaultHttpContext();
ctx.Request.Host = new HostString("test.qp.lan");
RoutingMiddleware routingMiddleware = new RoutingMiddleware(_next, new NullTargetingFilterAccessor());
StubCacheProvider stubCacheProvider = new StubCacheProvider();
CacheStubAbstractItemStorageProvider cacheStubAbstractItemStorageProvider = new CacheStubAbstractItemStorageProvider(stubCacheProvider);
await Assert.ThrowsExceptionAsync <DeprecateCacheIsExpiredOrMissingException>(() => routingMiddleware.Invoke(ctx, cacheStubAbstractItemStorageProvider));
}
public void Should_execute_delegate_but_not_put_value_in_cache_if_cache_does_not_hold_value_but_ttl_indicates_not_worth_caching()
{
const string valueToReturn = "valueToReturn";
const string executionKey = "SomeExecutionKey";
ISyncCacheProvider stubCacheProvider = new StubCacheProvider();
CachePolicy cache = Policy.Cache(stubCacheProvider, TimeSpan.Zero);
stubCacheProvider.Get(executionKey).Should().BeNull();
cache.Execute(() => { return(valueToReturn); }, new Context(executionKey)).Should().Be(valueToReturn);
stubCacheProvider.Get(executionKey).Should().Be(null);
}
public async Task Should_execute_delegate_and_put_value_in_cache_if_cache_does_not_hold_value()
{
const string valueToReturn = "valueToReturn";
const string executionKey = "SomeExecutionKey";
IAsyncCacheProvider stubCacheProvider = new StubCacheProvider();
CachePolicy cache = Policy.CacheAsync(stubCacheProvider, TimeSpan.MaxValue);
((string)await stubCacheProvider.GetAsync(executionKey, CancellationToken.None, false).ConfigureAwait(false)).Should().BeNull();
(await cache.ExecuteAsync(async() => { await TaskHelper.EmptyTask.ConfigureAwait(false); return(valueToReturn); }, new Context(executionKey)).ConfigureAwait(false)).Should().Be(valueToReturn);
((string)await stubCacheProvider.GetAsync(executionKey, CancellationToken.None, false).ConfigureAwait(false)).Should().Be(valueToReturn);
}
public async Task Should_execute_delegate_but_not_put_value_in_cache_if_cache_does_not_hold_value_but_ttl_indicates_not_worth_caching()
{
const string valueToReturn = "valueToReturn";
const string operationKey = "SomeOperationKey";
IAsyncCacheProvider stubCacheProvider = new StubCacheProvider();
CachePolicy cache = Policy.CacheAsync(stubCacheProvider, TimeSpan.Zero);
((string)await stubCacheProvider.GetAsync(operationKey, CancellationToken.None, false).ConfigureAwait(false)).Should().Be(null);
(await cache.ExecuteAsync(async ctx => { await TaskHelper.EmptyTask.ConfigureAwait(false); return(valueToReturn); }, new Context(operationKey)).ConfigureAwait(false)).Should().Be(valueToReturn);
((string)await stubCacheProvider.GetAsync(operationKey, CancellationToken.None, false).ConfigureAwait(false)).Should().Be(null);
}
public void Should_execute_delegate_and_put_value_in_cache_if_cache_does_not_hold_value()
{
const string valueToReturn = "valueToReturn";
const string executionKey = "SomeExecutionKey";
ISyncCacheProvider stubCacheProvider = new StubCacheProvider();
CachePolicy <string> cache = Policy.Cache <string>(stubCacheProvider, TimeSpan.MaxValue);
stubCacheProvider.Get(executionKey).Should().BeNull();
cache.Execute(() => { return(valueToReturn); }, new Context(executionKey)).Should().Be(valueToReturn);
stubCacheProvider.Get(executionKey).Should().Be(valueToReturn);
}
public void Should_execute_delegate_and_put_value_in_cache_for_non_nullable_types_if_cache_does_not_hold_value()
{
const ResultPrimitive valueToReturn = ResultPrimitive.Substitute;
const string operationKey = "SomeOperationKey";
ISyncCacheProvider stubCacheProvider = new StubCacheProvider();
CachePolicy cache = Policy.Cache(stubCacheProvider, TimeSpan.MaxValue);
stubCacheProvider.Get(operationKey).Should().BeNull();
cache.Execute(ctx => { return(valueToReturn); }, new Context(operationKey)).Should().Be(valueToReturn);
stubCacheProvider.Get(operationKey).Should().Be(valueToReturn);
}
public async Task Should_execute_delegate_and_put_value_in_cache_but_when_it_expires_execute_delegate_again()
{
const string valueToReturn = "valueToReturn";
const string operationKey = "SomeOperationKey";
IAsyncCacheProvider stubCacheProvider = new StubCacheProvider();
TimeSpan ttl = TimeSpan.FromMinutes(30);
var cache = Policy.CacheAsync <string>(stubCacheProvider, ttl);
(bool cacheHit1, object fromCache1) = await stubCacheProvider.TryGetAsync(operationKey, CancellationToken.None, false).ConfigureAwait(false);
cacheHit1.Should().BeFalse();
fromCache1.Should().BeNull();
int delegateInvocations = 0;
Func <Context, Task <string> > func = async ctx =>
{
delegateInvocations++;
await TaskHelper.EmptyTask.ConfigureAwait(false);
return(valueToReturn);
};
DateTimeOffset fixedTime = SystemClock.DateTimeOffsetUtcNow();
SystemClock.DateTimeOffsetUtcNow = () => fixedTime;
// First execution should execute delegate and put result in the cache.
(await cache.ExecuteAsync(func, new Context(operationKey)).ConfigureAwait(false)).Should().Be(valueToReturn);
delegateInvocations.Should().Be(1);
(bool cacheHit2, object fromCache2) = await stubCacheProvider.TryGetAsync(operationKey, CancellationToken.None, false).ConfigureAwait(false);
cacheHit2.Should().BeTrue();
fromCache2.Should().Be(valueToReturn);
// Second execution (before cache expires) should get it from the cache - no further delegate execution.
// (Manipulate time so just prior cache expiry).
SystemClock.DateTimeOffsetUtcNow = () => fixedTime.Add(ttl).AddSeconds(-1);
(await cache.ExecuteAsync(func, new Context(operationKey)).ConfigureAwait(false)).Should().Be(valueToReturn);
delegateInvocations.Should().Be(1);
// Manipulate time to force cache expiry.
SystemClock.DateTimeOffsetUtcNow = () => fixedTime.Add(ttl).AddSeconds(1);
// Third execution (cache expired) should not get it from the cache - should cause further delegate execution.
(await cache.ExecuteAsync(func, new Context(operationKey)).ConfigureAwait(false)).Should().Be(valueToReturn);
delegateInvocations.Should().Be(2);
}
public void Should_not_error_for_executions_on_non_nullable_types_if_cache_does_not_hold_value()
{
const string operationKey = "SomeOperationKey";
bool onErrorCalled = false;
Action <Context, string, Exception> onError = (ctx, key, exc) => { onErrorCalled = true; };
ISyncCacheProvider stubCacheProvider = new StubCacheProvider();
CachePolicy cache = Policy.Cache(stubCacheProvider, TimeSpan.MaxValue, onError);
stubCacheProvider.Get(operationKey).Should().BeNull();
ResultPrimitive result = cache.Execute(ctx => ResultPrimitive.Substitute, new Context(operationKey));
onErrorCalled.Should().BeFalse();
}
public async Task Single_generic_SerializingCacheProvider_should_not_serialize_on_put_for_defaultTResult()
{
bool serializeInvoked = false;
StubSerializer <object, StubSerialized> stubSerializer = new StubSerializer <object, StubSerialized>(
serialize: o => { serializeInvoked = true; return(new StubSerialized(o)); },
deserialize: s => s.Original
);
StubCacheProvider stubCacheProvider = new StubCacheProvider();
object objectToCache = default(object);
string key = "some key";
SerializingCacheProviderAsync <StubSerialized> serializingCacheProvider = new SerializingCacheProviderAsync <StubSerialized>(stubCacheProvider.AsyncFor <StubSerialized>(), stubSerializer);
await serializingCacheProvider.PutAsync(key, objectToCache, new Ttl(TimeSpan.FromMinutes(1)), CancellationToken.None, false);
serializeInvoked.Should().Be(false);
stubCacheProvider.Get(key).Should().BeNull();
}
public void Should_execute_delegate_and_put_value_in_cache_but_when_it_expires_execute_delegate_again()
{
const string valueToReturn = "valueToReturn";
const string operationKey = "SomeOperationKey";
ISyncCacheProvider stubCacheProvider = new StubCacheProvider();
TimeSpan ttl = TimeSpan.FromMinutes(30);
CachePolicy <string> cache = Policy.Cache <string>(stubCacheProvider, ttl);
(bool cacheHit1, object fromCache1) = stubCacheProvider.TryGet(operationKey);
cacheHit1.Should().BeFalse();
fromCache1.Should().BeNull();
int delegateInvocations = 0;
Func <Context, string> func = _ =>
{
delegateInvocations++;
return(valueToReturn);
};
DateTimeOffset fixedTime = SystemClock.DateTimeOffsetUtcNow();
SystemClock.DateTimeOffsetUtcNow = () => fixedTime;
// First execution should execute delegate and put result in the cache.
cache.Execute(func, new Context(operationKey)).Should().Be(valueToReturn);
delegateInvocations.Should().Be(1);
(bool cacheHit2, object fromCache2) = stubCacheProvider.TryGet(operationKey);
cacheHit2.Should().BeTrue();
fromCache2.Should().Be(valueToReturn);
// Second execution (before cache expires) should get it from the cache - no further delegate execution.
// (Manipulate time so just prior cache expiry).
SystemClock.DateTimeOffsetUtcNow = () => fixedTime.Add(ttl).AddSeconds(-1);
cache.Execute(func, new Context(operationKey)).Should().Be(valueToReturn);
delegateInvocations.Should().Be(1);
// Manipulate time to force cache expiry.
SystemClock.DateTimeOffsetUtcNow = () => fixedTime.Add(ttl).AddSeconds(1);
// Third execution (cache expired) should not get it from the cache - should cause further delegate execution.
cache.Execute(func, new Context(operationKey)).Should().Be(valueToReturn);
delegateInvocations.Should().Be(2);
}
public void Single_generic_SerializingCacheProvider_from_extension_syntax_should_not_serialize_on_put_for_defaultTResult()
{
bool serializeInvoked = false;
StubSerializer <object, StubSerialized> stubSerializer = new StubSerializer <object, StubSerialized>(
serialize: o => { serializeInvoked = true; return(new StubSerialized(o)); },
deserialize: s => s.Original
);
StubCacheProvider stubCacheProvider = new StubCacheProvider();
object objectToCache = default(object);
string key = "some key";
SerializingCacheProvider <StubSerialized> serializingCacheProvider = stubCacheProvider.For <StubSerialized>().WithSerializer(stubSerializer);
serializingCacheProvider.Put(key, objectToCache, new Ttl(TimeSpan.FromMinutes(1)));
serializeInvoked.Should().Be(false);
stubCacheProvider.Get(key).Should().BeNull();
}
public void Should_execute_delegate_and_put_value_in_cache_if_cache_does_not_hold_value()
{
const string valueToReturn = "valueToReturn";
const string operationKey = "SomeOperationKey";
ISyncCacheProvider stubCacheProvider = new StubCacheProvider();
CachePolicy <string> cache = Policy.Cache <string>(stubCacheProvider, TimeSpan.MaxValue);
(bool cacheHit1, object fromCache1) = stubCacheProvider.TryGet(operationKey);
cacheHit1.Should().BeFalse();
fromCache1.Should().BeNull();
cache.Execute(_ => valueToReturn, new Context(operationKey)).Should().Be(valueToReturn);
(bool cacheHit2, object fromCache2) = stubCacheProvider.TryGet(operationKey);
cacheHit2.Should().BeTrue();
fromCache2.Should().Be(valueToReturn);
}
public void Should_execute_delegate_and_put_value_in_cache_if_cache_does_not_hold_value__default_for_value_type()
{
ResultPrimitive valueToReturn = default(ResultPrimitive);
const string operationKey = "SomeOperationKey";
ISyncCacheProvider stubCacheProvider = new StubCacheProvider();
CachePolicy cache = Policy.Cache(stubCacheProvider, TimeSpan.MaxValue);
(bool cacheHit1, object fromCache1) = stubCacheProvider.TryGet(operationKey);
cacheHit1.Should().BeFalse();
fromCache1.Should().BeNull();
cache.Execute(ctx => { return(valueToReturn); }, new Context(operationKey)).Should().Be(valueToReturn);
(bool cacheHit2, object fromCache2) = stubCacheProvider.TryGet(operationKey);
cacheHit2.Should().BeTrue();
fromCache2.Should().Be(valueToReturn);
}
public void Should_execute_delegate_but_not_put_value_in_cache_if_cache_does_not_hold_value_but_ttl_indicates_not_worth_caching()
{
const string valueToReturn = "valueToReturn";
const string operationKey = "SomeOperationKey";
ISyncCacheProvider stubCacheProvider = new StubCacheProvider();
CachePolicy cache = Policy.Cache(stubCacheProvider, TimeSpan.Zero);
(bool cacheHit1, object fromCache1) = stubCacheProvider.TryGet(operationKey);
cacheHit1.Should().BeFalse();
fromCache1.Should().BeNull();
cache.Execute(ctx => { return(valueToReturn); }, new Context(operationKey)).Should().Be(valueToReturn);
(bool cacheHit2, object fromCache2) = stubCacheProvider.TryGet(operationKey);
cacheHit2.Should().BeFalse();
fromCache2.Should().BeNull();
}
public void Double_generic_SerializingCacheProvider_should_not_serialize_on_put_for_defaultTResult()
{
bool serializeInvoked = false;
StubSerializer <ResultPrimitive, StubSerialized <ResultPrimitive> > stubTResultSerializer = new StubSerializer <ResultPrimitive, StubSerialized <ResultPrimitive> >(
serialize: o => { serializeInvoked = true; return(new StubSerialized <ResultPrimitive>(o)); },
deserialize: s => s.Original
);
StubCacheProvider stubCacheProvider = new StubCacheProvider();
ResultPrimitive objectToCache = default(ResultPrimitive);
string key = "some key";
SerializingCacheProvider <ResultPrimitive, StubSerialized <ResultPrimitive> > serializingCacheProvider = new SerializingCacheProvider <ResultPrimitive, StubSerialized <ResultPrimitive> >(stubCacheProvider.For <StubSerialized <ResultPrimitive> >(), stubTResultSerializer);
serializingCacheProvider.Put(key, objectToCache, new Ttl(TimeSpan.FromMinutes(1)));
serializeInvoked.Should().Be(false);
stubCacheProvider.Get(key).Should().BeNull();
}
public async Task Single_generic_SerializingCacheProvider_from_extension_syntax_should_serialize_on_put()
{
bool serializeInvoked = false;
StubSerializer <object, StubSerialized> stubSerializer = new StubSerializer <object, StubSerialized>(
serialize: o => { serializeInvoked = true; return(new StubSerialized(o)); },
deserialize: s => s.Original
);
StubCacheProvider stubCacheProvider = new StubCacheProvider();
object objectToCache = new object();
string key = "some key";
SerializingCacheProviderAsync <StubSerialized> serializingCacheProvider = stubCacheProvider.AsyncFor <StubSerialized>().WithSerializer(stubSerializer);
await serializingCacheProvider.PutAsync(key, objectToCache, new Ttl(TimeSpan.FromMinutes(1)), CancellationToken.None, false);
serializeInvoked.Should().Be(true);
(await stubCacheProvider.GetAsync(key, CancellationToken.None, false)).Should().BeOfType <StubSerialized>()
.Which.Original.Should().Be(objectToCache);
}
public void Single_generic_SerializingCacheProvider_should_not_deserialize_on_get_when_item_not_in_cache()
{
bool deserializeInvoked = false;
StubSerializer <object, StubSerialized> stubSerializer = new StubSerializer <object, StubSerialized>(
serialize: o => new StubSerialized(o),
deserialize: s => { deserializeInvoked = true; return(s.Original); }
);
var stubCacheProvider = new StubCacheProvider();
string key = "some key";
stubCacheProvider.Get(key).Should().BeNull();
SerializingCacheProvider <StubSerialized> serializingCacheProvider = new SerializingCacheProvider <StubSerialized>(stubCacheProvider.For <StubSerialized>(), stubSerializer);
object fromCache = serializingCacheProvider.Get(key);
deserializeInvoked.Should().Be(false);
fromCache.Should().Be(default(object));
}
public async Task Should_execute_delegate_and_put_value_in_cache_for_non_nullable_types_if_cache_does_not_hold_value()
{
const ResultPrimitive valueToReturn = ResultPrimitive.Substitute;
const string operationKey = "SomeOperationKey";
IAsyncCacheProvider stubCacheProvider = new StubCacheProvider();
CachePolicy cache = Policy.CacheAsync(stubCacheProvider, TimeSpan.MaxValue);
(await stubCacheProvider.GetAsync(operationKey, CancellationToken.None, false)).Should().BeNull();
(await cache.ExecuteAsync(async ctx =>
{
await TaskHelper.EmptyTask.ConfigureAwait(false);
return(ResultPrimitive.Substitute);
}, new Context(operationKey))).Should().Be(valueToReturn);
(await stubCacheProvider.GetAsync(operationKey, CancellationToken.None, false)).Should().Be(valueToReturn);
}
public async Task Double_generic_SerializingCacheProvider_from_extension_syntax_should_not_serialize_on_put_for_defaultTResult()
{
bool serializeInvoked = false;
StubSerializer <ResultPrimitive, StubSerialized <ResultPrimitive> > stubTResultSerializer = new StubSerializer <ResultPrimitive, StubSerialized <ResultPrimitive> >(
serialize: o => { serializeInvoked = true; return(new StubSerialized <ResultPrimitive>(o)); },
deserialize: s => s.Original
);
StubCacheProvider stubCacheProvider = new StubCacheProvider();
ResultPrimitive objectToCache = default(ResultPrimitive);
string key = "some key";
SerializingCacheProviderAsync <ResultPrimitive, StubSerialized <ResultPrimitive> > serializingCacheProvider =
stubCacheProvider.AsyncFor <StubSerialized <ResultPrimitive> >().WithSerializer(stubTResultSerializer);
await serializingCacheProvider.PutAsync(key, objectToCache, new Ttl(TimeSpan.FromMinutes(1)), CancellationToken.None, false);
serializeInvoked.Should().Be(false);
stubCacheProvider.Get(key).Should().BeNull();
}
public async Task Double_generic_SerializingCacheProvider_should_not_deserialize_on_get_when_item_not_in_cache()
{
bool deserializeInvoked = false;
StubSerializer <ResultPrimitive, StubSerialized <ResultPrimitive> > stubTResultSerializer = new StubSerializer <ResultPrimitive, StubSerialized <ResultPrimitive> >(
serialize: o => new StubSerialized <ResultPrimitive>(o),
deserialize: s => { deserializeInvoked = true; return(s.Original); }
);
var stubCacheProvider = new StubCacheProvider();
string key = "some key";
stubCacheProvider.Get(key).Should().BeNull();
SerializingCacheProviderAsync <ResultPrimitive, StubSerialized <ResultPrimitive> > serializingCacheProvider = new SerializingCacheProviderAsync <ResultPrimitive, StubSerialized <ResultPrimitive> >(stubCacheProvider.AsyncFor <StubSerialized <ResultPrimitive> >(), stubTResultSerializer);
ResultPrimitive fromCache = await serializingCacheProvider.GetAsync(key, CancellationToken.None, false);
deserializeInvoked.Should().Be(false);
fromCache.Should().Be(default(ResultPrimitive));
}
public async Task Double_generic_SerializingCacheProvider_should_serialize_on_put()
{
bool serializeInvoked = false;
StubSerializer <ResultPrimitive, StubSerialized <ResultPrimitive> > stubTResultSerializer = new StubSerializer <ResultPrimitive, StubSerialized <ResultPrimitive> >(
serialize: o => { serializeInvoked = true; return(new StubSerialized <ResultPrimitive>(o)); },
deserialize: s => s.Original
);
var stubCacheProvider = new StubCacheProvider();
ResultPrimitive objectToCache = ResultPrimitive.Good;
string key = "some key";
SerializingCacheProviderAsync <ResultPrimitive, StubSerialized <ResultPrimitive> > serializingCacheProvider = new SerializingCacheProviderAsync <ResultPrimitive, StubSerialized <ResultPrimitive> >(stubCacheProvider.AsyncFor <StubSerialized <ResultPrimitive> >(), stubTResultSerializer);
await serializingCacheProvider.PutAsync(key, objectToCache, new Ttl(TimeSpan.FromMinutes(1)), CancellationToken.None, false);
serializeInvoked.Should().Be(true);
(await stubCacheProvider.GetAsync(key, CancellationToken.None, false)).Should().BeOfType <StubSerialized <ResultPrimitive> >()
.Which.Original.Should().Be(objectToCache);
}
public async Task Single_generic_SerializingCacheProvider_from_extension_syntax_should_not_deserialize_on_get_when_item_not_in_cache()
{
bool deserializeInvoked = false;
StubSerializer <object, StubSerialized> stubSerializer = new StubSerializer <object, StubSerialized>(
serialize: o => new StubSerialized(o),
deserialize: s => { deserializeInvoked = true; return(s.Original); }
);
var stubCacheProvider = new StubCacheProvider();
string key = "some key";
stubCacheProvider.Get(key).Should().BeNull();
SerializingCacheProviderAsync <StubSerialized> serializingCacheProvider = stubCacheProvider.AsyncFor <StubSerialized>().WithSerializer(stubSerializer);
object fromCache = await serializingCacheProvider.GetAsync(key, CancellationToken.None, false);
deserializeInvoked.Should().Be(false);
fromCache.Should().Be(default(object));
}
public void Double_generic_SerializingCacheProvider_from_extension_syntax_should_not_deserialize_on_get_when_item_not_in_cache()
{
bool deserializeInvoked = false;
StubSerializer <ResultPrimitive, StubSerialized <ResultPrimitive> > stubTResultSerializer = new StubSerializer <ResultPrimitive, StubSerialized <ResultPrimitive> >(
serialize: o => new StubSerialized <ResultPrimitive>(o),
deserialize: s => { deserializeInvoked = true; return(s.Original); }
);
var stubCacheProvider = new StubCacheProvider();
string key = "some key";
stubCacheProvider.Get(key).Should().BeNull();
SerializingCacheProvider <ResultPrimitive, StubSerialized <ResultPrimitive> > serializingCacheProvider =
stubCacheProvider.For <StubSerialized <ResultPrimitive> >().WithSerializer(stubTResultSerializer);
ResultPrimitive fromCache = serializingCacheProvider.Get(key);
deserializeInvoked.Should().Be(false);
fromCache.Should().Be(default(ResultPrimitive));
}
public void Single_generic_SerializingCacheProvider_from_extension_syntax_should_deserialize_on_get()
{
bool deserializeInvoked = false;
StubSerializer <object, StubSerialized> stubSerializer = new StubSerializer <object, StubSerialized>(
serialize: o => new StubSerialized(o),
deserialize: s => { deserializeInvoked = true; return(s.Original); }
);
var stubCacheProvider = new StubCacheProvider();
object objectToCache = new object();
string key = "some key";
stubCacheProvider.Put(key, new StubSerialized(objectToCache), new Ttl(TimeSpan.FromMinutes(1)));
SerializingCacheProvider <StubSerialized> serializingCacheProvider = stubCacheProvider.For <StubSerialized>().WithSerializer(stubSerializer);
object fromCache = serializingCacheProvider.Get(key);
deserializeInvoked.Should().Be(true);
fromCache.Should().Be(objectToCache);
}
public async Task Single_generic_SerializingCacheProvider_should_not_deserialize_on_get_when_item_not_in_cache()
{
bool deserializeInvoked = false;
StubSerializer <object, StubSerialized> stubSerializer = new StubSerializer <object, StubSerialized>(
serialize: o => new StubSerialized(o),
deserialize: s => { deserializeInvoked = true; return(s.Original); }
);
var stubCacheProvider = new StubCacheProvider();
string key = "some key";
stubCacheProvider.TryGet(key).Item1.Should().BeFalse();
AsyncSerializingCacheProvider <StubSerialized> serializingCacheProvider = new AsyncSerializingCacheProvider <StubSerialized>(stubCacheProvider.AsyncFor <StubSerialized>(), stubSerializer);
(bool cacheHit, object fromCache) = await serializingCacheProvider.TryGetAsync(key, CancellationToken.None, false);
cacheHit.Should().BeFalse();
deserializeInvoked.Should().BeFalse();
fromCache.Should().Be(default);
public void Double_generic_SerializingCacheProvider_should_deserialize_on_get()
{
bool deserializeInvoked = false;
StubSerializer <ResultPrimitive, StubSerialized <ResultPrimitive> > stubTResultSerializer = new StubSerializer <ResultPrimitive, StubSerialized <ResultPrimitive> >(
serialize: o => new StubSerialized <ResultPrimitive>(o),
deserialize: s => { deserializeInvoked = true; return(s.Original); }
);
var stubCacheProvider = new StubCacheProvider();
ResultPrimitive objectToCache = ResultPrimitive.Good;
string key = "some key";
SerializingCacheProvider <ResultPrimitive, StubSerialized <ResultPrimitive> > serializingCacheProvider = new SerializingCacheProvider <ResultPrimitive, StubSerialized <ResultPrimitive> >(stubCacheProvider.For <StubSerialized <ResultPrimitive> >(), stubTResultSerializer);
stubCacheProvider.Put(key, new StubSerialized <ResultPrimitive>(objectToCache), new Ttl(TimeSpan.FromMinutes(1)));
object fromCache = serializingCacheProvider.Get(key);
deserializeInvoked.Should().Be(true);
fromCache.Should().Be(objectToCache);
}
public async Task Should_not_error_for_executions_on_non_nullable_types_if_cache_does_not_hold_value()
{
const string operationKey = "SomeOperationKey";
bool onErrorCalled = false;
Action <Context, string, Exception> onError = (ctx, key, exc) => { onErrorCalled = true; };
IAsyncCacheProvider stubCacheProvider = new StubCacheProvider();
CachePolicy cache = Policy.CacheAsync(stubCacheProvider, TimeSpan.MaxValue, onError);
(await stubCacheProvider.GetAsync(operationKey, CancellationToken.None, false)).Should().BeNull();
ResultPrimitive result = await cache.ExecuteAsync(async ctx =>
{
await TaskHelper.EmptyTask.ConfigureAwait(false);
return(ResultPrimitive.Substitute);
}, new Context(operationKey));
onErrorCalled.Should().BeFalse();
}
public void Single_generic_SerializingCacheProvider_should_serialize_on_put()
{
bool serializeInvoked = false;
StubSerializer <object, StubSerialized> stubSerializer = new StubSerializer <object, StubSerialized>(
serialize: o => { serializeInvoked = true; return(new StubSerialized(o)); },
deserialize: s => s.Original
);
StubCacheProvider stubCacheProvider = new StubCacheProvider();
object objectToCache = new object();
string key = "some key";
SerializingCacheProvider <StubSerialized> serializingCacheProvider = new SerializingCacheProvider <StubSerialized>(stubCacheProvider.For <StubSerialized>(), stubSerializer);
serializingCacheProvider.Put(key, objectToCache, new Ttl(TimeSpan.FromMinutes(1)));
serializeInvoked.Should().Be(true);
stubCacheProvider.Get(key).Should().BeOfType <StubSerialized>()
.Which.Original.Should().Be(objectToCache);
}
public async Task Single_generic_SerializingCacheProvider_from_extension_syntax_should_deserialize_on_get()
{
bool deserializeInvoked = false;
StubSerializer <object, StubSerialized> stubSerializer = new StubSerializer <object, StubSerialized>(
serialize: o => new StubSerialized(o),
deserialize: s => { deserializeInvoked = true; return(s.Original); }
);
var stubCacheProvider = new StubCacheProvider();
object objectToCache = new object();
string key = "some key";
await stubCacheProvider.PutAsync(key, new StubSerialized(objectToCache), new Ttl(TimeSpan.FromMinutes(1)), CancellationToken.None, false);
SerializingCacheProviderAsync <StubSerialized> serializingCacheProvider = stubCacheProvider.AsyncFor <StubSerialized>().WithSerializer(stubSerializer);
object fromCache = await serializingCacheProvider.GetAsync(key, CancellationToken.None, false);
deserializeInvoked.Should().Be(true);
fromCache.Should().Be(objectToCache);
}
public async Task Should_allow_custom_FuncCacheKeyStrategy()
{
IAsyncCacheProvider stubCacheProvider = new StubCacheProvider();
CachePolicy cache = Policy.CacheAsync(stubCacheProvider, TimeSpan.MaxValue, context => context.ExecutionKey + context["id"]);
object person1 = new object();
await stubCacheProvider.PutAsync("person1", person1, new Ttl(TimeSpan.MaxValue), CancellationToken.None, false).ConfigureAwait(false);
object person2 = new object();
await stubCacheProvider.PutAsync("person2", person2, new Ttl(TimeSpan.MaxValue), CancellationToken.None, false).ConfigureAwait(false);
bool funcExecuted = false;
Func <Task <object> > func = async() => { funcExecuted = true; await TaskHelper.EmptyTask.ConfigureAwait(false); return(new object()); };
(await cache.ExecuteAsync(func, new Context("person", new { id = "1" }.AsDictionary())).ConfigureAwait(false)).Should().BeSameAs(person1);
funcExecuted.Should().BeFalse();
(await cache.ExecuteAsync(func, new Context("person", new { id = "2" }.AsDictionary())).ConfigureAwait(false)).Should().BeSameAs(person2);
funcExecuted.Should().BeFalse();
}
