/// <inheritdoc/>
public Task BeforeHandleAsync(MessageHandlingContext context)
{
if (MessageType.GQL_CONNECTION_INIT.Equals(context.Message?.Type))
{
var payload = context.Message?.Payload;
if (payload != null)
{
var authorizationTokenObject = ((JObject)payload)["Authorization"];
if (authorizationTokenObject != null)
{
var token = authorizationTokenObject.ToString().Replace("Bearer ", string.Empty);
var jwtSecurityToken = new JwtSecurityTokenHandler().ReadJwtToken(token);
this.httpContextAccessor.HttpContext.User =
new ClaimsPrincipal(new ClaimsIdentity(jwtSecurityToken.Claims));
}
}
}
var user = this.httpContextAccessor.HttpContext.User;
context.Properties["GraphQLUserContext"] = new GraphQLUserContext()
{
User = user
};
return(Task.CompletedTask);
}
public async Task ShouldProperlyExecuteFailurePipelineWhenMessageHandlingServiceThrowsException()
{
var argsMock = new Mock <BasicDeliverEventArgs>();
var exception = new Exception();
var messageHandlingServiceMock = new Mock <IMessageHandlingService>();
messageHandlingServiceMock.Setup(x => x.HandleMessageReceivingEvent(It.IsAny <MessageHandlingContext>()))
.ThrowsAsync(exception);
var errorProcessingServiceMock = new Mock <IErrorProcessingService>();
var middlewareOrderingMap = new Dictionary <int, int>();
var firstMiddleware = new StubMessageHandlingMiddleware(1, new Dictionary <int, int>(), middlewareOrderingMap);
var secondMiddleware = new StubMessageHandlingMiddleware(2, new Dictionary <int, int>(), middlewareOrderingMap);
var thirdMiddleware = new StubMessageHandlingMiddleware(3, new Dictionary <int, int>(), middlewareOrderingMap);
var middlewares = new List <IMessageHandlingMiddleware>
{
firstMiddleware,
secondMiddleware,
thirdMiddleware
};
var service = CreateService(
messageHandlingServiceMock.Object,
errorProcessingServiceMock.Object,
middlewares);
var context = new MessageHandlingContext(argsMock.Object, AckAction, false);
await service.Execute(context);
errorProcessingServiceMock.Verify(x => x.HandleMessageProcessingFailure(It.IsAny <MessageHandlingContext>(), exception), Times.Once);
Assert.Equal(1, middlewareOrderingMap[thirdMiddleware.Number]);
Assert.Equal(2, middlewareOrderingMap[secondMiddleware.Number]);
Assert.Equal(3, middlewareOrderingMap[firstMiddleware.Number]);
}
public async Task when_executed_with_message_type_within_context_it_should_find_handlers_for_this_message_and_store_them_in_context()
{
var container = new Container();
container.Options.DefaultScopedLifestyle = new AsyncScopedLifestyle();
container.AddLogging(_testOutput);
var handlersRegistry = new VentureServiceHandlersRegistry(new[] { typeof(Message01Handler).Assembly });
var handlers = handlersRegistry.HandlersGroupedByMessageType[typeof(Message01)];
foreach (var handler in handlers)
{
container.Register(handler);
}
var sut = new FindMessageHandlersStep(new SimpleInjectorAdapter(container));
var context = new MessageHandlingContext
{
MessageType = typeof(Message01),
Api = new FakeIngressApi {
HandlerRegistry = handlersRegistry
}
};
await sut.Execute(context);
var foundHandlers = (IEnumerable <HandlerDescriptor>)context.Handlers;
var singleHandler = foundHandlers.Single();
singleHandler.Should().BeOfType <HandlerDescriptor>("should find the handler for the message");
}
public async Task Failed_Subscribe_writes_error()
{
/* Given */
string id = "1";
var payload = new GraphQLRequest();
var context = new MessageHandlingContext(_server, null);
_executer.ExecuteAsync(null).ReturnsForAnyArgs(
new ExecutionResult
{
Errors = new ExecutionErrors
{
new ExecutionError("error")
}
});
/* When */
await _sut.SubscribeOrExecuteAsync(id, payload, context);
/* Then */
await _writer.Received().SendAsync(
Arg.Is <OperationMessage>(
message => message.Id == id &&
message.Type == MessageType.GQL_ERROR));
}
private static MessageHandlingContext CreateContext()
{
var typesRegistry = new IngressApiMessageTypesRegistry1();
typesRegistry.Initialize();
var context = new MessageHandlingContext
{
Payload = new byte[1],
QueueName = "queue name",
ReceivedOnUtc = DateTimeOffset.UtcNow,
Metadata = new Dictionary <string, string>
{
{ VentureApi.Headers.MessageId, "VentureApi.Headers.MessageId" },
{ VentureApi.Headers.CorrelationId, "VentureApi.Headers.CorrelationId" },
{ VentureApi.Headers.CausationId, "VentureApi.Headers.CausationId" },
{ VentureApi.Headers.MessageTypeName, nameof(Message1) }
},
Api = new FakeIngressApi {
MessageTypesRegistry = typesRegistry, HandlerRegistry = new HandlerRegistry()
}
};
return(context);
}
public async Task BeforeHandleAsync(MessageHandlingContext context)
{
var httpContext = _httpContextAccessor.HttpContext;
if (httpContext != null)
{
if (httpContext.WebSockets.IsWebSocketRequest && (!httpContext.User.Identity.IsAuthenticated))
{
await _webSocketPreHandler.PrepareContext(httpContext);
}
var userContext = new GraphQLUserContext
{
User = httpContext.User
};
// if the default auth scheme is cookies
// users from remote clients that pass bearer token are not automatically authenticated
if (!httpContext.User.Identity.IsAuthenticated)
{
var result = await httpContext.AuthenticateAsync("Bearer");
if (result.Succeeded)
{
userContext.User = result.Principal;
}
}
context.Properties.TryAdd("UserContext", userContext);
}
}
private async Task OnAfterHandleAsync(MessageHandlingContext context)
{
foreach (var listener in _messageListeners)
{
await listener.AfterHandleAsync(context).ConfigureAwait(false);
}
}
public async Task Handle(MessageHandlingContext context, Func <Task> next)
{
var order = _orderingMap.Values.Max();
_orderingMap[Number] = order + 1;
await next();
}
public void when_executed_with_context_with_wrong_message_type_within_broker_message_metadata_it_should_fail()
{
var registry = new CaseOfficeIngressApiMessageTypesRegistry();
registry.Initialize();
var context = new MessageHandlingContext {
Api = new FakeIngressApi {
MessageTypesRegistry = registry
}
};
var step = new ExtractMessageTypeStep();
// ReSharper disable once JoinDeclarationAndInitializer - it's a way to test.
Func <Task> sut;
context.Metadata = new Dictionary <string, string> {
{ VentureApi.Headers.MessageTypeName, null }
};
sut = () => step.Execute(context);
sut.Should().Throw <PoezdOperationException>("null is a wrong message type value");
context.Metadata = new Dictionary <string, string> {
{ VentureApi.Headers.MessageTypeName, string.Empty }
};
sut = () => step.Execute(context);
sut.Should().Throw <PoezdOperationException>("an empty string is a wrong message type value");
context.Metadata = new Dictionary <string, string> {
{ VentureApi.Headers.MessageTypeName, WhitespaceString }
};
sut = () => step.Execute(context);
sut.Should().Throw <PoezdOperationException>("a whitespace string is a wrong message type value");
}
public async Task HandleError(MessageHandlingContext context, Exception exception, Func <Task> next)
{
var order = _errorOrderingMap.Values.Max();
_errorOrderingMap[Number] = order + 1;
await next();
}
public async Task Failed_Subscribe_with_null_stream()
{
/* Given */
string id = "1";
var payload = new GraphQLRequest();
var context = new MessageHandlingContext(_server, null);
_executer.ExecuteAsync(null).ReturnsForAnyArgs(
new ExecutionResult
{
Streams = new Dictionary <string, IObservable <ExecutionResult> >
{
{ "1", null }
}
});
/* When */
await _sut.SubscribeOrExecuteAsync(id, payload, context);
/* Then */
await _writer.Received().SendAsync(
Arg.Is <OperationMessage>(
message => message.Id == id &&
message.Type == MessageType.GQL_ERROR));
}
public async Task BeforeHandleAsync(MessageHandlingContext context)
{
if (context.Terminated)
{
return;
}
var message = context.Message;
if (message.Type == MessageType.GQL_CONNECTION_INIT)
{
JwtSecurityTokenHandler handler = new JwtSecurityTokenHandler();
string token = ((string)((dynamic)message.Payload)
?.Authorization)
?.Replace("Bearer ", "");
if (token == null)
{
return;
}
var user = _jwtValidator.ValidateJwt(token);
_contextAccessor.HttpContext.User = user;
}
}
private void RunMessageHandler(IMessageHandler handler, MessageHandlingContext context, string matchingRoute)
{
ValidateMessageHandler(handler);
_loggingService.LogDebug($"Starting processing the message by message handler {handler.GetType().Name}");
handler.Handle(context, matchingRoute);
_loggingService.LogDebug($"The message has been processed by message handler {handler.GetType().Name}");
}
private async Task RunAsyncMessageHandler(IAsyncMessageHandler handler, MessageHandlingContext context, string matchingRoute)
{
ValidateMessageHandler(handler);
_loggingService.LogDebug($"Starting processing the message by async message handler {handler.GetType().Name}");
await handler.Handle(context, matchingRoute);
_loggingService.LogDebug($"The message has been processed by async message handler {handler.GetType().Name}");
}
public async Task when_executed_with_context_containing_no_message_metadata_it_should_skip()
{
var sut = new ExtractRelationMetadataStep();
var context = new MessageHandlingContext();
await sut.Execute(context);
context.CorrelationId.Should().BeNull("this header not present");
}
/// <inheritdoc />
public virtual async Task HandleMessageProcessingFailure(MessageHandlingContext context, Exception exception)
{
var eventArgs = context.Message;
context.AckAction?.Invoke(eventArgs);
_loggingService.LogError(exception, $"An error occurred while processing received message with the delivery tag {eventArgs.DeliveryTag}.");
await HandleFailedMessageProcessing(eventArgs).ConfigureAwait(false);
}
public async Task when_executed_with_context_containing_message_metadata_with_missing_causation_id_it_should_skip()
{
var sut = new ExtractRelationMetadataStep();
var context = new MessageHandlingContext {
Metadata = new Dictionary <string, string>()
};
await sut.Execute(context);
context.CausationId.Should().BeNull("this header not present");
}
private async Task ProcessMessageEvent(MessageHandlingContext context, IEnumerable <string> matchingRoutes)
{
var container = _messageHandlerContainers.FirstOrDefault(x => x.Exchange == context.Message.Exchange) ??
_messageHandlerContainers.FirstOrDefault(x => x.IsGeneral);
if (container is null)
{
return;
}
var messageHandlerOrderingContainers = new List <MessageHandlerOrderingContainer>();
foreach (var matchingRoute in matchingRoutes)
{
if (!container.MessageHandlers.ContainsKey(matchingRoute))
{
continue;
}
var orderingContainers = container.MessageHandlers[matchingRoute]
.Select(handler => new MessageHandlerOrderingContainer(handler, matchingRoute, container.GetOrderForHandler(handler)));
messageHandlerOrderingContainers.AddRange(orderingContainers);
}
var executedHandlers = new List <Type>();
var orderedContainers = messageHandlerOrderingContainers.OrderByDescending(x => x.Order)
.ThenByDescending(x => x.MessageHandler.GetHashCode())
.ToList();
foreach (var orderedContainer in orderedContainers)
{
var handlerType = orderedContainer.MessageHandler.GetType();
if (executedHandlers.Contains(handlerType))
{
continue;
}
switch (orderedContainer.MessageHandler)
{
case IMessageHandler messageHandler:
RunMessageHandler(messageHandler, context, orderedContainer.MatchingRoute);
break;
case IAsyncMessageHandler asyncMessageHandler:
await RunAsyncMessageHandler(asyncMessageHandler, context, orderedContainer.MatchingRoute).ConfigureAwait(false);
break;
default:
throw new NotSupportedException($"The type {orderedContainer.MessageHandler.GetType()} of message handler is not supported.");
}
executedHandlers.Add(handlerType);
}
}
/// <inheritdoc/>
public async Task Execute(MessageHandlingContext context)
{
try
{
await ExecutePipeline(context).ConfigureAwait(false);
}
catch (Exception exception)
{
await ExecuteFailurePipeline(context, exception).ConfigureAwait(false);
}
}
/// <inheritdoc />
public async Task HandleMessageReceivingEvent(MessageHandlingContext context)
{
var eventArgs = context.Message;
_loggingService.LogInformation($"A new message received with deliveryTag {eventArgs.DeliveryTag}.");
var matchingRoutes = GetMatchingRoutePatterns(eventArgs.Exchange, eventArgs.RoutingKey);
await ProcessMessageEvent(eventArgs, matchingRoutes).ConfigureAwait(false);
context.AckAction?.Invoke(eventArgs);
_loggingService.LogInformation($"Message processing finished successfully. Acknowledge has been sent with deliveryTag {eventArgs.DeliveryTag}.");
}
public async Task when_executed_with_context_containing_causation_id_within_broker_message_metadata_it_should_store_it_in_context()
{
var sut = new ExtractRelationMetadataStep();
var context = new MessageHandlingContext();
const string expectedCausationId = "expected";
context.Metadata = new Dictionary <string, string> {
{ VentureApi.Headers.CausationId, expectedCausationId }
};
await sut.Execute(context);
context.CausationId.Should().Be(expectedCausationId, "this header should be copied");
}
public async Task Subscribe_adds()
{
/* Given */
string id = "1";
var payload = new GraphQLRequest();
var context = new MessageHandlingContext(_server, null);
/* When */
await _sut.SubscribeOrExecuteAsync(id, payload, context);
/* Then */
Assert.Single(_sut, sub => sub.Id == id);
}
/// <inheritdoc/>
public async Task Execute(BasicDeliverEventArgs eventArgs, Action <BasicDeliverEventArgs>?ackAction)
{
var context = new MessageHandlingContext(eventArgs, ackAction);
try
{
await ExecutePipeline(context).ConfigureAwait(false);
}
catch (Exception exception)
{
await ExecuteFailurePipeline(context, exception).ConfigureAwait(false);
}
}
public async Task Subscribe_executes()
{
/* Given */
string id = "1";
var payload = new GraphQLRequest();
var context = new MessageHandlingContext(_server, null);
/* When */
await _sut.SubscribeOrExecuteAsync(id, payload, context);
/* Then */
await _executer.Received().ExecuteAsync(
Arg.Any <ExecutionOptions>());
}
public async Task Unsubscribe_removes()
{
/* Given */
string id = "1";
var payload = new GraphQLRequest();
var context = new MessageHandlingContext(_server, null);
await _sut.SubscribeOrExecuteAsync(id, payload, context);
/* When */
await _sut.UnsubscribeAsync(id);
/* Then */
Assert.Empty(_sut);
}
public Task HandleAsync(MessageHandlingContext context)
{
if (context.Terminated)
{
return(Task.CompletedTask);
}
return(context.Message.Type switch
{
MessageType.GQL_CONNECTION_INIT => HandleInitAsync(context),
MessageType.GQL_START => HandleStartAsync(context),
MessageType.GQL_STOP => HandleStopAsync(context),
MessageType.GQL_CONNECTION_TERMINATE => HandleTerminateAsync(context),
_ => HandleUnknownAsync(context),
});
public async Task ShouldProperlyExecutePipelineWithNoAdditionalMiddlewares()
{
var argsMock = new Mock <BasicDeliverEventArgs>();
var messageHandlingServiceMock = new Mock <IMessageHandlingService>();
var errorProcessingServiceMock = new Mock <IErrorProcessingService>();
var service = CreateService(
messageHandlingServiceMock.Object,
errorProcessingServiceMock.Object,
Enumerable.Empty <IMessageHandlingMiddleware>());
var context = new MessageHandlingContext(argsMock.Object, AckAction, false);
await service.Execute(context);
messageHandlingServiceMock.Verify(x => x.HandleMessageReceivingEvent(It.IsAny <MessageHandlingContext>()), Times.Once);
}
public async Task Subscribe_executes()
{
/* Given */
var id = "1";
var payload = new OperationMessagePayload();
var context = new MessageHandlingContext(_server, null);
/* When */
await _sut.SubscribeOrExecuteAsync(id, payload, context);
/* Then */
await _executer.Received().ExecuteAsync(
Arg.Is(payload.OperationName),
Arg.Is(payload.Query),
Arg.Any <dynamic>(),
context);
}
public void when_executed_with_message_type_and_message_payload_but_without_message_type_descriptor_within_context_it_should_fail()
{
var(_, messageBytes) = CreateSerializedMessage();
var registry = new CaseOfficeIngressApiMessageTypesRegistry();
registry.Initialize();
var messageType = typeof(CreateJusticeCase);
var context = new MessageHandlingContext {
MessageType = messageType, Payload = messageBytes
};
var step = new ParseBrokerMessageStep();
Func <Task> sut = () => step.Execute(context);
sut.Should().Throw <KeyNotFoundException>("impossible to parse message without its message type descriptor");
}
public void when_executed_with_context_without_message_type_registry_it_should_fail()
{
var registry = new CaseOfficeIngressApiMessageTypesRegistry();
registry.Initialize();
const string expectedTypeName = "Venture.CaseOffice.Messages.V1.Commands.CreateCase";
var context = new MessageHandlingContext
{
Metadata = new Dictionary <string, string> {
{ VentureApi.Headers.MessageTypeName, expectedTypeName }
}
};
var step = new ExtractMessageTypeStep();
Func <Task> sut = () => step.Execute(context);
sut.Should().Throw <KeyNotFoundException>("it can not work without message types registry");
}
