コード例 #1
0
        public async Task InvokeAsync_NonSpecialExceptionIsThrown_OriginalMessageShouldBeSentToTheDeadLetterQueue()
        {
            //prepare
            var    originalSubscriptionMock      = new Mock <ISubscription>();
            var    publisherMock                 = new Mock <IPublisher>();
            string subscriberDeadLetterQueueName = "deadletter.subscriber";
            var    argumentException             = new ArgumentException();

            originalSubscriptionMock.Setup(x => x.InvokeAsync(_serializedMessage)).Returns <string>(
                (msg) =>
            {
                return(Task.FromException(argumentException));
            });

            //act
            DeadLetterSubscriptionWrapper actor = new DeadLetterSubscriptionWrapper(originalSubscriptionMock.Object,
                                                                                    publisherMock.Object, subscriberDeadLetterQueueName);

            await actor.InvokeAsync(_serializedMessage);

            //check
            originalSubscriptionMock.Verify(x => x.NotifyAboutDeadLetterAsync(It.IsAny <string>(), It.IsAny <Exception>()), Times.Never);
            IntegrationEvent <DeadLetterEventDescriptor <JObject> > integrationEvent =
                JsonConvert.DeserializeObject <IntegrationEvent <DeadLetterEventDescriptor <JObject> > >(_serializedMessage);

            publisherMock.Verify(x => x.PublishDirectEventAsync(It.Is <IntegrationEvent <DeadLetterEventDescriptor <JObject> > >(actualevent => actualevent.CorrelationId == integrationEvent.CorrelationId),
                                                                subscriberDeadLetterQueueName, true), Times.Once);
        }
コード例 #2
0
        public void InvokeAsync_SpecialExceptionIsThrown_ExceptionShouldBePropogated(Type exceptionType)
        {
            //prepare
            var    originalSubscriptionMock = new Mock <ISubscription>();
            var    publisherMock            = new Mock <IPublisher>();
            string message = "justMessage";

            originalSubscriptionMock.Setup(x => x.InvokeAsync(message)).Returns <string>(
                (msg) =>
            {
                return(Task.FromException((Exception)Activator.CreateInstance(exceptionType)));
            });

            //act
            DeadLetterSubscriptionWrapper actor = new DeadLetterSubscriptionWrapper(originalSubscriptionMock.Object, publisherMock.Object, null);
            Func <Task> f = async() =>
            {
                await actor.InvokeAsync(message);
            };

            //check
            f.ShouldThrow <Exception>();
            originalSubscriptionMock.Verify(x => x.NotifyAboutDeadLetterAsync(It.IsAny <string>(), It.IsAny <Exception>()), Times.Never);
            publisherMock.Verify(x => x.PublishDirectEventAsync(It.IsAny <IntegrationEvent <DeadLetterEventDescriptor <JObject> > >(),
                                                                It.IsAny <string>(), It.IsAny <bool>()), Times.Never);
        }