コード例 #1
0
        public async Task ErrorHandler_NoErrors_Success()
        {
            var innerHandler = Substitute.For<IDelegatingHandler>();
            innerHandler.OpenAsync(Arg.Is(false)).Returns(TaskConstants.Completed);
            innerHandler.SendEventAsync(Arg.Any<Message>()).Returns(TaskConstants.Completed);
            var sut = new ErrorDelegatingHandler(() => innerHandler);

            //emulate Gatekeeper behaviour: it opens the channel for us
            await sut.OpenAsync(false);
            await sut.SendEventAsync(new Message(new byte[0]));

            await innerHandler.Received(1).OpenAsync(Arg.Is(false));
            await innerHandler.Received(1).SendEventAsync(Arg.Any<Message>());
        }
コード例 #2
0
        public async Task ErrorHandler_NoErrors_Success()
        {
            var contextMock = Substitute.For<IPipelineContext>();
            var innerHandler = Substitute.For<IDelegatingHandler>();
            innerHandler.OpenAsync(Arg.Any<CancellationToken>()).Returns(Task.CompletedTask);
            innerHandler.SendEventAsync(Arg.Any<Message>(), Arg.Any<CancellationToken>()).Returns(Task.CompletedTask);
            var sut = new ErrorDelegatingHandler(contextMock, innerHandler);

            var cancellationToken = new CancellationToken();
            await sut.OpenAsync(cancellationToken).ConfigureAwait(false);
            await sut.SendEventAsync(new Message(new byte[0]), cancellationToken).ConfigureAwait(false);

            await innerHandler.Received(1).OpenAsync(cancellationToken).ConfigureAwait(false);
            await innerHandler.Received(1).SendEventAsync(Arg.Any<Message>(), cancellationToken).ConfigureAwait(false);
        }
コード例 #3
0
        DeviceClient(IotHubConnectionString iotHubConnectionString, ITransportSettings[] transportSettings)
        {
            this.iotHubConnectionString = iotHubConnectionString;

#if !WINDOWS_UWP
            var innerHandler = new RetryDelegatingHandler(
                new ErrorDelegatingHandler(
                    () => new RoutingDelegatingHandler(this.CreateTransportHandler, iotHubConnectionString, transportSettings)));
#else
            // UWP does not support retry yet. We need to make the underlying Message stream accessible internally on UWP
            // to be sure that either the stream has not been read or it is seekable to safely retry operation
            var innerHandler = new ErrorDelegatingHandler(
                () => new RoutingDelegatingHandler(this.CreateTransportHandler, iotHubConnectionString, transportSettings));
#endif
            this.InnerHandler = new GateKeeperDelegatingHandler(innerHandler);
        }
コード例 #4
0
        static async Task OperationAsync_ExceptionThrownAndThenSucceed_OperationSuccessfullyCompleted(Func <IDelegatingHandler, Task> mockSetup, Func <IDelegatingHandler, Task> act, Func <IDelegatingHandler, Task> assert, Type thrownExceptionType, Type expectedExceptionType, bool reopenExpected)
        {
            int ctorCallCounter = 0;
            var contextMock     = Substitute.For <IPipelineContext>();
            var innerHandler    = Substitute.For <IDelegatingHandler>();

            innerHandler.OpenAsync(Arg.Is(false), Arg.Any <CancellationToken>()).Returns(TaskConstants.Completed);
            var sut = new ErrorDelegatingHandler(contextMock);

            sut.ContinuationFactory = c => {
                ctorCallCounter++;
                return(innerHandler);
            };

            //initial OpenAsync to emulate Gatekeeper behaviour
            var cancellationToken = new CancellationToken();
            await sut.OpenAsync(false, cancellationToken).ConfigureAwait(false);

            //set initial operation result that throws

            bool[] setup = { false };
            mockSetup(innerHandler).Returns(ci =>
            {
                if (setup[0])
                {
                    return(TaskConstants.Completed);
                }
                throw ExceptionFactory[thrownExceptionType]();
            });

            //act
            await((Func <Task>)(() => act(sut))).ExpectedAsync(expectedExceptionType).ConfigureAwait(false);

            //override outcome
            setup[0] = true;//otherwise previosly setup call will happen and throw;
            mockSetup(innerHandler).Returns(TaskConstants.Completed);

            //act
            await act(sut).ConfigureAwait(false);

            //assert
            await innerHandler.Received(reopenExpected? 2 : 1).OpenAsync(Arg.Is(false), Arg.Any <CancellationToken>()).ConfigureAwait(false);

            await assert(innerHandler).ConfigureAwait(false);

            Assert.AreEqual(reopenExpected ? 2 : 1, ctorCallCounter);
        }
コード例 #5
0
        public async Task ErrorHandler_NoErrors_Success()
        {
            var innerHandler = Substitute.For <IDelegatingHandler>();

            innerHandler.OpenAsync(Arg.Is(false)).Returns(TaskConstants.Completed);
            innerHandler.SendEventAsync(Arg.Any <Message>()).Returns(TaskConstants.Completed);
            var sut = new ErrorDelegatingHandler(() => innerHandler);

            //emulate Gatekeeper behaviour: it opens the channel for us
            await sut.OpenAsync(false);

            await sut.SendEventAsync(new Message(new byte[0]));

            await innerHandler.Received(1).OpenAsync(Arg.Is(false));

            await innerHandler.Received(1).SendEventAsync(Arg.Any <Message>());
        }
コード例 #6
0
        static async Task OperationAsync_ExceptionThrownAndThenSucceed_OperationSuccessfullyCompleted(
            Func <IDelegatingHandler, Task <Message> > mockSetup,
            Func <IDelegatingHandler, Task <Message> > act,
            Func <IDelegatingHandler, Task <Message> > assert,
            Type thrownExceptionType,
            Type expectedExceptionType)
        {
            var contextMock  = Substitute.For <IPipelineContext>();
            var innerHandler = Substitute.For <IDelegatingHandler>();
            var sut          = new ErrorDelegatingHandler(contextMock, innerHandler);

            //initial OpenAsync to emulate Gatekeeper behaviour
            var cancellationToken = new CancellationToken();

            innerHandler.OpenAsync(Arg.Any <CancellationToken>()).Returns(Task.CompletedTask);
            await sut.OpenAsync(cancellationToken).ConfigureAwait(false);

            //set initial operation result that throws

            bool[] setup = { false };
            mockSetup(innerHandler).Returns(ci =>
            {
                if (setup[0])
                {
                    return(Task.FromResult(new Message()));
                }
                throw ExceptionFactory[thrownExceptionType]();
            });

            //act
            await((Func <Task>)(() => act(sut))).ExpectedAsync(expectedExceptionType).ConfigureAwait(false);

            //override outcome
            setup[0] = true;//otherwise previosly setup call will happen and throw;
            mockSetup(innerHandler).Returns(new Message());

            //act
            await act(sut).ConfigureAwait(false);

            //assert
            await innerHandler.Received(1).OpenAsync(Arg.Any <CancellationToken>()).ConfigureAwait(false);

            await assert(innerHandler).ConfigureAwait(false);
        }
コード例 #7
0
        public async Task ErrorHandler_NoErrors_Success()
        {
            var contextMock  = Substitute.For <IPipelineContext>();
            var innerHandler = Substitute.For <IDelegatingHandler>();

            innerHandler.OpenAsync(Arg.Is(false), Arg.Any <CancellationToken>()).Returns(TaskConstants.Completed);
            innerHandler.SendEventAsync(Arg.Any <Message>(), Arg.Any <CancellationToken>()).Returns(TaskConstants.Completed);
            var sut = new ErrorDelegatingHandler(contextMock);

            sut.ContinuationFactory = c => innerHandler;

            //emulate Gatekeeper behaviour: it opens the channel for us
            var cancellationToken = new CancellationToken();
            await sut.OpenAsync(false, cancellationToken).ConfigureAwait(false);

            await sut.SendEventAsync(new Message(new byte[0]), cancellationToken).ConfigureAwait(false);

            await innerHandler.Received(1).OpenAsync(Arg.Is(false), cancellationToken).ConfigureAwait(false);

            await innerHandler.Received(1).SendEventAsync(Arg.Any <Message>(), cancellationToken).ConfigureAwait(false);
        }
コード例 #8
0
        static async Task OpenAsync_ExceptionThrownAndThenSucceed_SuccessfullyOpened(Func <IDelegatingHandler, Task> mockSetup, Func <IDelegatingHandler, Task> act, Func <IDelegatingHandler, Task> assert, Type thrownExceptionType, Type expectedExceptionType)
        {
            int ctorCallCounter = 0;
            var contextMock     = Substitute.For <IPipelineContext>();
            var innerHandler    = Substitute.For <IDelegatingHandler>();
            var sut             = new ErrorDelegatingHandler(contextMock);

            sut.ContinuationFactory = c => {
                ctorCallCounter++;
                return(innerHandler);
            };

            //set initial operation result that throws

            bool[] setup = { false };
            mockSetup(innerHandler).Returns(ci =>
            {
                if (setup[0])
                {
                    return(Task.FromResult(Guid.NewGuid()));
                }
                throw ExceptionFactory[thrownExceptionType]();
            });

            //act
            await((Func <Task>)(() => act(sut))).ExpectedAsync(expectedExceptionType).ConfigureAwait(false);

            //override outcome
            setup[0] = true;//otherwise previosly setup call will happen and throw;
            mockSetup(innerHandler).Returns(TaskConstants.Completed);

            //act
            await act(sut).ConfigureAwait(false);

            //assert
            await assert(innerHandler).ConfigureAwait(false);

            Assert.AreEqual(2, ctorCallCounter);
        }
コード例 #9
0
        DeviceClient(IotHubConnectionString iotHubConnectionString, ITransportSettings[] transportSettings)
        {
            this.iotHubConnectionString = iotHubConnectionString;

#if !WINDOWS_UWP
            var innerHandler = new RetryDelegatingHandler(
                new ErrorDelegatingHandler(
                    () => new RoutingDelegatingHandler(this.CreateTransportHandler, iotHubConnectionString, transportSettings)));
#else
            // UWP does not support retry yet. We need to make the underlying Message stream accessible internally on UWP
            // to be sure that either the stream has not been read or it is seekable to safely retry operation
            var innerHandler = new ErrorDelegatingHandler(
                () => new RoutingDelegatingHandler(this.CreateTransportHandler, iotHubConnectionString, transportSettings));
#endif
            this.InnerHandler = new GateKeeperDelegatingHandler(innerHandler);
        }
コード例 #10
0
        static async Task OpenAsync_ExceptionThrownAndThenSucceed_SuccessfullyOpened(Func<IDelegatingHandler, Task> mockSetup, Func<IDelegatingHandler, Task> act, Func<IDelegatingHandler, Task> assert, Type thrownExceptionType, Type expectedExceptionType)
        {
            int ctorCallCounter = 0;
            var innerHandler = Substitute.For<IDelegatingHandler>();
            var sut = new ErrorDelegatingHandler(() =>
            {
                ctorCallCounter++;
                return innerHandler;
            });

            //set initial operation result that throws

            bool[] setup = { false };
            mockSetup(innerHandler).Returns(ci =>
            {
                if (setup[0])
                {
                    return Task.FromResult(Guid.NewGuid());
                }
                throw ExceptionFactory[thrownExceptionType]();
            });

            //act
            await ((Func<Task>)(() => act(sut))).ExpectedAsync(expectedExceptionType);

            //override outcome
            setup[0] = true;//otherwise previosly setup call will happen and throw;
            mockSetup(innerHandler).Returns(TaskConstants.Completed);

            //act
            await act(sut);

            //assert
            await assert(innerHandler);
            Assert.AreEqual(2, ctorCallCounter);
        }
コード例 #11
0
        static async Task OperationAsync_ExceptionThrownAndThenSucceed_OperationSuccessfullyCompleted(Func<IDelegatingHandler, Task> mockSetup, Func<IDelegatingHandler, Task> act, Func<IDelegatingHandler, Task> assert, Type thrownExceptionType, Type expectedExceptionType, bool reopenExpected)
        {
            int ctorCallCounter = 0;
            var innerHandler = Substitute.For<IDelegatingHandler>();
            var sut = new ErrorDelegatingHandler(() =>
            {
                ctorCallCounter++;
                return innerHandler;
            });

            //initial OpenAsync to emulate Gatekeeper behaviour
            innerHandler.OpenAsync(Arg.Is(false)).Returns(TaskConstants.Completed);
            await sut.OpenAsync(false);

            //set initial operation result that throws

            bool[] setup = { false };
            mockSetup(innerHandler).Returns(ci =>
            {
                if (setup[0])
                {
                    return TaskConstants.Completed;
                }
                throw ExceptionFactory[thrownExceptionType]();
            });

            //act
            await ((Func<Task>)(() => act(sut))).ExpectedAsync(expectedExceptionType);

            //override outcome
            setup[0] = true;//otherwise previosly setup call will happen and throw;
            mockSetup(innerHandler).Returns(TaskConstants.Completed);

            //act
            await act(sut);

            //assert
            await innerHandler.Received(reopenExpected ? 2 : 1).OpenAsync(Arg.Is(false));
            await assert(innerHandler);
            Assert.AreEqual(reopenExpected ? 2 : 1, ctorCallCounter);
        }