public async Task MemoizeAsync_MultipleFailingCallsWithSuppressCaching_ThrowExceptionForEachSuppressedCacheCallAndReturnCachedValueForNonSuppressedCachedCalls()
{
string firstValue = "first Value";
var refreshTask = new TaskCompletionSource <Thing>();
var dataSource = CreateDataSource(firstValue, refreshTask);
var memoizer = CreateMemoizer(CreateCache());
using (TracingContext.SuppressCaching(CacheSuppress.RecursiveAllDownstreamServices))
{
//Cache result for a successful call
var actual = await(Task <Thing>) memoizer.Memoize(dataSource, ThingifyTaskThing, new object[] { "someString" }, GetPolicy()); //1 call to data source
actual.Id.ShouldBe(firstValue);
//Should throw for each call to the data source
refreshTask.SetException(new Exception("Boo!!"));
//because we are in SuppressCaching using block, all calls will try to go to data source and fail
for (int i = 0; i < 10; i++) //10 calls to data source
{
var task = (Task <Thing>)memoizer.Memoize(dataSource, ThingifyTaskThing, new object[] { "someString" }, GetPolicy());
task.ShouldThrow <EnvironmentException>();
}
}
for (int i = 0; i < 5; i++)
{
//We are not in SuppressCaching using block, get cached result (NOT FROM DATA SOURCE)
var value = await(Task <Thing>) memoizer.Memoize(dataSource, ThingifyTaskThing, new object[] { "someString" }, GetPolicy()); //should not call data source
value.Id.ShouldBe(firstValue);
}
//We have total of 11 calls to data source: first one which cached the result, another failing 10 under SuppressCaching using block
dataSource.Received(11).ThingifyTaskThing("someString");
}
public async Task MemoizeAsync_MultipleCallsWithDoNotSuppressCaching_UseCacheForDoNotSuppressCalls()
{
string firstValue = "first Value";
var dataSource = CreateDataSource(firstValue);
var memoizer = CreateMemoizer(CreateCache());
var actual = await(Task <Thing>) memoizer.Memoize(dataSource, ThingifyTaskThing, new object[] { "someString" }, GetPolicy());
actual.Id.ShouldBe(firstValue);
using (TracingContext.SuppressCaching(CacheSuppress.DoNotSuppress))
{
for (int i = 0; i < 100; i++)
{
actual = await(Task <Thing>) memoizer.Memoize(dataSource, ThingifyTaskThing, new object[] { "someString" }, GetPolicy());
actual.Id.ShouldBe(firstValue);
}
}
dataSource.Received(1).ThingifyTaskThing("someString");
}
public async Task MemoizeAsync_ParallelSuppressedAndNonSuppressedCallsWithSuppressCaching_UsesDataSourceForEverySuppressedCacheCallX()
{
string firstValue = "first Value";
var dataSource = CreateDataSource(firstValue);
var memoizer = CreateMemoizer(CreateCache());
//call data source and cache value
await(Task <Thing>) memoizer.Memoize(dataSource, ThingifyTaskThing, new object[] { "someString" }, GetPolicy());
List <Task <Thing> > tasks = new List <Task <Thing> >();
//calls should use cache, although they run in parallel to suppressed cached calls (but not under using)
for (int i = 0; i < 10; i++)
{
var task = new Task <Thing>(() => ((Task <Thing>)memoizer.Memoize(dataSource, ThingifyTaskThing, new object[] { "someString" }, GetPolicy())).Result);
tasks.Add(task);
}
//SuppressCaching
using (TracingContext.SuppressCaching(CacheSuppress.RecursiveAllDownstreamServices))
{
//start the tasks here, so they will run in parallel to cache suppress
foreach (var task in tasks)
{
task.Start();
}
//10 suppressed cached calls should call data source
for (int i = 0; i < 10; i++)
{
await(Task <Thing>) memoizer.Memoize(dataSource, ThingifyTaskThing, new object[] { "someString" }, GetPolicy());
}
}
await Task.WhenAll(tasks.ToArray());
dataSource.Received(11).ThingifyTaskThing("someString");
}
public async Task MemoizeAsync_MultipleCallsWithSuppressCaching_UsesDataSourceForEverySuppressedCacheCall()
{
string firstValue = "first Value";
var dataSource = CreateDataSource(firstValue);
var memoizer = CreateMemoizer(CreateCache());
//SuppressCaching - option 1 (50 calls)
using (TracingContext.SuppressCaching(CacheSuppress.RecursiveAllDownstreamServices))
{
for (int i = 0; i < 50; i++)
{
var actual = await(Task <Thing>) memoizer.Memoize(dataSource, ThingifyTaskThing,
new object[] { "someString" }, GetPolicy());
actual.Id.ShouldBe(firstValue);
}
}
//SuppressCaching - option 2 (50 calls)
using (TracingContext.SuppressCaching(CacheSuppress.UpToNextServices))
{
for (int i = 0; i < 50; i++)
{
var actual = await(Task <Thing>) memoizer.Memoize(dataSource, ThingifyTaskThing,
new object[] { "someString" }, GetPolicy());
actual.Id.ShouldBe(firstValue);
}
}
//Use cache (we are not in suppressCaching block
for (int i = 0; i < 50; i++)
{
var actual = await(Task <Thing>) memoizer.Memoize(dataSource, ThingifyTaskThing, new object[] { "someString" }, GetPolicy());
actual.Id.ShouldBe(firstValue);
}
dataSource.Received(100).ThingifyTaskThing("someString");
}
public async Task ServiceProxyRpcMessageShouldRemainSame()
{
const string serviceName = "DemoService";
int defaultPort = DisposablePort.GetPort().Port;
var dict = new Dictionary <string, string>
{
{ $"Discovery.Services.{serviceName}.Source", "Config" },
{ $"Discovery.Services.{serviceName}.Hosts", "host1" },
{ $"Discovery.Services.{serviceName}.DefaultPort", defaultPort.ToString() }
};
Uri uri = null;
string requestMessage = null;
Func <HttpClientConfiguration, HttpMessageHandler> messageHandlerFactory = _ =>
{
var messageHandler = new MockHttpMessageHandler();
messageHandler
.When("*").Respond(async req =>
{
requestMessage = await req.Content.ReadAsStringAsync();
uri = req.RequestUri;
return(HttpResponseFactory.GetResponse(HttpStatusCode.Accepted));
});
return(messageHandler);
};
using (var kernel = new TestingKernel <ConsoleLog>(k =>
{
k.Rebind <IDiscovery>().To <ServiceDiscovery.Rewrite.Discovery>().InSingletonScope();
k.Rebind <Func <HttpClientConfiguration, HttpMessageHandler> >().ToMethod(c => messageHandlerFactory);
}, dict))
{
var providerFactory = kernel.Get <Func <string, ServiceProxyProvider> >();
TracingContext.SetRequestID("g");
var serviceProxy = providerFactory(serviceName);
string expectedHost = "override-host";
int expectedPort = DisposablePort.GetPort().Port;
TracingContext.SetHostOverride(serviceName, expectedHost, expectedPort);
var request = new HttpServiceRequest("testMethod", null, new Dictionary <string, object>());
using (TracingContext.Tags.SetUnencryptedTag("test", 1))
using (TracingContext.SuppressCaching(CacheSuppress.RecursiveAllDownstreamServices))
await serviceProxy.Invoke(request, typeof(string));
var body = requestMessage;
Console.WriteLine($"error: {body}");
JsonConvert.DeserializeObject <GigyaRequestProtocol>(body, new JsonSerializerSettings()
{
MissingMemberHandling = MissingMemberHandling.Error
});
uri.Host.ShouldBe(expectedHost);
uri.Port.ShouldBe(expectedPort);
}
}