public async Task FailIsNoOpAfterStartCompletedSuccessfully()
        {
            var mockTransportHelper = new Mock <TransportHelper>();
            var mockConnection      = new Mock <IConnection>();

            mockConnection.Setup(p => p.TotalTransportConnectTimeout).Returns(TimeSpan.FromMilliseconds(200));
            mockConnection.Setup(c => c.JsonSerializer).Returns(JsonSerializer.CreateDefault());

            var initHandler = new TransportInitializationHandler(Mock.Of <IHttpClient>(), mockConnection.Object,
                                                                 string.Empty, "fakeTransport", CancellationToken.None, mockTransportHelper.Object);

            var onFailureInvoked = false;

            initHandler.OnFailure += () => onFailureInvoked = true;

            mockTransportHelper.Setup(
                h => h.GetStartResponse(It.IsAny <IHttpClient>(), It.IsAny <IConnection>(),
                                        It.IsAny <string>(), It.IsAny <string>()))
            .Returns <IHttpClient, IConnection, string, string>(
                (httpClient, connection, connectionData, transport) => Task.FromResult("{ \"Response\" : \"started\" }"));

            initHandler.InitReceived();
            Assert.False(initHandler.TryFailStart());
            Assert.False(initHandler.TryFailStart());

            await initHandler.Task;

            Assert.False(onFailureInvoked);
        }
        public async Task StartRequestNotCalledIfTransportAlreadyFailed()
        {
            var mockConnection = new Mock <IConnection>();

            mockConnection.Setup(c => c.TotalTransportConnectTimeout).Returns(TimeSpan.FromSeconds(1));

            var mockTransportHelper = new Mock <TransportHelper>();
            var failureInvokedTcs   = new TaskCompletionSource <object>();

            var initHandler = new TransportInitializationHandler(Mock.Of <IHttpClient>(), mockConnection.Object,
                                                                 string.Empty, "fakeTransport", CancellationToken.None, mockTransportHelper.Object);

            initHandler.OnFailure += () => failureInvokedTcs.TrySetResult(null);

            Assert.True(initHandler.TryFailStart());
            Assert.True(initHandler.TryFailStart());

            await failureInvokedTcs.Task.OrTimeout();

            initHandler.InitReceived();

            mockTransportHelper.Verify(
                h => h.GetStartResponse(It.IsAny <IHttpClient>(), It.IsAny <IConnection>(),
                                        It.IsAny <string>(), It.IsAny <string>()), Times.Never());
        }
        public async Task InitTaskIsFailedIfFailureOccursAfterStartRequestStarted()
        {
            var mockTransportHelper = new Mock <TransportHelper>();
            var mockConnection      = new Mock <IConnection>();

            mockConnection.Setup(p => p.TotalTransportConnectTimeout).Returns(TimeSpan.FromSeconds(0.5));
            mockConnection.Setup(c => c.JsonSerializer).Returns(JsonSerializer.CreateDefault());

            var initHandler = new TransportInitializationHandler(Mock.Of <IHttpClient>(), mockConnection.Object,
                                                                 string.Empty, "fakeTransport", CancellationToken.None, mockTransportHelper.Object);

            var onFailureInvoked = false;

            initHandler.OnFailure += () => onFailureInvoked = true;

            var exception = new Exception("test exception");

            mockTransportHelper.Setup(
                h => h.GetStartResponse(It.IsAny <IHttpClient>(), It.IsAny <IConnection>(),
                                        It.IsAny <string>(), It.IsAny <string>()))
            .Returns <IHttpClient, IConnection, string, string>(
                (httpClient, connection, connectionData, transport) =>
            {
                initHandler.TryFailStart(exception);
                return(Task.FromResult("{ \"Response\" : \"started\" }"));
            });

            initHandler.InitReceived();

            var startException = await Assert.ThrowsAsync <StartException>(() => initHandler.Task);

            Assert.Same(exception, startException.InnerException);

            Assert.True(onFailureInvoked);
        }