Added documentation and removed sequential execution for tests.

Author: Anton Vorontsov

docs/advanced-usage.md

@@ -1,8 +1,8 @@
 # Advanced usage
 
-`IQueueService` is an interface that implements two other interfaces - `IConsumingService` and `IProducingService`. By default a RabbitMQ Client is registered as `IQueueService` without a logical separation at producing and consuming code. Thus, you can inject only a `IQueueService` instance, and `IConsumingService` or `IProducingService` won't be available. This is not a real deal until you want to control the way a RabbitMQ Client connects to the server.
+`IQueueService` is an interface that implements two other interfaces - `IConsumingService` and `IProducingService`. By default, a RabbitMQ Client is registered as `IQueueService` without a logical separation at producing and consuming code. Thus, you can inject only a `IQueueService` instance, and `IConsumingService` or `IProducingService` won't be available. This is not a real deal until you want to control the way a RabbitMQ Client connects to the server.
 
-An instance of `IQueueService` opens two connections to the RabbitMQ server, one is for message production and the other one is for message consumption. Normally a RabbitMQ Client is added in a singleton mode, so both connections stay opened while application is running. It is also noticeable that a RabbitMQ Client uses the same credentials for both connections. If you add `IQueueService` in a transient mode (via the `AddRabbitMqClientTransient` extension method) both connections will be opened each time `IQueueService` is being injected somewhere else. This behavior does not fit everybody, so you can change it a little.
+An instance of `IQueueService` opens two connections to the RabbitMQ server, one is for message production, and the other one is for message consumption. Normally a RabbitMQ Client is added in a singleton mode, so both connections stay opened while application is running. It is also noticeable that a RabbitMQ Client uses the same credentials for both connections. If you add `IQueueService` in the transient mode (via the `AddRabbitMqClientTransient` extension method) both connections will be opened each time `IQueueService` is being injected somewhere else. This behavior does not fit everybody, so you can change it a little.
 
 You are allowed to register a RabbitMQ Client as an implementation of two interfaces that have been mentioned before - `IConsumingService` and `IProducingService`. Each interface defines its own connection and its own collection of methods, obviously, for message production and message consumption. You can also use different credentials for different connections, and there is an option `ClientProvidedName` which allows you to create a "named" connection (which will be easier to find in the RabbitMQ management UI). There is also a possibility of registering `IConsumingService` and `IProducingService` in different lifetime modes, in case you want your consumption connection to be persist (singleton `IConsumingService`) and open a connection each time you want to send a message (a transient `IProducingService`). This situation will be covered in code examples below.
 

docs/message-consumption.md

@@ -316,8 +316,8 @@ The message handling process organized as follows:
 
 There are also a feature that you can use in case of necessity of handling messages in batches.
 First of all you have to create a class that inherits a `BatchMessageHandler` class.
-You have to set up values for `QueueName` and `PrefetchCount` properties. These values are responsible for the queue that will be read by the message handler, and the size of batches of messages.
-You have to be aware that batch message handlers do not declare queues, so if it does not exists an exception will be thrown. Either declare manually or using RabbitMqClient configuration features.
+You have to set up values for `QueueName` and `PrefetchCount` properties. These values are responsible for the queue that will be read by the message handler, and the size of batches of messages. You can also set a `MessageHandlingPeriod` property value and the method `HandleMessage` will be executed repeatedly so messages in unfilled batches could be processed too, but keep in mind that this property is optional.
+Be aware that batch message handlers *do not declare queues*, so if it does not exist an exception will be thrown. Either declare manually or using RabbitMqClient configuration features.
 
 ```c#
 public class CustomBatchMessageHandler : BatchMessageHandler
@@ -337,6 +337,8 @@ public class CustomBatchMessageHandler : BatchMessageHandler
 
     public override string QueueName { get; set; } = "another.queue.name";
 
+    public override TimeSpan? MessageHandlingPeriod { get; set; } = TimeSpan.FromMilliseconds(500);
+
     public override Task HandleMessages(IEnumerable<string> messages, CancellationToken cancellationToken)
     {
         _logger.LogInformation("Handling a batch of messages.");

examples/Examples.BatchMessageHandler/AnotherCustomBatchMessageHandler.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
@@ -25,6 +26,9 @@ public AnotherCustomBatchMessageHandler(
         // You have to be aware that BaseBatchMessageHandler does not declare the specified queue. So if it does not exists an exception will be thrown.
         public override string QueueName { get; set; } = "another.queue.name";
 
+        // This thing will fire message handling if there are not enough messages, but timeout is already off.
+        public override TimeSpan? MessageHandlingPeriod { get; set; } = TimeSpan.FromMilliseconds(500);
+
         public override Task HandleMessages(IEnumerable<string> messages, CancellationToken cancellationToken)
         {
             _logger.LogInformation("Handling a batch of messages.");

readme.md

@@ -259,7 +259,9 @@ public class CustomBatchMessageHandler : BatchMessageHandler
 
     public override ushort PrefetchCount { get; set; } = 50;
 
-    public override string QueueName { get; set; } = "another.queue.name";
+    public override string QueueName { get; set; } = "queue.name";
+
+    public override TimeSpan? MessageHandlingPeriod { get; set; } = TimeSpan.FromMilliseconds(500);
 
     public override Task HandleMessages(IEnumerable<string> messages, CancellationToken cancellationToken)
     {
@@ -279,7 +281,7 @@ services.AddBatchMessageHandler<CustomBatchMessageHandler>(Configuration.GetSect
 ```
 
 The message handler will create a separate connection and use it for reading messages.
-When the message collection is full to the size of `PrefetchCount` they are passed to the `HandleMessage` method. For more information, see the [message-consuming](./docs/message-consumption.md) documentation file.
+When the message collection is full to the size of `PrefetchCount` they are passed to the `HandleMessage` method. You can also set a `MessageHandlingPeriod` property value and the method `HandleMessage` will be executed repeatedly so messages in unfilled batches could be processed too. For more information, see the [message-consuming](./docs/message-consumption.md) documentation file.
 
 ## Advanced usage and nuances
 

tests/RabbitMQ.Client.Core.DependencyInjection.Tests/UnitTests/BaseBatchMessageHandlerTests.cs

@@ -14,7 +14,6 @@
 
 namespace RabbitMQ.Client.Core.DependencyInjection.Tests.UnitTests
 {
-    [Collection("Sequential tests")]
     public class BaseBatchMessageHandlerTests
     {
         readonly TimeSpan _globalTestsTimeout = TimeSpan.FromSeconds(60);

tests/RabbitMQ.Client.Core.DependencyInjection.Tests/UnitTests/BatchMessageHandlerTests.cs

@@ -14,7 +14,6 @@
 
 namespace RabbitMQ.Client.Core.DependencyInjection.Tests.UnitTests
 {
-    [Collection("Sequential tests")]
     public class BatchMessageHandlerTests
     {
         readonly TimeSpan _globalTestsTimeout = TimeSpan.FromSeconds(60);