public void ThrowsAnExceptionWhenTheConsumerIsNull()
        {
            resolver.Setup(o => o.Resolve(context)).Returns((IConsumer <object>)null);

            var target = new StubDefaultConsumerExecutionStrategy <object>(resolver.Object);

            Assert.ThrowsAsync <InvalidOperationException>(async() => await target.ExecuteAsync(context));
        }
        public void ThrowsExceptionWhenContextIsNull1()
        {
            var target = new StubDefaultConsumerExecutionStrategy <object>(resolver.Object);

            target.SetOverrideContext(null);

            Assert.ThrowsAsync <ArgumentNullException>(async() => await target.ExecuteAsync(context));
        }
        public void ReleasesTheProcessingContextWhenFailsToCreateConsumer()
        {
            resolver.Setup(o => o.Resolve(context)).Throws <InvalidOperationException>();

            var target = new StubDefaultConsumerExecutionStrategy <object>(resolver.Object, onExitCallback: (strategy, context) => {
                Assert.IsNull(ProcessingContext.Current);
            });

            Assert.ThrowsAsync <InvalidOperationException>(async() => await target.ExecuteAsync(context));
        }
        public async Task ExecutesAllExtensionMethodsInOrderAsExpected()
        {
            bool called1 = false, called2 = false, called3 = false, called4 = false;

            var target = new StubDefaultConsumerExecutionStrategy <object>(resolver.Object,
                                                                           (strategy, context) =>
            {
                called1 = true;

                Assert.IsFalse(called2);
                Assert.IsFalse(called3);
                Assert.IsFalse(called4);
            },
                                                                           (strategy, context) =>
            {
                called2 = true;

                Assert.IsTrue(called1);
                Assert.IsFalse(called3);
                Assert.IsFalse(called4);
            },
                                                                           (strategy, context) =>
            {
                called3 = true;

                Assert.IsTrue(called1);
                Assert.IsTrue(called2);
                Assert.IsFalse(called4);
            },
                                                                           (strategy, context) =>
            {
                called4 = true;

                Assert.IsTrue(called1);
                Assert.IsTrue(called2);
                Assert.IsTrue(called3);
            });

            await target.ExecuteAsync(context);

            Assert.True(called1);
            Assert.True(called2);
            Assert.True(called3);
            Assert.True(called4);
        }