コード例 #1
0
        public async Task Reply_ShouldInvokeMessageInitializer()
        {
            var context = new TestableMessageHandlerContext();

            await context.Reply<ITestMessage>(m => m.Value = "initialized value");

            Assert.AreEqual("initialized value", context.RepliedMessages[0].Message<ITestMessage>().Value);
        }
コード例 #2
0
        public async Task ForwardCurrentMessageTo_ShouldContainDestinationsInForwardDestinations()
        {
            var context = new TestableMessageHandlerContext();

            await context.ForwardCurrentMessageTo("destination1");
            await context.ForwardCurrentMessageTo("destination2");

            Assert.Contains("destination1", context.ForwardedMessages);
            Assert.Contains("destination2", context.ForwardedMessages);
        }
コード例 #3
0
            public async Task Given()
            {
                message = new OrderPlaced {
                    OrderId = Guid.NewGuid()
                };

                var sut = new OrderPlacedHandler();

                context = new TestableMessageHandlerContext();

                await sut.Handle(message, context);
            }
コード例 #4
0
        public async Task Should_have_passed_through_correct_context()
        {
            var cache = new MessageHandlerRegistry();

            cache.RegisterHandler(typeof(StubHandler));

            var handler        = cache.GetCachedHandlerForMessage <StubMessage>();
            var handlerContext = new TestableMessageHandlerContext();
            await handler.Invoke(new StubMessage(), handlerContext);

            Assert.AreSame(handlerContext, ((StubHandler)handler.Instance).HandlerContext);
        }
コード例 #5
0
        public async Task Send_ShouldContainMessageInSentMessages()
        {
            var context = new TestableMessageHandlerContext();
            var messageInstance = new TestMessage();
            var sendOptions = new SendOptions();

            await context.Send(messageInstance, sendOptions);

            Assert.AreEqual(1, context.SentMessages.Length);
            Assert.AreSame(messageInstance, context.SentMessages[0].Message);
            Assert.AreSame(sendOptions, context.SentMessages[0].Options);
        }
コード例 #6
0
        public async Task SendCachedEvent()
        {
            var handler = new Handlers.P2pReceivedHandler(string.Empty);
            var context = new TestableMessageHandlerContext();

            var workflowId = Guid.NewGuid();
            await handler.PublishP2pCached(context, null, workflowId);

            var publishedMessages = context.PublishedMessages;

            handler.ShouldSatisfyAllConditions(() => publishedMessages.Containing <P2pCached>().Any(t => t.Message.WorkflowId == workflowId && t.Message.InsertedItems == null).ShouldBe(true));
        }
コード例 #7
0
        public async Task Reply_ShouldContainMessageInRepliedMessages()
        {
            var context = new TestableMessageHandlerContext();
            var messageInstance = new TestMessage();
            var publishOptions = new ReplyOptions();

            await context.Reply(messageInstance, publishOptions);

            Assert.AreEqual(1, context.RepliedMessages.Length);
            Assert.AreSame(messageInstance, context.RepliedMessages[0].Message);
            Assert.AreSame(publishOptions, context.RepliedMessages[0].Options);
        }
コード例 #8
0
    public async Task Logging()
    {
        var handler = new MyHandlerWithLogging();
        var context = new TestableMessageHandlerContext();

        await handler.Handle(new MyMessage(), context);

        await Verify(new
        {
            context,
            LogCapture.LogMessages
        });
    }
コード例 #9
0
        IBehaviorContext CreateContext <TContext>(IPipeline <TContext> pipeline) where TContext : IBehaviorContext
        {
            var pipelineCache = new FakePipelineCache();

            pipelineCache.RegisterPipeline(pipeline);

            var context = new TestableMessageHandlerContext();

            context.Builder.Register <IMessageMapper>(() => new MessageMapper());
            context.Extensions.Set <IPipelineCache>(pipelineCache);

            return(context);
        }
        public static T ExpectPublish <T>(this TestableMessageHandlerContext context, Func <T, bool> matching = null) where T : IMessage
        {
            var publishedMessages = GetPublishedMessages(context, matching);

            if (publishedMessages.Count < 1)
            {
                var eventsString = GetPublishedEvents(context);
                eventsString = !string.IsNullOrWhiteSpace(eventsString) ? $"Actual Events published: {eventsString}" : null;
                throw new Exception($"Expected 1 message of type {typeof(T)} but found {publishedMessages.Count}. {eventsString}");
            }

            return(publishedMessages.First());
        }
        public async Task GetNativeMessageCustomization_when_no_customization_should_return_null()
        {
            var testableContext = new TestableMessageHandlerContext();

            var handler = new MyHandlerWithoutCustomization();

            await handler.Handle(new MyMessage(), testableContext);

            var publishedMessage = testableContext.PublishedMessages.Single();
            var customization    = publishedMessage.Options.GetNativeMessageCustomization();

            Assert.IsNull(customization);
        }
コード例 #12
0
        public async Task Should_have_passed_through_correct_message()
        {
            var cache = new MessageHandlerRegistry(new Conventions());

            cache.RegisterHandler(typeof(StubHandler));

            var handler        = cache.GetCachedHandlerForMessage <StubMessage>();
            var stubMessage    = new StubMessage();
            var handlerContext = new TestableMessageHandlerContext();
            await handler.Invoke(stubMessage, handlerContext);

            Assert.AreEqual(stubMessage, ((StubHandler)handler.Instance).HandledMessage);
        }
        private static string GetPublishedEvents(TestableMessageHandlerContext context)
        {
            var eventType = typeof(IEvent);

            return(string.Join(Environment.NewLine,
                               context.PublishedMessages
                               .Select(x => x.Message)
                               .Select(o => o.GetType().GetInterfaces()
                                       .Any(y => eventType.IsAssignableFrom(y))
                        ? o.ToString()
                        : null)
                               .Where(x => !string.IsNullOrWhiteSpace(x))));
        }
コード例 #14
0
    public async Task ShouldReplyWithResponseMessage()
    {
        var handler = new MyReplyingHandler();
        var context = new TestableMessageHandlerContext();

        await handler.Handle(new MyRequest(), context)
        .ConfigureAwait(false);

        var repliedMessages = context.RepliedMessages;

        Assert.AreEqual(1, repliedMessages.Length);
        Assert.IsInstanceOf <MyResponse>(repliedMessages[0].Message);
    }
コード例 #15
0
        public TestableContext()
        {
            _ids = new IdRegistry();
            _ctx = new TestableMessageHandlerContext();

            UoW       = new TestableDomain(_ids);
            App       = new TestableApplication(_ids);
            Processor = new TestableProcessor();

            _ctx.Extensions.Set <UnitOfWork.IDomain>(UoW);
            _ctx.Extensions.Set <UnitOfWork.IApplication>(App);
            _ctx.Extensions.Set <IProcessor>(Processor);
            _ctx.Extensions.Set <IContainer>(new TestableContainer());
        }
コード例 #16
0
        public async Task HandleCreateOrderMessageCorrectly()
        {
            var context = new TestableMessageHandlerContext();
            var message = new CreateOrder
            {
                OrderId = _orderId,
                UserId  = UserId
            };

            await _target.Handle(message, context);

            await _orderHubMessageDispatcher.Received().SendToGroupAsync(UserId, "StatusUpdated",
                                                                         Arg.Is <OrderStatus>(s => s.OrderId == message.OrderId && s.Status == "Pending"));
        }
コード例 #17
0
        public async Task Should_dispatch_edited_message_when_retrying()
        {
            var failedMessageId = Guid.NewGuid().ToString();

            await CreateFailedMessage(failedMessageId);

            var handlerContext = new TestableMessageHandlerContext();
            var message        = CreateEditMessage(failedMessageId);
            await Handler.Handle(message, handlerContext);

            await Handler.Handle(message, handlerContext);

            Assert.AreEqual(2, Dispatcher.DispatchedMessages.Count);
        }
コード例 #18
0
        public async Task HandleOrderBilledMessageCorrectly()
        {
            AssumeSagaCanBeMatched();
            var context = new TestableMessageHandlerContext();
            var message = new OrderBilled
            {
                OrderId = _orderId,
            };

            await _target.Handle(message, context);

            await _orderHubMessageDispatcher.Received().SendToGroupAsync(UserId, "StatusUpdated",
                                                                         Arg.Is <OrderStatus>(s => s.OrderId == message.OrderId && s.Status == "Order Billed"));
        }
コード例 #19
0
        public override void Validate(TestableMessageHandlerContext context)
        {
            if (saga.Completed == expectCompleted)
            {
                return;
            }

            if (saga.Completed)
            {
                Fail("Expected saga to not be completed but the saga was completed.");
            }

            Fail("Expected saga to be completed but the saga was not completed.");
        }
コード例 #20
0
        public async Task Should_dispatch_message_using_incoming_transaction()
        {
            var failedMessage = await CreateFailedMessage();

            var message              = CreateEditMessage(failedMessage.UniqueMessageId);
            var handlerContent       = new TestableMessageHandlerContext();
            var transportTransaction = new TransportTransaction();

            handlerContent.Extensions.Set(transportTransaction);

            await Handler.Handle(message, handlerContent);

            Assert.AreSame(Dispatcher.DispatchedMessages.Single().Item2, transportTransaction);
        }
コード例 #21
0
        public async Task Handle_WhenHandlingCommand_ThenShouldAddMessageIdToDistributedCache(
            [Frozen] Mock <IDistributedCache> distributedCache,
            RunHealthCheckCommandHandler handler,
            RunHealthCheckCommand message,
            TestableMessageHandlerContext context)
        {
            //arrange
            var stringValue = System.Text.Encoding.UTF8.GetBytes("OK");

            //act
            await handler.Handle(message, context);

            //assert
            distributedCache.Verify(c => c.SetAsync(context.MessageId, stringValue, It.IsAny <DistributedCacheEntryOptions>(), It.IsAny <CancellationToken>()), Times.Once, "Cache Method not Called");
        }
コード例 #22
0
    public void Setup()
    {
        saga = new BookingChangePolicy
        {
            Data = new BookingChangePolicyData()
        };
        context = new TestableMessageHandlerContext();

        bookedFlightWasChanged = new BookedFlightWasChanged
        {
            BookingReferenceId = bookingReferenceId,
            FlightNumber       = "UA890",
            ReasonForChange    = "Aircraft type was changed from Boeing 787 to Boeing 777"
        };
    }
コード例 #23
0
    public async Task TestIncomingAttachment()
    {
        //Arrange
        var context = new TestableMessageHandlerContext();
        var handler = new Handler();
        var mockMessageAttachments = new CustomMockMessageAttachments();

        context.InjectAttachmentsInstance(mockMessageAttachments);

        //Act
        await handler.Handle(new MyMessage(), context);

        //Assert
        Assert.True(mockMessageAttachments.GetBytesWasCalled);
    }
        public async Task Shares_state_with_handler_context()
        {
            var handlerContext = new TestableMessageHandlerContext();
            var uniformSession = new TestableUniformSession(handlerContext);
            var handler        = new SendingHandler(uniformSession);

            await handler.Handle(new SomeCommand(), handlerContext);

            Assert.AreEqual(2, uniformSession.PublishedMessages.Length);
            Assert.AreEqual(2, uniformSession.SentMessages.Length);
            Assert.AreEqual(2, handlerContext.PublishedMessages.Length);
            Assert.AreEqual(2, handlerContext.SentMessages.Length);

            Assert.IsTrue(handlerContext.DoNotContinueDispatchingCurrentMessageToHandlersWasCalled);
        }
コード例 #25
0
    public async Task OutgoingAttachments()
    {
        var context = new TestableMessageHandlerContext();
        var handler = new OutgoingAttachmentsHandler();
        await handler.Handle(new AMessage(), context);

        var attachments = context.SentMessages
                          .Single()
                          .Options
                          .Attachments();
        var names = attachments.Names;

        Assert.Single(names);
        Assert.Contains("theName", names);
        Assert.True(attachments.HasPendingAttachments);
    }
コード例 #26
0
        public async Task ExpectTimeoutFails_WithNewTestingFramework()
        {
            var saga = new TestSaga {
                Data = new MySagaData {
                    Id = new Guid("11111111-1111-1111-1111-111111111111")
                }
            };
            var executeOn = 31.January(2019).At(10, 35).AsLocal();

            var context = new TestableMessageHandlerContext();
            await saga.Handle(new StartSagaCommand { Id = new Guid("22222222-2222-2222-2222-222222222222"), ExecutionTime = executeOn }, context).ConfigureAwait(false);

            var sentMessage = context.SentMessages.SingleOrDefault();

            sentMessage.Message <TimeoutData>().Time.Should().Be(executeOn);
        }
コード例 #27
0
    public async Task Logging()
    {
        var handler = new MyHandlerWithLogging();
        var context = new TestableMessageHandlerContext();

        context.Extensions.Set("key", "value");

        await handler.Handle(new(), context);

        await Verify(
            new
        {
            context,
            LogCapture.LogMessages
        });
    }
コード例 #28
0
    public async Task Saga()
    {
        var saga = new MySaga
        {
            Data = new()
        };
        var context = new TestableMessageHandlerContext();

        await saga.Handle(new(), context);

        await Verify(new
        {
            context,
            saga.Data
        });
    }
コード例 #29
0
        public async void Setup()
        {
            var dbContext = new OrderDbContext()
            {
                Orders = Aef.FakeDbSet(orders)
            };

            placedAtDate = DateTime.UtcNow;
            orderId      = new Guid("DE81F6B5-7F29-4AE7-A72B-023F6B58DE72");
            var placeOrderCommand = new PlaceOrderCommand
            {
                OrderId      = orderId,
                OrderNumber  = 100,
                PlacedAtDate = placedAtDate
            };

            var context = new TestableMessageHandlerContext();

            //TODO: Question? How do you test this, since I cannot inject the OrderDbContext into the handler
            //In the handler there is the context.SynchronizedStorageSession.FromCurrentSession() that returns a new OrderDbContext
            //In V5 we did new PlaceOrderCommandHandler(OrderDbContext dbContext); and then we could use the FakeDbSet.
            //Since I could not use Moq to mock the return value of context.SynchronizedStorageSession.FromCurrentSession() since it is an extension method
            //so I created a OrderStorageContext instead
            //Then I realized that U guys have your own TestingFramework that I installed so that I could get a TestableMessageHandlerContext
            //but cannot find a way to set the session.SqlPersistenceSession();

            var orderStorageContextMock = new Mock <IDbContextWrapper <OrderDbContext> >();

            orderStorageContextMock.SetupIgnoreArgs(x => x.GetDbContext(null)).Returns(dbContext);


            handler = new PlaceOrderCommandHandler(orderStorageContextMock.Object);

            try
            {
                await handler.Handle(placeOrderCommand, context)
                .ConfigureAwait(false);

                await dbContext.SaveChangesAsync()
                .ConfigureAwait(false);
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
        }
コード例 #30
0
        public void SetUp()
        {
            _messageHandlerContext = new TestableMessageHandlerContext();
            _mediatorMock          = new Mock <IMediator>();
            _loggerMock            = new Mock <ILog>();

            Fixture.Customize <Account>(x => x.Without(s => s.AccountLegalEntities));

            _mediatorMock.Setup(mock => mock.SendAsync(It.IsAny <GetAllEmployerAccountsRequest>()))
            .ReturnsAsync(new GetAllEmployerAccountsResponse {
                Accounts = new List <Account> {
                    Fixture.Create <Account>()
                }
            });

            _sut = new ProcessPeriodEndPaymentsCommandHandler(_mediatorMock.Object, _loggerMock.Object);
        }
        public async Task Handle_WhenHandlingAddedPayeSchemeEvent_ThenShouldSendUpsertUserCommand(
            TestableMessageHandlerContext context,
            [Frozen] Mock <IMediator> mediator,
            AddedAccountProviderEventHandler handler,
            UpsertedUserEvent message)
        {
            //arrange

            //act
            await handler.Handle(message, context);

            //assert
            mediator.Verify(s => s.Send(It.Is <UpsertUserCommand>(c =>
                                                                  c.Created == message.Created &&
                                                                  c.CorrelationId == message.CorrelationId &&
                                                                  c.UserRef == message.UserRef), It.IsAny <CancellationToken>()));
        }
コード例 #32
0
            public async Task CustomizationHandler()
            {
                var testableContext = new TestableMessageHandlerContext();

                var handler = new MyHandlerUsingCustomizations();

                await handler.Handle(new MyEvent(), testableContext);

                var publishedMessage = testableContext.PublishedMessages.Single();
                var customization    = publishedMessage.Options.GetNativeMessageCustomization(testableContext);

                var nativeMessage = new Message();

                customization(nativeMessage);

                Assert.AreEqual("abc", nativeMessage.Label);
            }
コード例 #33
0
        public async Task HandleTest()
        {
            var handler = new Handlers.P2pWorkflowStartedHandler("Data Source=.;Initial Catalog=PdpDb;Integrated Security=True;");
            var context = new TestableMessageHandlerContext();
            var message = new P2pWorkflowStarted()
            {
                WorkflowId = Guid.NewGuid()
            };
            await handler.Handle(message, context);

            var publishedMessages = context.PublishedMessages;

            handler.ShouldSatisfyAllConditions(() =>
            {
                publishedMessages.Containing <P2pPolled>().Any(t => t.Message.WorkflowId == message.WorkflowId && t.Message.Customers != null).ShouldBe(true);
            });
        }
        public async Task GetNativeMessageCustomization_should_return_customization()
        {
            var testableContext = new TestableMessageHandlerContext();

            var handler = new MyHandlerUsingCustomizations();

            await handler.Handle(new MyMessage(), testableContext);

            var publishedMessage = testableContext.PublishedMessages.Single();
            var customization    = publishedMessage.Options.GetNativeMessageCustomization();

            var nativeMessage = new ServiceBusMessage();

            customization(nativeMessage);

            Assert.AreEqual("abc", nativeMessage.Subject);
        }
コード例 #35
0
        public void HandleCurrentMessageLater_WhenCalled_ShouldIndicateInvocation()
        {
            var context = new TestableMessageHandlerContext();

            context.HandleCurrentMessageLater();

            Assert.IsTrue(context.HandleCurrentMessageLaterWasCalled);
        }
コード例 #36
0
        public void ShouldAllowSettingMessageProperties()
        {
            var context = new TestableMessageHandlerContext();

            context.MessageId = "custom message id";
            context.ReplyToAddress = "custom reply address";
            context.MessageHeaders = new Dictionary<string, string>();
            context.MessageHeaders.Add("custom header", "custom value");
            context.Extensions = new ContextBag();
        }
コード例 #37
0
        public void DoNotContinueDispatchingCurrentMessageToHandlers_WhenNotCalled_ShouldNotIndicateInvocation()
        {
            var context = new TestableMessageHandlerContext();

            Assert.IsFalse(context.DoNotContinueDispatchingCurrentMessageToHandlersWasCalled);
        }