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