public void When_Building_A_Handler_For_An_Async_Command()
{
_chainOfResponsibility = _chainBuilder.BuildAsync(_requestContext, false).First();
_chainOfResponsibility.Context.Should().NotBeNull();
_chainOfResponsibility.Context.Should().BeSameAs(_requestContext);
}
public void Add(IHandleRequestsAsync instance)
{
if (_asyncHandlerFactory == null)
throw new ArgumentException("An instance of an async handler can not be added without an AsyncHandlerFactory.");
_trackedAsyncObjects.Add(instance);
_logger.Value.DebugFormat("Tracking async handler instance {0} of type {1}", instance.GetHashCode(), instance.GetType());
}
public void When_Building_A_Handler_For_An_Async_Command()
{
s_chainOfResponsibility = s_chainBuilder.BuildAsync(s_requestContext, false).First();
Assert.NotNull(s_chainOfResponsibility.Context);
Assert.AreSame(s_requestContext, s_chainOfResponsibility.Context);
}
public void When_A_Handler_Is_Part_Of_An_Async_Pipeline()
{
_pipeline = _pipelineBuilder.BuildAsync(new RequestContext(), false).First();
TracePipeline().ToString().Should().Contain("MyImplicitHandlerAsync");
TracePipeline().ToString().Should().Contain("MyLoggingHandlerAsync");
}
private PipelineTracer TracePipeline(IHandleRequestsAsync <TRequest> firstInPipeline)
{
var pipelineTracer = new PipelineTracer();
firstInPipeline.DescribePath(pipelineTracer);
return(pipelineTracer);
}
public void When_Building_An_Async_Pipeline_That_Has_Sync_Handlers()
{
_exception = Catch.Exception(() => _pipeline = _pipelineBuilder.BuildAsync(new RequestContext(), false).First());
Assert.NotNull(_exception);
Assert.IsInstanceOf(typeof(ConfigurationException), _exception);
StringAssert.Contains(typeof(MyLoggingHandler <>).Name, _exception.Message);
}
public void When_Building_An_Async_Pipeline_That_Has_Sync_Handlers()
{
_exception = Catch.Exception(() => _pipeline = _pipelineBuilder.BuildAsync(new RequestContext(), false).First());
_exception.Should().NotBeNull();
_exception.Should().BeOfType <ConfigurationException>();
_exception.Message.Should().Contain(typeof(MyLoggingHandler <>).Name);
}
public void Add(IHandleRequestsAsync instance)
{
if (_asyncHandlerFactory == null)
{
throw new ArgumentException("An instance of an async handler can not be added without an AsyncHandlerFactory.");
}
_trackedAsyncObjects.Add(instance);
_logger.Value.DebugFormat("Tracking async handler instance {0} of type {1}", instance.GetHashCode(), instance.GetType());
}
public void Release(IHandleRequestsAsync handler)
{
var disposable = handler as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
handler = null;
}
public void Release(IHandleRequestsAsync handler)
{
// ReSharper disable once SuspiciousTypeConversion.Global
var disposable = handler as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
public void Release(IHandleRequestsAsync handler)
{
var disposable = handler as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
public void Release(IHandleRequestsAsync handler)
{
// ReSharper disable once SuspiciousTypeConversion.Global
var disposable = handler as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
public void Release(IHandleRequestsAsync handler)
{
if (!_isTransient)
{
return;
}
var disposal = handler as IDisposable;
disposal?.Dispose();
}
private void AppendToAsyncPipeline(IEnumerable <RequestHandlerAttribute> attributes, IHandleRequestsAsync <TRequest> implicitHandler, IRequestContext requestContext)
{
IHandleRequestsAsync <TRequest> lastInPipeline = implicitHandler;
attributes.Each(attribute =>
{
var handlerType = attribute.GetHandlerType();
if (handlerType.GetTypeInfo().GetInterfaces().Contains(typeof(IHandleRequestsAsync)))
{
var decorator = _asyncHandlerFactory.CreateAsyncRequestHandler <TRequest>(attribute, requestContext);
lastInPipeline.SetSuccessor(decorator);
lastInPipeline = decorator;
}
else
{
var message = string.Format("All handlers in an async pipeline must derive from IHandleRequestsAsync. You cannot have a mixed pipeline by including handler {0}", handlerType.Name);
throw new ConfigurationException(message);
}
});
}
public void Release(IHandleRequestsAsync handler)
{
}
private IHandleRequestsAsync <TRequest> PushOntoAsyncPipeline(IEnumerable <RequestHandlerAttribute> attributes, IHandleRequestsAsync <TRequest> lastInPipeline, IRequestContext requestContext, bool continueOnCapturedContext)
{
attributes.Each(attribute =>
{
var handlerType = attribute.GetHandlerType();
if (handlerType.GetTypeInfo().GetInterfaces().Contains(typeof(IHandleRequestsAsync)))
{
var decorator = _asyncHandlerFactory.CreateAsyncRequestHandler <TRequest>(attribute, requestContext);
decorator.ContinueOnCapturedContext = continueOnCapturedContext;
decorator.SetSuccessor(lastInPipeline);
lastInPipeline = decorator;
}
else
{
var message = string.Format("All handlers in an async pipeline must derive from IHandleRequestsAsync. You cannot have a mixed pipeline by including handler {0}", handlerType.Name);
throw new ConfigurationException(message);
}
});
return(lastInPipeline);
}
public void Release(IHandleRequestsAsync handler)
{
var disposable = handler as IDisposable;
disposable?.Dispose();
}
public void Release(IHandleRequestsAsync handler)
{
var disposable = handler as IDisposable;
disposable?.Dispose();
}
public void When_Building_An_Async_Pipeline_Allow_ForiegnAttribues()
{
_pipeline = _pipeline_Builder.BuildAsync(new RequestContext(), false).First();
Assert.AreEqual("MyValidationHandlerAsync`1|MyObsoleteCommandHandlerAsync|MyLoggingHandlerAsync`1|", TraceFilters().ToString());
}
public void Release(IHandleRequestsAsync handler)
{
}
public void Add(IHandleRequestsAsync <TRequest> handler)
{
_filters.Add(handler);
}
private void When_Building_An_Async_Pipeline_Allow_Pre_And_Post_Tasks()
{
_pipeline = _pipelineBuilder.BuildAsync(new RequestContext(), false).First();
TraceFilters().ToString().Should().Be("MyValidationHandlerAsync`1|MyPreAndPostDecoratedHandlerAsync|MyLoggingHandlerAsync`1|");
}
/// <summary>
/// Sets the successor.
/// </summary>
/// <param name="successor">The successor.</param>
public void SetSuccessor(IHandleRequestsAsync <TRequest> successor)
{
_successor = successor;
}
public void Release(IHandleRequestsAsync handler)
{
// todo not supported by all containers
}
public void When_Building_An_Async_Pipeline_Preserve_The_Order()
{
_pipeline = _pipeline_Builder.BuildAsync(new RequestContext(), false).First();
PipelineTracer().ToString().Should().Be("MyLoggingHandlerAsync`1|MyValidationHandlerAsync`1|MyDoubleDecoratedHandlerAsync|");
}
public void When_Building_An_Async_Pipeline_Allow_ForeignAttributes()
{
_pipeline = _pipeline_Builder.BuildAsync(new RequestContext(), false).First();
TraceFilters().ToString().Should().Be("MyValidationHandlerAsync`1|MyObsoleteCommandHandlerAsync|MyLoggingHandlerAsync`1|");
}
