public void SetUp()
        {
            _mxQueueProcessor        = A.Fake <IMxQueueProcessor>();
            _publisher               = A.Fake <IMessagePublisher>();
            _mxHostTester            = A.Fake <ITlsSecurityTesterAdapator>();
            _mxSecurityTesterConfig  = A.Fake <IMxTesterConfig>();
            _processingFilter        = A.Fake <IMxSecurityProcessingFilter>();
            _recentlyProcessedLedger = A.Fake <IRecentlyProcessedLedger>();
            _log = A.Fake <ILogger <MxSecurityTesterProcessor> >();

            A.CallTo(() => _mxSecurityTesterConfig.PublishBatchSize).Returns(1);
            A.CallTo(() => _mxSecurityTesterConfig.PublishBatchFlushIntervalSeconds).Returns(1);
            A.CallTo(() => _mxSecurityTesterConfig.TlsTesterThreadCount).Returns(1);

            cancellationTokenSource     = new CancellationTokenSource();
            cancellationTokenSourceTask = cancellationTokenSource.Token.WhenCanceled();

            _mxSecurityTesterProcessor = new MxSecurityTesterProcessor(_mxQueueProcessor,
                                                                       _publisher,
                                                                       _mxHostTester,
                                                                       _mxSecurityTesterConfig,
                                                                       _processingFilter,
                                                                       _recentlyProcessedLedger,
                                                                       _log,
                                                                       RunPipelineDelegate);
        }
        public void SetUp()
        {
            _domainTlsSecurityProfileDao = A.Fake <IDomainTlsSecurityProfileDao>();
            _certsSecurityProfileUpdater = A.Fake <IPublishingCertsSecurityProfileUpdater>();

            _mxSecurityTesterProcessor = new MxSecurityTesterProcessor(_domainTlsSecurityProfileDao,
                                                                       _certsSecurityProfileUpdater, A.Fake <ILogger>());
        }
        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);
        }