public async Task NoProfileToProcessNoProcessingOccurs()
        {
            A.CallTo(() => _domainTlsSecurityProfileDao.GetSecurityProfilesForUpdate()).Returns(Task.FromResult(new List <DomainTlsSecurityProfile>()));

            await _mxSecurityTesterProcessor.Process();

            A.CallTo(() => _domainTlsSecurityProfileDao.GetSecurityProfilesForUpdate()).MustHaveHappened(Repeated.Exactly.Once);
            A.CallTo(() => _certsSecurityProfileUpdater.UpdateSecurityProfiles(A <List <DomainTlsSecurityProfile> > ._)).MustNotHaveHappened();
        }
        public async Task MultipleHostsWithMultipleProcessorsAreProcessed()
        {
            A.CallTo(() => _mxSecurityTesterConfig.TlsTesterThreadCount)
            .Returns(2);

            _mxSecurityTesterProcessor = new MxSecurityTesterProcessor(_mxQueueProcessor,
                                                                       _publisher,
                                                                       _mxHostTester,
                                                                       _mxSecurityTesterConfig,
                                                                       _processingFilter,
                                                                       _recentlyProcessedLedger,
                                                                       _log,
                                                                       RunPipelineDelegate);

            var testPending  = CreateMxHostTestPending(1);
            var testPending2 = CreateMxHostTestPending(2);

            List <TlsTestPending> firstHosts = new List <TlsTestPending>
            {
                testPending,
                testPending2
            };

            A.CallTo(() => _mxQueueProcessor.GetMxHosts())
            .Returns(Task.FromResult(firstHosts)).Once()
            .Then
            .Returns(Task.FromResult(new List <TlsTestPending>()));

            A.CallTo(() => _recentlyProcessedLedger.Contains(A <string> ._)).Returns(false);

            A.CallTo(() => _mxQueueProcessor.DeleteMessage(A <string> ._, A <string> ._)).Returns(Task.CompletedTask);

            var testResult = CreateMxHostTestResult();

            A.CallTo(() => _mxHostTester.Test(A <TlsTestPending> ._)).Returns(Task.FromResult(testResult));

            A.CallTo(() => _processingFilter.Reserve(A <string> ._)).Returns(true);

            A.CallTo(() => _publisher.Publish(A <Message> ._, A <string> ._)).Returns(Task.CompletedTask);

            Task process = _mxSecurityTesterProcessor.Process(cancellationTokenSource.Token);

            await _pipelineStartBlock.SendAsync(null);

            cancellationTokenSource.Cancel();

            await process;

            A.CallTo(() => _mxQueueProcessor.GetMxHosts()).MustHaveHappenedOnceExactly();
            A.CallTo(() => _mxHostTester.Test(A <TlsTestPending> ._)).MustHaveHappened(2, Times.Exactly);
            A.CallTo(() => _publisher.Publish(A <Message> ._, A <string> ._)).MustHaveHappened(2, Times.Exactly);
            A.CallTo(() => _mxQueueProcessor.DeleteMessage(A <string> ._, A <string> ._)).MustHaveHappened(2, Times.Exactly);
            A.CallTo(() => _processingFilter.Reserve(A <string> ._)).MustHaveHappened(2, Times.Exactly);
            A.CallTo(() => _processingFilter.ReleaseReservation(A <string> ._)).MustHaveHappened(2, Times.Exactly);
        }
        public async Task NoProfileToProcessNoProcessingOccurs()
        {
            A.CallTo(() => _mxQueueProcessor.GetMxHosts())
            .Returns(Task.FromResult(new List <TlsTestPending>()));

            Task process = _mxSecurityTesterProcessor.Process(cancellationTokenSource.Token);

            await _pipelineStartBlock.SendAsync(null);

            cancellationTokenSource.Cancel();

            await process;

            A.CallTo(() => _mxQueueProcessor.GetMxHosts()).MustHaveHappenedOnceExactly();
            A.CallTo(() => _mxHostTester.Test(A <TlsTestPending> ._)).MustNotHaveHappened();
            A.CallTo(() => _publisher.Publish(A <Message> ._, A <string> ._)).MustNotHaveHappened();
            A.CallTo(() => _mxQueueProcessor.DeleteMessage(A <string> ._, A <string> ._)).MustNotHaveHappened();
            A.CallTo(() => _processingFilter.Reserve(A <string> ._)).MustNotHaveHappened();
            A.CallTo(() => _processingFilter.ReleaseReservation(A <string> ._)).MustNotHaveHappened();
        }