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 ExecuteActivityHost(ExecuteActivityFactory <TActivity, TArguments> activityFactory,
IPipe <RequestContext> executePipe)
{
if (activityFactory == null)
{
throw new ArgumentNullException(nameof(activityFactory));
}
_activityFactory = activityFactory;
_executePipe = executePipe.CreateRequestPipe <ExecuteActivityContext <TActivity, TArguments>, ExecutionResult>();
}
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)));
}
public Task <ResultContext <CompensationResult> > Compensate(CompensateContext <TLog> context, IRequestPipe <CompensateActivityContext <TActivity, TLog>, CompensationResult> next)
{
return(_factory.Compensate(context, next));
}
public Task <ResultContext <ExecutionResult> > Execute(ExecuteContext <TArguments> context,
IRequestPipe <ExecuteActivityContext <TActivity, TArguments>, ExecutionResult> next)
{
return(_factory.Execute(context, next));
}
public CompensateActivityHost(CompensateActivityFactory <TActivity, TLog> activityFactory,
IPipe <RequestContext> compensatePipe)
{
_activityFactory = activityFactory;
_compensatePipe = compensatePipe.CreateRequestPipe <CompensateActivityContext <TActivity, TLog>, CompensationResult>();
}
