public async Task Should_move_message_scope_provider_right_after_error_middleware()
{
//arrange
var executionOrderList = new List <int>();
var middlewares = new List <IMessageProcessorMiddleware>();
for (var i = 1; i < 11; i++)
{
middlewares.Add(new TestMiddleware(executionOrderList, i));
}
middlewares.Add(new MessageScopeTestMiddleware(executionOrderList, 0));
var transportConfig = new Mock <ITransportChannelFactory>();
transportConfig.Setup(x => x.Middlewares).Returns(new List <IMessageProcessorMiddleware>());
var finalProcessor = new Mock <IMessageProcessor>();
var pipeline = new MiddlewarePipeline(middlewares, Mock.Of <IPipelineInformation>(), transportConfig.Object, Mock.Of <ILog>());
//act
var chain = pipeline.GetPipeline(finalProcessor.Object);
await chain.ProcessAsync(Mock.Of <IMessageStateHandler <TestCommand> >(), CancellationToken.None);
//assert
for (int i = 0; i < 11; i++)
{
executionOrderList[i].Should().Be(i);
}
executionOrderList.Count.Should().Be(11);
finalProcessor.Verify(x => x.ProcessAsync(It.IsAny <IMessageStateHandler <TestCommand> >(), CancellationToken.None), Times.Once);
}
public void Setup()
{
_messageHandlerProvider = new Mock <IDependencyInjection>();
_logger = new Mock <ILog>();
_stateHandler = new Mock <IMessageStateHandler <TestCommandOne> >();
_countable = new Mock <ICountable>();
_messageHandlerProvider.Setup(x => x.GetScope()).Returns(_messageHandlerProvider.Object);
_messageHandlerProvider.Setup(x => x.GetInstance <IProcessMessage <TestCommandOne> >(typeof(MultipleCommandProcessor))).Returns(
() => new MultipleCommandProcessor(_countable.Object)
);
_stateHandler.Setup(x => x.MessageScope).Returns(_messageHandlerProvider.Object);
_hostConfiguration = new Mock <IHostConfiguration>();
_hostConfiguration.Setup(x => x.DependencyInjection).Returns(_messageHandlerProvider.Object);
_pipelineInformation = new Mock <IPipelineInformation>();
_pipelineInformation.Setup(x => x.HostConfiguration).Returns(_hostConfiguration.Object);
var middlewares = new List <IMessageProcessorMiddleware>
{
new ThrottlingMiddleware(1)
};
var transportConfiguration = new Mock <ITransportChannelFactory>();
transportConfiguration.Setup(x => x.Middlewares).Returns(new List <IMessageProcessorMiddleware>());
var pipeline = new MiddlewarePipeline(middlewares, _pipelineInformation.Object, transportConfiguration.Object, _logger.Object);
_messageProcessor = pipeline.GetPipeline(new MessageProcessor(typeof(MultipleCommandProcessor)));
}
public async Task Build_And_Run_With_Params(int paramI, int paramI2, int paramI3, string paramS, int[] paramAI, string[] paramAS, bool[] paramAB)
{
var paramLI = new List <int>(paramAI);
var paramLS = new List <string>(paramAS);
var expected = new[]
{
$"{nameof(LogMiddlewareWithParams)}+",
$"Params: {paramI}, {paramS}, {paramLI}, {paramLS}, {paramAB}",
$"{nameof(LogMiddlewareWithParamsNextAsLast)}+",
$"Params: {paramI}, {paramI2}, {paramI3}",
$"{nameof(LogMiddlewareWithParamsNextAsLast)}-",
$"{nameof(LogMiddlewareWithParams)}-",
};
var actual = new List <string>();
await MiddlewarePipeline.New <IList <string> >()
.Use <LogMiddlewareWithParams>(paramI, paramS, paramLI, paramLS, paramAB)
.Use <LogMiddlewareWithParamsNextAsLast>(paramI, paramI2, paramI3)
.Build()
.RunAsync(actual)
;
Assert.Equal(expected, actual);
}
public async Task Build_And_Run()
{
var expected = new[]
{
$"{nameof(LogMiddlewareA)}+",
"AnonymousA+",
$"{nameof(LogMiddlewareB)}+",
"Core",
$"{nameof(LogMiddlewareB)}-",
"AnonymousA-",
$"{nameof(LogMiddlewareA)}-",
};
var actual = new List <string>();
await MiddlewarePipeline.New <IList <string> >()
.Use <LogMiddlewareA>()
.Use(async(log, next) =>
{
log.Add("AnonymousA+");
await next(log);
log.Add("AnonymousA-");
})
.Use(typeof(LogMiddlewareB))
.UseAsCore(log =>
{
log.Add("Core");
})
.Build()
.RunAsync(actual)
;
Assert.Equal(expected, actual);
}
public async Task Should_execute_ordered_pipeline()
{
//arrange
var executionOrderList = new List <int>();
var middlewares = new List <IMessageProcessorMiddleware>();
for (var i = 9; i >= 0; i--)
{
middlewares.Add(new TestMiddleware(executionOrderList, i));
}
var transportConfig = new Mock <ITransportChannelFactory>();
transportConfig.Setup(x => x.Middlewares).Returns(middlewares);
var finalProcessor = new Mock <IMessageProcessor>();
var pipeline = new MiddlewarePipeline(new List <IMessageProcessorMiddleware>(), transportConfig.Object, Mock.Of <ILog>());
//act
var chain = pipeline.GetPipeline(finalProcessor.Object);
await chain.ProcessAsync(Mock.Of <IMessageStateHandler <TestCommand> >(), CancellationToken.None);
//assert
for (int i = 0; i < 10; i++)
{
executionOrderList[i].Should().Be(i);
}
finalProcessor.Verify(x => x.ProcessAsync(It.IsAny <IMessageStateHandler <TestCommand> >(), CancellationToken.None), Times.Once);
}
public string ToString(Indent indent)
{
var nl = Environment.NewLine;
var indent2 = indent.Increment();
var tokenTransformations = TokenTransformations
.OrderBy(t => t.Order)
.Select(t => $"{indent2}{t.Name}({t.Order})")
.ToCsv(nl);
var middleware = MiddlewarePipeline
.Select(m => $"{indent2}{m.Method.FullName()}")
.ToCsv(nl);
var paramResolvers = ParameterResolversByType.Keys
.Select(k => $"{indent2}{k}")
.ToCsv(nl);
return($"{nameof(AppConfig)}:{nl}" +
$"{indent}{AppSettings.ToString(indent.Increment())}{nl}" +
$"{indent}DependencyResolver: {DependencyResolver}{nl}" +
$"{indent}HelpProvider: {HelpProvider}{nl}" +
$"{indent}TokenTransformations:{nl}{tokenTransformations}{nl}" +
$"{indent}MiddlewarePipeline:{nl}{middleware}{nl}" +
$"{indent}ParameterResolvers:{nl}{paramResolvers}");
}
/// <summary>
/// Creates a pipeline to demonstrate exception handling.
/// </summary>
/// <param name="func">The method containing the Azure Function business logic implementation.</param>
/// <returns>The middleware pipeline.</returns>
public IMiddlewarePipeline Create(Func <HttpContext, Task <IActionResult> > func)
{
MiddlewarePipeline pipeline = new MiddlewarePipeline(this.httpContextAccessor);
return(pipeline.UseCorrelationId(correlationIdHeaders)
.UseExceptionHandling(CustomExceptionHandler.HandleAsync)
.Use(func));
}
/// <summary>
/// Creates a pipeline to validate query parameters.
/// </summary>
/// <typeparam name="TQuery">The object type representing the query parameters.</typeparam>
/// <param name="func">The method containing the Azure Function business logic implementation.</param>
/// <returns>The middleware pipeline.</returns>
public IMiddlewarePipeline CreateForQuery <TQuery>(Func <HttpContext, Task <IActionResult> > func)
where TQuery : new()
{
MiddlewarePipeline pipeline = new MiddlewarePipeline(this.httpContextAccessor);
return(pipeline.UseCorrelationId(correlationIdHeaders)
.UseQueryValidation <TQuery>()
.Use(func));
}
/// <summary>
/// Creates a pipeline to validate query parameters.
/// </summary>
/// <typeparam name="TQuery">The object type representing the query parameters.</typeparam>
/// <param name="func">The method containing the Azure Function business logic implementation.</param>
/// <returns>The middleware pipeline.</returns>
public IMiddlewarePipeline Create(Func <HttpContext, Task <IActionResult> > func)
{
MiddlewarePipeline pipeline = new MiddlewarePipeline(this.httpContextAccessor);
// If Function1 is called, then use MiddlewareA and B, else use MiddlewareB only
return(pipeline.UseWhen(ctx => ctx.Request.Path.StartsWithSegments("/api/Function1"),
p => p.Use(middlewareA))
.Use(middlewareB)
.Use(func));
}
/// <summary>
/// Creates a pipeline to validate a body payload.
/// </summary>
/// <typeparam name="TBody">The object type representing the body.</typeparam>
/// <param name="func">The method containing the Azure Function business logic implementation.</param>
/// <param name="handleValidationFailure">Optional handler to return a custom response when validation is unsuccessful.</param>
/// <returns>The middleware pipeline.</returns>
public IMiddlewarePipeline CreateForBody <TBody>(
Func <HttpContext, Task <IActionResult> > func,
Func <HttpContext, ModelValidationResult, IActionResult> handleValidationFailure = null)
where TBody : new()
{
MiddlewarePipeline pipeline = new MiddlewarePipeline(this.httpContextAccessor);
return(pipeline.UseCorrelationId(correlationIdHeaders)
.UseBodyValidation <TBody>(handleValidationFailure)
.Use(func));
}
public async Task Build_Linked_And_Run(bool linked)
{
var builder = MiddlewarePipeline.New <IList <string> >()
.Use <LogMiddlewareA>()
.Use <LogMiddlewareB>()
.UseAsCore(log =>
{
log.Add("CoreA");
})
;
var pipeline = linked ? builder.BuildLinked() : builder.Build();
{
var expected = new[]
{
$"{nameof(LogMiddlewareA)}+",
$"{nameof(LogMiddlewareB)}+",
"CoreA",
$"{nameof(LogMiddlewareB)}-",
$"{nameof(LogMiddlewareA)}-",
};
var actual = new List <string>();
await pipeline.RunAsync(actual);
Assert.Equal(expected, actual);
}
builder.UseAsCore(log =>
{
log.Add("CoreB");
});
{
var expected = new[]
{
$"{nameof(LogMiddlewareA)}+",
$"{nameof(LogMiddlewareB)}+",
linked ? "CoreB" : "CoreA",
$"{nameof(LogMiddlewareB)}-",
$"{nameof(LogMiddlewareA)}-",
};
var actual = new List <string>();
await pipeline.RunAsync(actual);
Assert.Equal(expected, actual);
}
}
public void Setup()
{
_messageHandlerProvider = new Mock <IMessageProcessorProvider>();
_logger = new Mock <ILog>();
_stateHandler = new Mock <IMessageStateHandler <TestCommandOne> >();
_countable = new Mock <ICountable>();
_messageHandlerProvider.Setup(x => x.GetProcessor <TestCommandOne>(typeof(MultipleCommandProcessor))).Returns(
() => new MultipleCommandProcessor(_countable.Object)
);
var middlewares = new List <IMessageProcessorMiddleware>
{
new ThrottlingMiddleware(1)
};
var transportConfiguration = new Mock <ITransportChannelFactory>();
transportConfiguration.Setup(x => x.Middlewares).Returns(new List <IMessageProcessorMiddleware>());
var pipeline = new MiddlewarePipeline(middlewares, transportConfiguration.Object, _logger.Object);
_messageProcessor = pipeline.GetPipeline(new MessageProcessor <MultipleCommandProcessor>(_messageHandlerProvider.Object));
}
public async Task Should_execute_scoped_MessageProcessor_with_dependency_injection()
{
//arrange
var container = new ServiceCollection();
var countableMock = new Mock <ICountable>();
container.AddSingleton <ICountable>(countableMock.Object);
var hostConfiguration = new HostConfiguration();
hostConfiguration.RegisterProcessors(container, Assembly.GetExecutingAssembly());
hostConfiguration.UseMicrosoftDependencyInjection(container);
((IIsolatedDependencyInjection)hostConfiguration.DependencyInjection).Build();
var transportChannelFactory = new Mock <ITransportChannelFactory>();
transportChannelFactory.Setup(x => x.Middlewares).Returns(hostConfiguration.Middlewares);
var pipelineInformation = new Mock <IPipelineInformation>();
pipelineInformation.Setup(x => x.HostConfiguration).Returns(hostConfiguration);
var finalProcessor = new MessageProcessor <IProcessCommand <DiTestMessage, DiTestMessageSettings> >();
var pipeline = new MiddlewarePipeline(new List <IMessageProcessorMiddleware>(), pipelineInformation.Object, transportChannelFactory.Object, Mock.Of <ILog>());
var messageStateHandler = new Mock <IMessageStateHandler <DiTestMessage> >();
messageStateHandler.Setup(x => x.MessageScope).Returns(hostConfiguration.DependencyInjection.GetScope);
//act
var chain = pipeline.GetPipeline(finalProcessor);
await chain.ProcessAsync(messageStateHandler.Object, CancellationToken.None);
//assert
countableMock.Verify(x => x.Count(), Times.Once);
}
public WebServer(int currentCount)
{
_sem = new Semaphore(currentCount, currentCount);
_listener = new HttpListener();
_pipeline = new MiddlewarePipeline();
}
