public void SendingOpenSessionsIsAbortedImmediatelyWhenTooManyRequestsResponseIsReceived()
        {
            //given
            const int sleepTime      = 987654;
            var       statusResponse = Substitute.For <IStatusResponse>();

            statusResponse.ResponseCode.Returns(StatusResponse.HttpTooManyRequests);
            statusResponse.IsErroneousResponse.Returns(true);
            statusResponse.GetRetryAfterInMilliseconds().Returns(sleepTime);

            mockSession1Open.SendBeacon(Arg.Any <IHttpClientProvider>(), Arg.Any <IAdditionalQueryParameters>())
            .Returns(statusResponse);
            mockSession1Open.IsDataSendingAllowed.Returns(true);
            mockSession2Open.SendBeacon(Arg.Any <IHttpClientProvider>(), Arg.Any <IAdditionalQueryParameters>())
            .Returns(statusResponse);
            mockSession2Open.IsDataSendingAllowed.Returns(true);

            BeaconSendingCaptureOffState capturedState = null;

            mockContext.NextState = Arg.Do <BeaconSendingCaptureOffState>(x => capturedState = x);

            var target = new BeaconSendingCaptureOnState();

            // when
            target.Execute(mockContext);

            // then
            mockSession1Open.Received(1).SendBeacon(Arg.Any <IHttpClientProvider>(), mockContext);
            _ = mockSession1Open.Received(1).IsDataSendingAllowed;

            Assert.That(mockSession2Open.ReceivedCalls(), Is.Empty);

            Assert.That(capturedState, Is.Not.Null);
            Assert.That(capturedState.SleepTimeInMilliseconds, Is.EqualTo(sleepTime));
        }
        public void ABeaconSendingCaptureOnStateSendsFinishedSessions()
        {
            // given
            var target = new BeaconSendingCaptureOnState();

            var statusResponse = Substitute.For <IStatusResponse>();

            statusResponse.ResponseCode.Returns(StatusResponse.HttpOk);
            statusResponse.IsErroneousResponse.Returns(false);

            mockSession3Finished.SendBeacon(Arg.Any <IHttpClientProvider>(), Arg.Any <IAdditionalQueryParameters>())
            .Returns(statusResponse);
            mockSession3Finished.IsDataSendingAllowed.Returns(true);
            mockSession4Finished.SendBeacon(Arg.Any <IHttpClientProvider>(), Arg.Any <IAdditionalQueryParameters>())
            .Returns(statusResponse);
            mockSession4Finished.IsDataSendingAllowed.Returns(true);

            // when
            target.Execute(mockContext);

            // then
            mockSession3Finished.Received(1).SendBeacon(Arg.Any <IHttpClientProvider>(), mockContext);
            mockSession4Finished.Received(1).SendBeacon(Arg.Any <IHttpClientProvider>(), mockContext);

            // also verify that the sessions are removed
            mockContext.Received(1).RemoveSession(mockSession3Finished);
            mockContext.Received(1).RemoveSession(mockSession4Finished);
        }
        public void ABeaconSendingFlushSessionStateStopsSendingIfTooManyRequestsResponseWasReceived()
        {
            // given
            var target = new BeaconSendingFlushSessionsState();

            var response = Substitute.For <IStatusResponse>();

            response.ResponseCode.Returns(StatusResponse.HttpTooManyRequests);
            response.IsErroneousResponse.Returns(true);
            mockSession3Closed.SendBeacon(Arg.Any <IHttpClientProvider>(), Arg.Any <IAdditionalQueryParameters>())
            .Returns(response);

            // when
            target.Execute(mockContext);

            // then
            mockSession3Closed.Received(1).SendBeacon(Arg.Any <IHttpClientProvider>(), mockContext);
            mockSession3Closed.Received(1).ClearCapturedData();

            mockSession1Open.Received(0)
            .SendBeacon(Arg.Any <IHttpClientProvider>(), Arg.Any <IAdditionalQueryParameters>());
            mockSession1Open.Received(1).ClearCapturedData();

            mockSession2Open.Received(0)
            .SendBeacon(Arg.Any <IHttpClientProvider>(), Arg.Any <IAdditionalQueryParameters>());
            mockSession2Open.Received(1).ClearCapturedData();
        }
        public void SetUp()
        {
            mockSession1Open     = Substitute.For <ISessionInternals>();
            mockSession2Open     = Substitute.For <ISessionInternals>();
            mockSession3Finished = Substitute.For <ISessionInternals>();
            mockSession4Finished = Substitute.For <ISessionInternals>();
            mockSession5New      = Substitute.For <ISessionInternals>();
            mockSession6New      = Substitute.For <ISessionInternals>();

            mockLogger = Substitute.For <ILogger>();

            var okResponse = Substitute.For <IStatusResponse>();

            okResponse.ResponseCode.Returns(StatusResponse.HttpOk);
            okResponse.IsErroneousResponse.Returns(false);

            var errorResponse = Substitute.For <IStatusResponse>();

            errorResponse.ResponseCode.Returns(404);
            errorResponse.IsErroneousResponse.Returns(true);

            mockSession1Open.IsDataSendingAllowed.Returns(true);
            mockSession1Open.SendBeacon(Arg.Any <IHttpClientProvider>(), Arg.Any <IAdditionalQueryParameters>())
            .Returns(okResponse);
            mockSession2Open.SendBeacon(Arg.Any <IHttpClientProvider>(), Arg.Any <IAdditionalQueryParameters>())
            .Returns(errorResponse);

            var mockHttpClientProvider = Substitute.For <IHttpClientProvider>();

            mockContext = Substitute.For <IBeaconSendingContext>();
            mockContext.HttpClientProvider.Returns(mockHttpClientProvider);
            mockContext.CurrentTimestamp.Returns(42);
            mockContext.GetAllNotConfiguredSessions().Returns(new List <ISessionInternals>());
            mockContext.GetAllOpenAndConfiguredSessions().Returns(new List <ISessionInternals>
            {
                mockSession1Open, mockSession2Open
            });
            mockContext.GetAllFinishedAndConfiguredSessions().Returns(new List <ISessionInternals>
            {
                mockSession3Finished, mockSession4Finished
            });
        }
        public void Setup()
        {
            var mockResponse = Substitute.For <IStatusResponse>();

            mockResponse.ResponseCode.Returns(StatusResponse.HttpOk);
            mockResponse.IsErroneousResponse.Returns(false);

            mockSession1Open = Substitute.For <ISessionInternals>();
            mockSession1Open.IsDataSendingAllowed.Returns(true);
            mockSession1Open.SendBeacon(Arg.Any <IHttpClientProvider>(), Arg.Any <IAdditionalQueryParameters>())
            .Returns(mockResponse);

            mockSession2Open = Substitute.For <ISessionInternals>();
            mockSession2Open.IsDataSendingAllowed.Returns(true);
            mockSession2Open.SendBeacon(Arg.Any <IHttpClientProvider>(), Arg.Any <IAdditionalQueryParameters>())
            .Returns(mockResponse);

            mockSession3Closed = Substitute.For <ISessionInternals>();
            mockSession3Closed.IsDataSendingAllowed.Returns(true);
            mockSession3Closed.SendBeacon(Arg.Any <IHttpClientProvider>(), Arg.Any <IAdditionalQueryParameters>())
            .Returns(mockResponse);

            var mockHttpClient = Substitute.For <IHttpClient>();

            mockContext = Substitute.For <IBeaconSendingContext>();
            mockContext.GetHttpClient().Returns(mockHttpClient);
            mockContext.GetAllNotConfiguredSessions().Returns(new List <ISessionInternals>());
            mockContext.GetAllOpenAndConfiguredSessions().Returns(new List <ISessionInternals>
            {
                mockSession1Open, mockSession2Open
            });
            mockContext.GetAllFinishedAndConfiguredSessions().Returns(new List <ISessionInternals>
            {
                mockSession3Closed, mockSession2Open, mockSession1Open
            });
        }