public async Task FulfillOrderWebHookWithNonPriviledgedUserLogsWhenSupplyingTestData() { var mockLogger = new Mock <ILogger>(); var mockActionDescriptor = new Mock <HttpActionDescriptor>(); var httpConfiguration = new HttpConfiguration(); var routeData = new HttpRouteData(new HttpRoute()); var request = new HttpRequestMessage(); var controllerDescriptor = new HttpControllerDescriptor { Configuration = httpConfiguration, ControllerName = nameof(OrderSubmissionController) }; var controllerContext = new HttpControllerContext(httpConfiguration, routeData, request) { ControllerDescriptor = controllerDescriptor }; var actionContext = new HttpActionContext(controllerContext, mockActionDescriptor.Object); var unpriviledgedIdentity = new ClaimsIdentity(new Claim[] { new Claim(CustomClaimTypes.IdentityType, "UnitTest") }); mockLogger.Setup(log => log.ForContext(It.IsAny <string>(), It.IsAny <object>(), It.IsAny <bool>())) .Returns(mockLogger.Object); mockActionDescriptor.SetupGet(descriptor => descriptor.ActionName).Returns("someAction"); actionContext.RequestContext.Principal = new ClaimsPrincipal(unpriviledgedIdentity); request.SetConfiguration(httpConfiguration); request.SetRouteData(routeData); var controller = new OrderSubmissionController(Mock.Of <IClock>(), Mock.Of <ICommandPublisher <ProcessOrder> >(), Mock.Of <IEventPublisher <EventBase> >(), mockLogger.Object, new OrderSubmissionControllerConfiguration()) { ControllerContext = controllerContext }; var order = new OrderFulfillmentMessage { OrderRequestHeader = new OrderHeader { OrderId = "ABC123", OrderDate = new DateTime(2017, 12, 09, 09, 00, 00, DateTimeKind.Utc) }, LineItems = new List <LineItem>(), Emulation = new DependencyEmulation() }; var partner = "SQUIRE"; var actionResult = await controller.FulfillOrderWebHook(partner, order); var result = await actionResult.ExecuteAsync(CancellationToken.None); mockLogger.Verify(logger => logger.Warning(It.IsAny <string>(), It.Is <HttpStatusCode>(code => code == HttpStatusCode.Forbidden), It.Is <string>(name => name == nameof(OrderSubmissionController)), It.Is <string>(method => method == nameof(OrderSubmissionController.FulfillOrderWebHook)), It.Is <string>(partnerName => partnerName == partner), It.IsAny <HttpRequestHeaders>()), Times.Once, "The failure should be logged"); }
public async Task FulfillOrderWebHookWithFailedCommandFails() { var mockLogger = new Mock <ILogger>(); var mockCommandPublisher = new Mock <ICommandPublisher <ProcessOrder> >(); var mockActionDescriptor = new Mock <HttpActionDescriptor>(); var httpConfiguration = new HttpConfiguration(); var routeData = new HttpRouteData(new HttpRoute()); var request = new HttpRequestMessage(); var controllerDescriptor = new HttpControllerDescriptor { Configuration = httpConfiguration, ControllerName = nameof(OrderSubmissionController) }; var controllerContext = new HttpControllerContext(httpConfiguration, routeData, request) { ControllerDescriptor = controllerDescriptor }; var actionContext = new HttpActionContext(controllerContext, mockActionDescriptor.Object); mockLogger.Setup(log => log.ForContext(It.IsAny <string>(), It.IsAny <object>(), It.IsAny <bool>())) .Returns(mockLogger.Object); mockCommandPublisher.Setup(publisher => publisher.TryPublishAsync(It.IsAny <ProcessOrder>(), It.IsAny <Instant?>())) .ReturnsAsync(false); mockActionDescriptor.SetupGet(descriptor => descriptor.ActionName).Returns("someAction"); request.SetConfiguration(httpConfiguration); request.SetRouteData(routeData); var controller = new OrderSubmissionController(Mock.Of <IClock>(), mockCommandPublisher.Object, Mock.Of <IEventPublisher <EventBase> >(), mockLogger.Object, new OrderSubmissionControllerConfiguration { ServiceUnavailableeRetryAfterInSeconds = 5 }) { ControllerContext = controllerContext }; var order = new OrderFulfillmentMessage { OrderRequestHeader = new OrderHeader { OrderId = "ABC123", OrderDate = new DateTime(2017, 12, 09, 09, 00, 00, DateTimeKind.Utc) }, LineItems = new List <LineItem>() }; var actionResult = await controller.FulfillOrderWebHook("SQUIRE", order); var result = await actionResult.ExecuteAsync(CancellationToken.None); result.Should().NotBeNull("because a result should have been returned"); result.StatusCode.Should().Be(HttpStatusCode.ServiceUnavailable, "because the request should have been rejected"); result.Headers.RetryAfter.Should().NotBeNull("because a RETRY-AFTER header should be specified for an Service Unavailable result"); }
public async Task FulfillOrderWebHookPublishesTheCommandToTiriggerProcessingForAnAcceptedOrder() { var mockLogger = new Mock <ILogger>(); var mockCommandPublisher = new Mock <ICommandPublisher <ProcessOrder> >(); var mockActionDescriptor = new Mock <HttpActionDescriptor>(); var httpConfiguration = new HttpConfiguration(); var routeData = new HttpRouteData(new HttpRoute()); var request = new HttpRequestMessage(); var controllerDescriptor = new HttpControllerDescriptor { Configuration = httpConfiguration, ControllerName = nameof(OrderSubmissionController) }; var controllerContext = new HttpControllerContext(httpConfiguration, routeData, request) { ControllerDescriptor = controllerDescriptor }; var actionContext = new HttpActionContext(controllerContext, mockActionDescriptor.Object); mockLogger.Setup(log => log.ForContext(It.IsAny <string>(), It.IsAny <object>(), It.IsAny <bool>())) .Returns(mockLogger.Object); mockActionDescriptor.SetupGet(descriptor => descriptor.ActionName).Returns("someAction"); request.SetConfiguration(httpConfiguration); request.SetRouteData(routeData); var controller = new OrderSubmissionController(Mock.Of <IClock>(), mockCommandPublisher.Object, Mock.Of <IEventPublisher <EventBase> >(), mockLogger.Object, new OrderSubmissionControllerConfiguration { OrderAcceptedRetryAfterInSeconds = 5 }) { ControllerContext = controllerContext }; var order = new OrderFulfillmentMessage { OrderRequestHeader = new OrderHeader { OrderId = "ABC123", OrderDate = new DateTime(2017, 12, 09, 09, 00, 00, DateTimeKind.Utc) }, LineItems = new List <LineItem>() }; var actionResult = await controller.FulfillOrderWebHook("SQUIRE", order); var result = await actionResult.ExecuteAsync(CancellationToken.None); result.Should().NotBeNull("because a result should have been returned"); mockCommandPublisher.Verify(publisher => publisher.TryPublishAsync(It.Is <ProcessOrder>(command => command.OrderId == order.OrderRequestHeader.OrderId), It.Is <Instant?>(time => time == null)), Times.Once, "An accepted order should emit an Order Received event"); }
public async Task FulfillOrderWebHookAcceptsAnOrder() { var mockCommandPublisher = new Mock <ICommandPublisher <ProcessOrder> >(); var mockActionDescriptor = new Mock <HttpActionDescriptor>(); var httpConfiguration = new HttpConfiguration(); var routeData = new HttpRouteData(new HttpRoute()); var request = new HttpRequestMessage(); var controllerDescriptor = new HttpControllerDescriptor { Configuration = httpConfiguration, ControllerName = nameof(OrderSubmissionController) }; var controllerContext = new HttpControllerContext(httpConfiguration, routeData, request) { ControllerDescriptor = controllerDescriptor }; var actionContext = new HttpActionContext(controllerContext, mockActionDescriptor.Object); mockCommandPublisher.Setup(publisher => publisher.TryPublishAsync(It.IsAny <ProcessOrder>(), It.IsAny <Instant?>())) .ReturnsAsync(true); mockActionDescriptor.SetupGet(descriptor => descriptor.ActionName).Returns("someAction"); request.SetConfiguration(httpConfiguration); request.SetRouteData(routeData); var controller = new OrderSubmissionController(Mock.Of <IClock>(), mockCommandPublisher.Object, Mock.Of <IEventPublisher <EventBase> >(), Mock.Of <ILogger>(), new OrderSubmissionControllerConfiguration { OrderAcceptedRetryAfterInSeconds = 5 }) { ControllerContext = controllerContext }; var order = new OrderFulfillmentMessage { OrderRequestHeader = new OrderHeader { OrderId = "ABC123", OrderDate = new DateTime(2017, 12, 09, 09, 00, 00, DateTimeKind.Utc) }, LineItems = new List <LineItem>() }; var actionResult = await controller.FulfillOrderWebHook("SQUIRE", order); var result = await actionResult.ExecuteAsync(CancellationToken.None); result.Should().NotBeNull("because a result should have been returned"); result.StatusCode.Should().Be(HttpStatusCode.Accepted, "because the request was valid"); result.Headers.RetryAfter.Should().NotBeNull("because a RETRY-AFTER header should be specified for an Accepted result"); result.TryGetContentValue <OrderFulfillmentAccepted>(out var response).Should().BeTrue("because the response should have been set"); response.FulfillerData.OrderId.Should().Be(order.OrderRequestHeader.OrderId, "because the correct order should have been acknoledged"); }
public async Task FulfillOrderWebHookWithAPriviledgedUserAcceptsTestData() { var mockCommandPublisher = new Mock <ICommandPublisher <ProcessOrder> >(); var mockActionDescriptor = new Mock <HttpActionDescriptor>(); var httpConfiguration = new HttpConfiguration(); var routeData = new HttpRouteData(new HttpRoute()); var request = new HttpRequestMessage(); var controllerDescriptor = new HttpControllerDescriptor { Configuration = httpConfiguration, ControllerName = nameof(OrderSubmissionController) }; var controllerContext = new HttpControllerContext(httpConfiguration, routeData, request) { ControllerDescriptor = controllerDescriptor }; var actionContext = new HttpActionContext(controllerContext, mockActionDescriptor.Object); var priviledgedIdentity = new ClaimsIdentity(new Claim[] { new Claim(CustomClaimTypes.MayAccessPriviledgedOperations, "true") }); mockCommandPublisher.Setup(publisher => publisher.TryPublishAsync(It.IsAny <ProcessOrder>(), It.IsAny <Instant?>())) .ReturnsAsync(true); mockActionDescriptor.SetupGet(descriptor => descriptor.ActionName).Returns("someAction"); actionContext.RequestContext.Principal = new ClaimsPrincipal(priviledgedIdentity); request.SetConfiguration(httpConfiguration); request.SetRouteData(routeData); var controller = new OrderSubmissionController(Mock.Of <IClock>(), mockCommandPublisher.Object, Mock.Of <IEventPublisher <EventBase> >(), Mock.Of <ILogger>(), new OrderSubmissionControllerConfiguration()) { ControllerContext = controllerContext }; var order = new OrderFulfillmentMessage { OrderRequestHeader = new OrderHeader { OrderId = "ABC123", OrderDate = new DateTime(2017, 12, 09, 09, 00, 00, DateTimeKind.Utc) }, LineItems = new List <LineItem>(), Emulation = new DependencyEmulation() }; var actionResult = await controller.FulfillOrderWebHook("SQUIRE", order); var result = await actionResult.ExecuteAsync(CancellationToken.None); result.Should().NotBeNull("because a result should have been returned"); result.StatusCode.Should().Be(HttpStatusCode.Accepted, "because the request was valid"); }
public async Task FulfillOrderWebHookWithNonPriviledgedUserIsRejectedWhenSupplyingTestData() { var mockActionDescriptor = new Mock <HttpActionDescriptor>(); var httpConfiguration = new HttpConfiguration(); var routeData = new HttpRouteData(new HttpRoute()); var request = new HttpRequestMessage(); var controllerDescriptor = new HttpControllerDescriptor { Configuration = httpConfiguration, ControllerName = nameof(OrderSubmissionController) }; var controllerContext = new HttpControllerContext(httpConfiguration, routeData, request) { ControllerDescriptor = controllerDescriptor }; var actionContext = new HttpActionContext(controllerContext, mockActionDescriptor.Object); var unpriviledgedIdentity = new ClaimsIdentity(new Claim[] { new Claim(CustomClaimTypes.IdentityType, "UnitTest") }); mockActionDescriptor.SetupGet(descriptor => descriptor.ActionName).Returns("someAction"); actionContext.RequestContext.Principal = new ClaimsPrincipal(unpriviledgedIdentity); request.SetConfiguration(httpConfiguration); request.SetRouteData(routeData); var controller = new OrderSubmissionController(Mock.Of <IClock>(), Mock.Of <ICommandPublisher <ProcessOrder> >(), Mock.Of <IEventPublisher <EventBase> >(), Mock.Of <ILogger>(), new OrderSubmissionControllerConfiguration()) { ControllerContext = controllerContext }; var order = new OrderFulfillmentMessage { OrderRequestHeader = new OrderHeader { OrderId = "ABC123", OrderDate = new DateTime(2017, 12, 09, 09, 00, 00, DateTimeKind.Utc) }, LineItems = new List <LineItem>(), Emulation = new DependencyEmulation() }; var actionResult = await controller.FulfillOrderWebHook("SQUIRE", order); var result = await actionResult.ExecuteAsync(CancellationToken.None); result.Should().NotBeNull("because a result should have been returned"); result.StatusCode.Should().Be(HttpStatusCode.Forbidden, "because the request should have been rejected"); var errorSet = await result.Content.ReadAsAsync <ErrorSet>(); errorSet.Should().BeNull("because no errors should be returned when the caller is unpriviledged"); }
public async Task FulfillOrderWebHookWithNullOrderLogs() { var mockLogger = new Mock <ILogger>(); var mockActionDescriptor = new Mock <HttpActionDescriptor>(); var httpConfiguration = new HttpConfiguration(); var routeData = new HttpRouteData(new HttpRoute()); var request = new HttpRequestMessage(); var controllerDescriptor = new HttpControllerDescriptor { Configuration = httpConfiguration, ControllerName = nameof(OrderSubmissionController) }; var controllerContext = new HttpControllerContext(httpConfiguration, routeData, request) { ControllerDescriptor = controllerDescriptor }; var actionContext = new HttpActionContext(controllerContext, mockActionDescriptor.Object); mockActionDescriptor.SetupGet(descriptor => descriptor.ActionName).Returns("someAction"); request.SetConfiguration(httpConfiguration); request.SetRouteData(routeData); mockLogger.Setup(log => log.ForContext(It.IsAny <string>(), It.IsAny <object>(), It.IsAny <bool>())) .Returns(mockLogger.Object); var controller = new OrderSubmissionController(Mock.Of <IClock>(), Mock.Of <ICommandPublisher <ProcessOrder> >(), Mock.Of <IEventPublisher <EventBase> >(), mockLogger.Object, new OrderSubmissionControllerConfiguration()) { ControllerContext = controllerContext }; var partner = "SQUIRE"; var actionResult = await controller.FulfillOrderWebHook(partner, null); mockLogger.Verify(logger => logger.Information(It.IsAny <string>(), It.Is <HttpStatusCode>(code => code == HttpStatusCode.BadRequest), It.Is <string>(name => name == nameof(OrderSubmissionController)), It.Is <string>(method => method == nameof(OrderSubmissionController.FulfillOrderWebHook)), It.Is <string>(partnerName => partnerName == partner), It.IsAny <HttpRequestHeaders>(), It.IsAny <string>(), It.IsAny <ErrorSet>()), Times.Once, "The failure should be logged"); }
public async Task FulfillOrderWebHookWithNullOrderIsRejected() { var mockActionDescriptor = new Mock <HttpActionDescriptor>(); var httpConfiguration = new HttpConfiguration(); var routeData = new HttpRouteData(new HttpRoute()); var request = new HttpRequestMessage(); var controllerDescriptor = new HttpControllerDescriptor { Configuration = httpConfiguration, ControllerName = nameof(OrderSubmissionController) }; var controllerContext = new HttpControllerContext(httpConfiguration, routeData, request) { ControllerDescriptor = controllerDescriptor }; var actionContext = new HttpActionContext(controllerContext, mockActionDescriptor.Object); mockActionDescriptor.SetupGet(descriptor => descriptor.ActionName).Returns("someAction"); request.SetConfiguration(httpConfiguration); request.SetRouteData(routeData); var controller = new OrderSubmissionController(Mock.Of <IClock>(), Mock.Of <ICommandPublisher <ProcessOrder> >(), Mock.Of <IEventPublisher <EventBase> >(), Mock.Of <ILogger>(), new OrderSubmissionControllerConfiguration()) { ControllerContext = controllerContext }; var actionResult = await controller.FulfillOrderWebHook("PLACE-ORDER", null); var result = await actionResult.ExecuteAsync(CancellationToken.None); result.Should().NotBeNull("because a result should have been returned"); result.StatusCode.Should().Be(HttpStatusCode.BadRequest, "because the request should have been rejected"); var errorSet = await result.Content.ReadAsAsync <ErrorSet>(); errorSet.Should().NotBeNull("because a set of errors should have been returned"); errorSet.Errors.Should().ContainSingle(error => error.MemberPath == "order", "because the order was invalid"); }
public async Task FulfillOrderWebHookAllowsNonUrlAssetsForAnAcceptedOrder() { var mockLogger = new Mock <ILogger>(); var mockCommandPublisher = new Mock <ICommandPublisher <ProcessOrder> >(); var mockActionDescriptor = new Mock <HttpActionDescriptor>(); var httpConfiguration = new HttpConfiguration(); var routeData = new HttpRouteData(new HttpRoute()); var request = new HttpRequestMessage(); var controllerDescriptor = new HttpControllerDescriptor { Configuration = httpConfiguration, ControllerName = nameof(OrderSubmissionController) }; var controllerContext = new HttpControllerContext(httpConfiguration, routeData, request) { ControllerDescriptor = controllerDescriptor }; var actionContext = new HttpActionContext(controllerContext, mockActionDescriptor.Object); var publishedCommand = default(ProcessOrder); mockLogger.Setup(log => log.ForContext(It.IsAny <string>(), It.IsAny <object>(), It.IsAny <bool>())) .Returns(mockLogger.Object); mockCommandPublisher .Setup(publisher => publisher.TryPublishAsync(It.IsAny <ProcessOrder>(), It.IsAny <Instant?>())) .ReturnsAsync(true) .Callback <ProcessOrder, Instant?>((command, publishTime) => publishedCommand = command); mockActionDescriptor.SetupGet(descriptor => descriptor.ActionName).Returns("someAction"); request.SetConfiguration(httpConfiguration); request.SetRouteData(routeData); var controller = new OrderSubmissionController(Mock.Of <IClock>(), mockCommandPublisher.Object, Mock.Of <IEventPublisher <EventBase> >(), mockLogger.Object, new OrderSubmissionControllerConfiguration { OrderAcceptedRetryAfterInSeconds = 5 }) { ControllerContext = controllerContext }; var order = new OrderFulfillmentMessage { OrderRequestHeader = new OrderHeader { OrderId = "ABC123", OrderDate = new DateTime(2017, 12, 09, 09, 00, 00, DateTimeKind.Utc) }, LineItems = new List <LineItem> { { new LineItem { Assets = new List <ItemAsset> { { new ItemAsset { Name = "one", Location = "Not a url" } } } } } } }; var actionResult = await controller.FulfillOrderWebHook("SQUIRE", order); var result = await actionResult.ExecuteAsync(CancellationToken.None); result.Should().NotBeNull("because a result should have been returned"); publishedCommand.Should().NotBeNull("because the command should have been published"); foreach (var item in order.LineItems) { var asset = item.Assets.Single(); var commandAsset = publishedCommand.Assets[asset.Name]; commandAsset.Should().NotBeNull("because an asset for asset {0} should be present", asset.Name); commandAsset.Should().Be(asset.Location, "because the asset value should be unchanged for asset {0}", asset.Name); } }
public async Task FulfillOrderWebHookForcesAssetUrlsToHttpsForAnAcceptedOrder() { var mockLogger = new Mock <ILogger>(); var mockCommandPublisher = new Mock <ICommandPublisher <ProcessOrder> >(); var mockActionDescriptor = new Mock <HttpActionDescriptor>(); var httpConfiguration = new HttpConfiguration(); var routeData = new HttpRouteData(new HttpRoute()); var request = new HttpRequestMessage(); var controllerDescriptor = new HttpControllerDescriptor { Configuration = httpConfiguration, ControllerName = nameof(OrderSubmissionController) }; var controllerContext = new HttpControllerContext(httpConfiguration, routeData, request) { ControllerDescriptor = controllerDescriptor }; var actionContext = new HttpActionContext(controllerContext, mockActionDescriptor.Object); var publishedCommand = default(ProcessOrder); mockLogger.Setup(log => log.ForContext(It.IsAny <string>(), It.IsAny <object>(), It.IsAny <bool>())) .Returns(mockLogger.Object); mockCommandPublisher .Setup(publisher => publisher.TryPublishAsync(It.IsAny <ProcessOrder>(), It.IsAny <Instant?>())) .ReturnsAsync(true) .Callback <ProcessOrder, Instant?>((command, publishTime) => publishedCommand = command); mockActionDescriptor.SetupGet(descriptor => descriptor.ActionName).Returns("someAction"); request.SetConfiguration(httpConfiguration); request.SetRouteData(routeData); var controller = new OrderSubmissionController(Mock.Of <IClock>(), mockCommandPublisher.Object, Mock.Of <IEventPublisher <EventBase> >(), mockLogger.Object, new OrderSubmissionControllerConfiguration { OrderAcceptedRetryAfterInSeconds = 5 }) { ControllerContext = controllerContext }; var order = new OrderFulfillmentMessage { OrderRequestHeader = new OrderHeader { OrderId = "ABC123", OrderDate = new DateTime(2017, 12, 09, 09, 00, 00, DateTimeKind.Utc) }, LineItems = new List <LineItem> { { new LineItem { Assets = new List <ItemAsset> { { new ItemAsset { Name = "one", Location = "https://www.bob.com/path" } } } } }, { new LineItem { Assets = new List <ItemAsset> { { new ItemAsset { Name = "two", Location = "https://www.john.com:443/path/?name=john" } } } } }, { new LineItem { Assets = new List <ItemAsset> { { new ItemAsset { Name = "three", Location = "gopher://www.frank.com:8086/path" } } } } } } }; var actionResult = await controller.FulfillOrderWebHook("SQUIRE", order); var result = await actionResult.ExecuteAsync(CancellationToken.None); result.Should().NotBeNull("because a result should have been returned"); publishedCommand.Should().NotBeNull("because the command should have been published"); foreach (var item in order.LineItems) { var asset = item.Assets.Single(); var commandAsset = publishedCommand.Assets[asset.Name]; asset.Should().NotBeNull("because an asset for asset {0} should be present", asset.Name); var assetUri = new Uri(asset.Location); var commandAssetUri = new Uri(commandAsset); commandAssetUri.Scheme.Should().Be(Uri.UriSchemeHttps, "because the uri scheme should have been forced to HTTPS for asset {0}", asset.Name); commandAssetUri.Host.Should().Be(assetUri.Host, "because the authorities should match for asset {0}", asset.Name); commandAssetUri.PathAndQuery.Should().Be(assetUri.PathAndQuery, "because the path and querystring should match for asset {0}", asset.Name); if (assetUri.IsDefaultPort) { commandAssetUri.Port.Should().Be(443, "because the default port was used for asset {0}", asset.Name); } else { commandAssetUri.Port.Should().Be(assetUri.Port, "because a non-default port was used for asset {0}", asset.Name); } } }