public void Double_generic_constructor_should_throw_on_no_wrapped_cache_provider()
{
StubSerializer <ResultPrimitive, StubSerialized <ResultPrimitive> > stubTResultSerializer = new StubSerializer <ResultPrimitive, StubSerialized <ResultPrimitive> >(
serialize: o => new StubSerialized <ResultPrimitive>(o),
deserialize: s => s.Original
);
Action configure = () => new SerializingCacheProviderAsync <ResultPrimitive, StubSerialized <ResultPrimitive> >(null, stubTResultSerializer);
configure.ShouldThrow <ArgumentNullException>()
.And.ParamName.Should().Be("wrappedCacheProvider");
}
public void Single_generic_constructor_should_throw_on_no_wrapped_cache_provider()
{
StubSerializer <object, StubSerialized> stubObjectSerializer = new StubSerializer <object, StubSerialized>(
serialize: o => new StubSerialized(o),
deserialize: s => s.Original
);
Action configure = () => new SerializingCacheProvider <StubSerialized>(null, stubObjectSerializer);
configure.Should().Throw <ArgumentNullException>()
.And.ParamName.Should().Be("wrappedCacheProvider");
}
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 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 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 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 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 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 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 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_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 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_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 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 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 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 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.TryGet(key).Item1.Should().BeFalse();
SerializingCacheProvider <StubSerialized> serializingCacheProvider = stubCacheProvider.For <StubSerialized>().WithSerializer(stubSerializer);
(bool cacheHit, object fromCache) = serializingCacheProvider.TryGet(key);
cacheHit.Should().BeFalse();
deserializeInvoked.Should().BeFalse();
fromCache.Should().Be(default(object));
}
public void Double_generic_SerializingCacheProvider_from_extension_syntax_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";
SerializingCacheProvider <ResultPrimitive, StubSerialized <ResultPrimitive> > serializingCacheProvider =
stubCacheProvider.For <StubSerialized <ResultPrimitive> >().WithSerializer(stubTResultSerializer);
serializingCacheProvider.Put(key, objectToCache, new Ttl(TimeSpan.FromMinutes(1)));
serializeInvoked.Should().Be(true);
stubCacheProvider.Get(key).Should().BeOfType <StubSerialized <ResultPrimitive> >()
.Which.Original.Should().Be(objectToCache);
}
public void 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.TryGet(key).Item1.Should().BeFalse();
SerializingCacheProvider <ResultPrimitive, StubSerialized <ResultPrimitive> > serializingCacheProvider = new SerializingCacheProvider <ResultPrimitive, StubSerialized <ResultPrimitive> >(stubCacheProvider.For <StubSerialized <ResultPrimitive> >(), stubTResultSerializer);
(bool cacheHit, ResultPrimitive fromCache) = serializingCacheProvider.TryGet(key);
cacheHit.Should().BeFalse();
deserializeInvoked.Should().BeFalse();
fromCache.Should().Be(default(ResultPrimitive));
}
public async Task 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";
AsyncSerializingCacheProvider <ResultPrimitive, StubSerialized <ResultPrimitive> > serializingCacheProvider = new AsyncSerializingCacheProvider <ResultPrimitive, StubSerialized <ResultPrimitive> >(stubCacheProvider.AsyncFor <StubSerialized <ResultPrimitive> >(), stubTResultSerializer);
await stubCacheProvider.PutAsync(key, new StubSerialized <ResultPrimitive>(objectToCache), new Ttl(TimeSpan.FromMinutes(1)), CancellationToken.None, false);
(bool cacheHit, object fromCache) = await serializingCacheProvider.TryGetAsync(key, CancellationToken.None, false);
cacheHit.Should().BeTrue();
deserializeInvoked.Should().BeTrue();
fromCache.Should().Be(objectToCache);
}
public async Task 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.TryGet(key).Item1.Should().BeFalse();
AsyncSerializingCacheProvider <ResultPrimitive, StubSerialized <ResultPrimitive> > serializingCacheProvider =
stubCacheProvider.AsyncFor <StubSerialized <ResultPrimitive> >().WithSerializer(stubTResultSerializer);
(bool cacheHit, ResultPrimitive fromCache) = await serializingCacheProvider.TryGetAsync(key, CancellationToken.None, false);
cacheHit.Should().BeFalse();
deserializeInvoked.Should().BeFalse();
fromCache.Should().Be(default(ResultPrimitive));
}
public async Task Single_generic_SerializingCacheProvider_should_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;
string key = "some key";
AsyncSerializingCacheProvider <StubSerialized> serializingCacheProvider = new AsyncSerializingCacheProvider <StubSerialized>(stubCacheProvider.AsyncFor <StubSerialized>(), stubSerializer);
await serializingCacheProvider.PutAsync(key, objectToCache, new Ttl(TimeSpan.FromMinutes(1)), CancellationToken.None, false);
serializeInvoked.Should().BeTrue();
(bool cacheHit, object fromCache) = stubCacheProvider.TryGet(key);
cacheHit.Should().BeTrue();
fromCache.Should().BeOfType <StubSerialized>()
.Which.Original.Should().Be(objectToCache);
}
public void 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";
SerializingCacheProvider <StubSerialized> serializingCacheProvider = stubCacheProvider.For <StubSerialized>().WithSerializer(stubSerializer);
serializingCacheProvider.Put(key, objectToCache, new Ttl(TimeSpan.FromMinutes(1)));
serializeInvoked.Should().BeTrue();
(bool cacheHit, object fromCache) = stubCacheProvider.TryGet(key);
cacheHit.Should().BeTrue();
fromCache.Should().BeOfType <StubSerialized>()
.Which.Original.Should().Be(objectToCache);
}
