public void ConsumerService_StartConsumers_InvalidHost_ThrowsException(string invalidHost)
        {
            IBrokerConfigConsumers config = new Entities.BrokerConfigConsumers
            {
                Host = invalidHost,
            };

            _consumerService = GetConsumerService(config);

            Assert.Throws <ArgumentException>(() => _consumerService.StartConsumers("test", null, TotalConsumers));
        }
예제 #2
0
        public Worker(ILogger <Worker> logger, IRabbitMqConsumerService rabbitConsumerService, IRabbitMqSenderService rabbitSenderService)
        {
            _logger = logger;
            _rabbitConsumerService = rabbitConsumerService;
            _rabbitSenderService   = rabbitSenderService;

            _rabbitConsumerService.ServiceDescription = "Test Service";
            _rabbitConsumerService.ReceiveMessage    += ProcessMessage;
            _rabbitConsumerService.ShutdownConsumer  += ProcessShutdown;

            _rabbitSenderService.ServiceDescription = "Test Service sender";
        }
        public void ConsumerService_ProcessErrors_executesAllErrorDelegates()
        {
            _consumerService = GetConsumerService();

            _consumerService.StartConsumers("test", null, TotalConsumers);

            _rabbitMqHelper.SendMessage(queueName, "error");
            _rabbitMqHelper.SendMessage(queueName, "error");

            Thread.Sleep(100);

            Assert.AreEqual(TotalConsumers, _totalErrors);
        }
        public void ConsumerService_StartConsumers_NamesAreCorrect()
        {
            _consumerService = GetConsumerService();

            _consumerService.StartConsumers("test", null, 2);

            Thread.Sleep(100);

            var startedConsumers = _consumerService.GetConsumerDetails();

            Assert.IsTrue(startedConsumers.Any(y => y.Name == "test_0"));
            Assert.IsTrue(startedConsumers.Any(y => y.Name == "test_1"));
        }
        public void ConsumerService_StopConsumers_oneConsumer_consumerStopConsuming()
        {
            _consumerService = GetConsumerService();

            _consumerService.StartConsumers("test", null, TotalConsumers);

            Thread.Sleep(100);

            Assert.AreEqual(TotalConsumers, _consumerService.GetTotalRunningConsumers);

            _consumerService.StopConsumers("test_0");

            Thread.Sleep(200);

            Assert.AreEqual(1, _consumerService.GetTotalRunningConsumers);
            Assert.AreEqual(TotalConsumers, _consumerService.GetTotalConsumers);
        }
        public void ConsumerService_Dispose_executesAllDisposeDelegates()
        {
            _consumerService = GetConsumerService();

            _consumerService.StartConsumers("test", null, TotalConsumers);

            _rabbitMqHelper.SendMessage(queueName, "message 1");
            _rabbitMqHelper.SendMessage(queueName, "message 2");

            Thread.Sleep(100);

            _consumerService.Dispose();

            Thread.Sleep(2500);

            Assert.AreEqual(TotalConsumers, _totalStopProcessing, $"_totalStopProcessing: {_totalStopProcessing}");
        }
        public void ConsumerService_ReceiveMessage_CreateQueue_queueDoesnt_existYet_receivesAllMessages()
        {
            _consumerService = GetConsumerService();

            _consumerService.StartConsumers("test", otherQueueName, TotalConsumers, true);

            _rabbitMqHelper.SendMessage(otherQueueName, "message 1");
            _rabbitMqHelper.SendMessage(otherQueueName, "message 2");

            Thread.Sleep(100);

            var res = _rabbitMqHelper.CreateQueueOrGetInfo(otherQueueName);
            var totalMessagesInQueue = res.MessageCount;

            Assert.AreEqual(2, _totalMessagesReceived);
            Assert.AreEqual(0, totalMessagesInQueue);
        }
        public void ConsumerService_ProcessMessage_messageIsReceived(string messageType,
                                                                     int expectedMessageInQueueAfterProcessing)
        {
            _consumerService = GetConsumerService();

            _rabbitMqHelper.SendMessage(queueName, messageType);

            _consumerService.StartConsumers("test", null, TotalConsumers);

            Thread.Sleep(100);

            _consumerService.Dispose();

            var res = _rabbitMqHelper.CreateQueueOrGetInfo(queueName);
            var totalMessagesInQueue = res.MessageCount;

            Assert.AreEqual(expectedMessageInQueueAfterProcessing, totalMessagesInQueue);
        }
        public void ConsumerService_StartConsumers_ValidNumberOfConsumers_useDefaultConsumers_returnsOk()
        {
            _consumerService = GetConsumerService();

            _consumerService.StartConsumers("test");

            Thread.Sleep(300);

            var startedConsumers = _consumerService.GetTotalRunningConsumers;
            var totalConsumers   = _consumerService.GetTotalConsumers;

            var res           = _rabbitMqHelper.CreateQueueOrGetInfo(queueName);
            var consumerCount = res.ConsumerCount;

            Assert.AreEqual(DefaultTotalConsumers, startedConsumers);
            Assert.AreEqual(DefaultTotalConsumers, totalConsumers);
            Assert.AreEqual(DefaultTotalConsumers, consumerCount);
        }
        public void ConsumerService_ProcessMessage_WithLimiter_limiterIsCalled()
        {
            const string messageType   = "ok";
            const int    expectedCalls = 1;

            var limiter = new LimiterHelper(Constants.MessageProcessInstruction.OK);

            _consumerService = GetConsumerService();

            _consumerService.Limiter = limiter;

            _rabbitMqHelper.SendMessage(queueName, messageType);

            _consumerService.StartConsumers("test", null, TotalConsumers);

            Thread.Sleep(100);

            _consumerService.Dispose();

            Assert.AreEqual(expectedCalls, limiter.TotalCalls);
        }
        public void ConsumerService_StopConsumers_AllConsumersStopConsuming()
        {
            _consumerService = GetConsumerService();

            _consumerService.StartConsumers("test", null, TotalConsumers);

            Thread.Sleep(100);

            Assert.AreEqual(TotalConsumers, _consumerService.GetTotalRunningConsumers);

            Thread.Sleep(100);

            _consumerService.StopConsumers();

            Thread.Sleep(100);

            var running = _consumerService.GetTotalRunningConsumers;
            var total   = _consumerService.GetTotalConsumers;

            Assert.AreEqual(0, running);
            Assert.AreEqual(TotalConsumers, total);
        }
예제 #12
0
        public ConsoleApp(ILogger <ConsoleApp> logger, IRabbitMqConsumerService consumerService, IRabbitMqSenderService senderService, IRabbitMqSenderServiceKeepConnection senderServiceKeepConnection,
                          ILimiter limiter, AppConfig config)
        {
            _logger = logger;

            _consumerService             = consumerService;
            _senderService               = senderService;
            _senderServiceKeepConnection = senderServiceKeepConnection;
            _config = config;


            _consumerService.ServiceDescription   = "Consumer Service";
            _consumerService.ReceiveMessage      += ProcessMessage;
            _consumerService.ShutdownConsumer    += ProcessShutdown;
            _consumerService.ReceiveMessageError += ProcessError;

            _consumerService.Limiter = limiter;

            _consumerService.MaxChannelsPerConnection = 3;

            _senderService.ServiceDescription = "Sender Service";
        }
        public void ConsumerService_StartConsumers_InValidNumberOfConsumers_ThrowsException()
        {
            _consumerService = GetConsumerService();

            Assert.Throws <ArgumentException>(() => _consumerService.StartConsumers("test", null, 0));
        }