public async Task Should_support_pipe_configuration_on_the_result() { IPipe <RequestContext> pipe = CreateHandlerPipe(); IRequestPipe <CheckInventory, CheckInventoryResult> requestPipe = pipe.CreateRequestPipe <CheckInventory, CheckInventoryResult>(x => { x.UseFilter(new UpdateCacheFilter(_inventoryCache)); }); var checkInventory = new CheckInventory() { ItemNumber = "ABC123", Quantity = 2 }; var timer = Stopwatch.StartNew(); var result = await requestPipe.Send(checkInventory).Result(); timer.Stop(); Assert.That(result.ItemNumber, Is.EqualTo(checkInventory.ItemNumber)); Assert.That(result.QuantityOnHand, Is.EqualTo(checkInventory.ItemNumber.GetHashCode() % 100)); Assert.That(timer.Elapsed, Is.GreaterThan(TimeSpan.FromMilliseconds(200))); timer = Stopwatch.StartNew(); result = await requestPipe.Send(checkInventory).Result(); timer.Stop(); Assert.That(result.ItemNumber, Is.EqualTo(checkInventory.ItemNumber)); Assert.That(result.QuantityOnHand, Is.EqualTo(checkInventory.ItemNumber.GetHashCode() % 100)); Assert.That(timer.Elapsed, Is.LessThan(TimeSpan.FromMilliseconds(20))); }
public async Task Should_support_a_simple_request_response_conversation() { IPipe <RequestContext> pipe = CreateHandlerPipe(); IRequestPipe <PurchaseTicket, TicketReceipt> requestPipe = pipe.CreateRequestPipe <PurchaseTicket, TicketReceipt>(); var receipt = await requestPipe.Send(new PurchaseTicket { EventName = "The Big Party", Quantity = 2 }).Result(); Assert.That(receipt.OrderNumber, Is.EqualTo("42")); }
public async Task Should_support_the_same_thing_a_different_way() { IPipe <RequestContext> pipe = CreateHandlerPipe(); IRequestPipe <PurchaseTicket, TicketReceipt> requestPipe = pipe.CreateRequestPipe <PurchaseTicket, TicketReceipt>(); var receipt = await requestPipe.Send(new PurchaseTicket { EventName = "The Big Party", Quantity = 2 }).Result(); Assert.That(receipt.OrderNumber, Is.EqualTo("42")); }
public async Task <ResultContext <ExecutionResult> > Execute(ExecuteContext <TArguments> context, IRequestPipe <ExecuteActivityContext <TActivity, TArguments>, ExecutionResult> next) { using (IExecuteActivityScopeContext <TActivity, TArguments> scope = _scopeProvider.GetScope(context)) { if (_log.IsDebugEnabled) { _log.DebugFormat("ExecuteActivityFactory: Executing: {0}", TypeMetadataCache <TActivity> .ShortName); } return(await next.Send(scope.Context).ConfigureAwait(false)); } }
public async Task Should_support_pipe_configuration_on_the_result() { IPipe <RequestContext> pipe = CreateHandlerPipe(); IRequestPipe <PurchaseTicket, TicketReceipt> requestPipe = pipe.CreateRequestPipe <PurchaseTicket, TicketReceipt>(x => { x.UseExecute(context => context.Result.AuthorizationCode = "8675309"); }); var receipt = await requestPipe.Send(new PurchaseTicket { EventName = "The Big Party", Quantity = 2 }).Result(); Assert.That(receipt.OrderNumber, Is.EqualTo("42")); Assert.That(receipt.AuthorizationCode, Is.EqualTo("8675309")); }
public async Task <ResultContext <ExecutionResult> > Execute(ExecuteContext <TArguments> context, IRequestPipe <ExecuteActivityContext <TActivity, TArguments>, ExecutionResult> next) { TActivity activity = null; try { activity = _executeFactory(context.Arguments); var activityContext = new HostExecuteActivityContext <TActivity, TArguments>(activity, context); return(await next.Send(activityContext).ConfigureAwait(false)); } finally { var disposable = activity as IDisposable; disposable?.Dispose(); } }
public async Task <ResultContext <CompensationResult> > Compensate(CompensateContext <TLog> context, IRequestPipe <CompensateActivityContext <TActivity, TLog>, CompensationResult> next) { TActivity activity = null; try { activity = _compensateFactory(context.Log); var activityContext = new HostCompensateActivityContext <TActivity, TLog>(activity, context); return(await next.Send(activityContext).ConfigureAwait(false)); } finally { var disposable = activity as IDisposable; disposable?.Dispose(); } }
public async Task <ResultContext <CompensationResult> > Compensate(CompensateContext <TLog> context, IRequestPipe <CompensateActivityContext <TActivity, TLog>, CompensationResult> next) { using (var innerScope = _lifetimeScope.BeginLifetimeScope(x => ConfigureScope(x, context))) { if (_log.IsDebugEnabled) { _log.DebugFormat("CompensateActivityFactory: Compensating: {0}", TypeMetadataCache <TActivity> .ShortName); } var activity = innerScope.Resolve <TActivity>(TypedParameter.From(context.Log)); CompensateActivityContext <TActivity, TLog> activityContext = new HostCompensateActivityContext <TActivity, TLog>(activity, context); var consumerLifetimeScope = innerScope; activityContext.GetOrAddPayload(() => consumerLifetimeScope); return(await next.Send(activityContext).ConfigureAwait(false)); } }
public async Task Should_support_multiple_result_types() { IPipe <RequestContext> pipe = CreateHandlerPipe(); IRequestPipe <PurchaseTicket> requestPipe = pipe.CreateRequestPipe <PurchaseTicket>( x => x.Result <TicketReceipt>(), x => x.Result <EventSoldOut>()); var resultContext = await requestPipe.Send(new PurchaseTicket { EventName = "Golden State Warriors", Quantity = 4 }); TicketReceipt receipt; Assert.That(resultContext.TryGetResult(out receipt), Is.False); EventSoldOut soldOut; Assert.That(resultContext.TryGetResult(out soldOut), Is.True); Assert.That(soldOut.EventName, Is.EqualTo("Golden State Warriors")); }
public async Task <ResultContext <ExecutionResult> > Execute(ExecuteContext <TArguments> context, IRequestPipe <ExecuteActivityContext <TActivity, TArguments>, ExecutionResult> next) { using (var scope = _lifetimeScope.BeginLifetimeScope(x => ConfigureScope(x, context))) { if (_log.IsDebugEnabled) { _log.DebugFormat("ExecuteActivityFactory: Executing: {0}", TypeMetadataCache <TActivity> .ShortName); } var activity = scope.Resolve <TActivity>(TypedParameter.From(context.Arguments)); ExecuteActivityContext <TActivity, TArguments> activityContext = new HostExecuteActivityContext <TActivity, TArguments>(activity, context); var consumerLifetimeScope = scope; activityContext.GetOrAddPayload(() => consumerLifetimeScope); return(await next.Send(activityContext).ConfigureAwait(false)); } }
public async Task <ResultContext <ExecutionResult> > Execute(ExecuteContext <TArguments> context, IRequestPipe <ExecuteActivityContext <TActivity, TArguments>, ExecutionResult> next) { using (_kernel.RequireScope()) { if (_log.IsDebugEnabled) { _log.DebugFormat("ExecuteActivityFactory: Executing: {0}", TypeMetadataCache <TActivity> .ShortName); } var activity = _kernel.Resolve <TActivity>(new { context.Arguments, context.ConsumeContext }); if (activity == null) { throw new ConsumerException($"Unable to resolve activity type '{TypeMetadataCache<TActivity>.ShortName}'."); } var activityContext = new HostExecuteActivityContext <TActivity, TArguments>(activity, context); return(await next.Send(activityContext).ConfigureAwait(false)); } }
public async Task Should_support_awesome_caching_speed() { IPipe <RequestContext> pipe = CreateHandlerPipe(); IRequestPipe <CheckInventory, CheckInventoryResult> requestPipe = pipe.CreateRequestPipe <CheckInventory, CheckInventoryResult>(x => { x.UseFilter(new UpdateCacheFilter(_inventoryCache)); }); var checks = new CheckInventory[] { new CheckInventory() { ItemNumber = "ABC123", Quantity = 2 }, new CheckInventory() { ItemNumber = "DEF456", Quantity = 4 }, new CheckInventory() { ItemNumber = "GHI789", Quantity = 6 }, }; var timer = Stopwatch.StartNew(); for (var i = 0; i < 100; i++) { await requestPipe.Send(checks[i % checks.Length]).Result(); } timer.Stop(); Console.WriteLine("Total time: {0}ms", timer.ElapsedMilliseconds); Console.WriteLine("Total calls: {0}", _totalCalls); Assert.That(timer.Elapsed, Is.LessThan(TimeSpan.FromMilliseconds(1000))); }