chore:resolve codacy warnings

Author: sergioamribeiro

src/KafkaFlow.Retry.IntegrationTests/Core/Storages/InMemoryAuxiliarStorage.cs

@@ -52,8 +52,6 @@ public static async Task AssertEmptyPartitionKeyCountMessageAsync(T message, int
 
                 await Task.Delay(1000).ConfigureAwait(false);
             } while (numberOfMessages != count);
-
-            Console.WriteLine($"Message {message.Key}:{message.Value} received {count} times");
         }
 
         public static void Clear()

src/KafkaFlow.Retry.IntegrationTests/EmptyPartitionKeyRetryDurableTests.cs

@@ -15,6 +15,7 @@ namespace KafkaFlow.Retry.IntegrationTests
     [Collection("BootstrapperHostCollection")]
     public class EmptyPartitionKeyRetryDurableTests
     {
+        private const int defaultWaitingTimeSeconds = 120;
         private readonly IRepositoryProvider repositoryProvider;
         private readonly IServiceProvider serviceProvider;
 
@@ -33,31 +34,27 @@ public static IEnumerable<object[]> EmptyKeyScenarios()
                 RepositoryType.MongoDb,
                 typeof(IMessageProducer<RetryDurableGuaranteeOrderedConsumptionMongoDbProducer>),
                 typeof(RetryDurableGuaranteeOrderedConsumptionPhysicalStorageAssert),
-                2, //numberOfMessagesToBeProduced
-                1 //numberOfMessagesByEachSameKey
+                3 //numberOfMessagesToBeProduced
             };
             yield return new object[]
             {
                 RepositoryType.SqlServer,
                 typeof(IMessageProducer<RetryDurableGuaranteeOrderedConsumptionSqlServerProducer>),
                 typeof(RetryDurableGuaranteeOrderedConsumptionPhysicalStorageAssert),
-                2,
-                1
+                3
             };
             yield return new object[]
             {
                 RepositoryType.MongoDb,
                 typeof(IMessageProducer<RetryDurableLatestConsumptionMongoDbProducer>),
                 typeof(RetryDurableLatestConsumptionPhysicalStorageAssert),
-                2,
                 1
             };
             yield return new object[]
             {
                 RepositoryType.SqlServer,
                 typeof(IMessageProducer<RetryDurableLatestConsumptionSqlServerProducer>),
                 typeof(RetryDurableLatestConsumptionPhysicalStorageAssert),
-                2,
                 1
             };
         }
@@ -68,12 +65,11 @@ internal async Task EmptyKeyRetryDurableTest(
             RepositoryType repositoryType,
             Type producerType,
             Type physicalStorageType,
-            int numberOfMessagesToBeProduced,
-            int numberOfMessagesByEachSameKey)
+            int numberOfMessagesToBeProduced)
         {
             // Arrange
+            var numberOfMessagesByEachSameKey = 1;
             var numberOfTimesThatEachMessageIsTriedWhenDone = 1;
-            var numberOfTimesThatEachMessageIsTriedBeforeDurable = 4;
             var numberOfTimesThatEachMessageIsTriedDuringDurable = 1;
             var producer = this.serviceProvider.GetRequiredService(producerType) as IMessageProducer;
             var physicalStorageAssert = this.serviceProvider.GetRequiredService(physicalStorageType) as IPhysicalStorageAssert;
@@ -91,27 +87,7 @@ internal async Task EmptyKeyRetryDurableTest(
                 await producer.ProduceAsync(message.Key, message).ConfigureAwait(false);
             }
 
-            RetryDurableTestMessage messageToValidate;
-            if (producer is IMessageProducer<RetryDurableLatestConsumptionSqlServerProducer> || producer is IMessageProducer<RetryDurableLatestConsumptionMongoDbProducer>)
-            {
-                messageToValidate = messages[numberOfMessagesToBeProduced - 1];
-
-                // Assert - Creation
-                foreach (var message in messages)
-                {
-                    await InMemoryAuxiliarStorage<RetryDurableTestMessage>
-                    .AssertEmptyPartitionKeyCountMessageAsync(message, numberOfTimesThatEachMessageIsTriedBeforeDurable, 120)
-                    .ConfigureAwait(false);
-                }
-            }
-            else
-            {
-                messageToValidate = messages[0];
-
-                await InMemoryAuxiliarStorage<RetryDurableTestMessage>
-                    .AssertEmptyPartitionKeyCountMessageAsync(messageToValidate, numberOfTimesThatEachMessageIsTriedBeforeDurable, 120)
-                    .ConfigureAwait(false);
-            }
+            RetryDurableTestMessage messageToValidate = messages[0];
 
             await physicalStorageAssert
                 .AssertEmptyKeyRetryDurableMessageRetryingAsync(repositoryType, messageToValidate, numberOfMessagesByEachSameKey)
@@ -121,7 +97,7 @@ await physicalStorageAssert
             InMemoryAuxiliarStorage<RetryDurableTestMessage>.Clear();
 
             await InMemoryAuxiliarStorage<RetryDurableTestMessage>
-                .AssertEmptyPartitionKeyCountMessageAsync(messageToValidate, numberOfTimesThatEachMessageIsTriedDuringDurable, 120)
+                .AssertEmptyPartitionKeyCountMessageAsync(messageToValidate, numberOfTimesThatEachMessageIsTriedDuringDurable, defaultWaitingTimeSeconds)
                 .ConfigureAwait(false);
 
             await physicalStorageAssert
@@ -133,7 +109,7 @@ await physicalStorageAssert
             InMemoryAuxiliarStorage<RetryDurableTestMessage>.Clear();
 
             await InMemoryAuxiliarStorage<RetryDurableTestMessage>
-                .AssertEmptyPartitionKeyCountMessageAsync(messageToValidate, numberOfTimesThatEachMessageIsTriedWhenDone, 120)
+                .AssertEmptyPartitionKeyCountMessageAsync(messageToValidate, numberOfTimesThatEachMessageIsTriedWhenDone, defaultWaitingTimeSeconds)
                 .ConfigureAwait(false);
 
             await physicalStorageAssert

src/KafkaFlow.Retry.UnitTests/Durable/Repository/RetryDurableQueueRepositoryTests.cs

@@ -1,5 +1,10 @@
 namespace KafkaFlow.Retry.UnitTests.Durable.Repository
 {
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Text;
+    using System.Threading.Tasks;
     using global::KafkaFlow.Retry.Durable.Definitions;
     using global::KafkaFlow.Retry.Durable.Encoders;
     using global::KafkaFlow.Retry.Durable.Repository;
@@ -8,42 +13,35 @@
     using global::KafkaFlow.Retry.Durable.Repository.Adapters;
     using global::KafkaFlow.Retry.Durable.Repository.Model;
     using Moq;
-    using System;
-    using System.Collections.Generic;
-    using System.Linq;
-    using System.Text;
-    using System.Threading.Tasks;
     using Xunit;
 
     public class RetryDurableQueueRepositoryTests
     {
-        private readonly Mock<IUpdateRetryQueueItemHandler> mockIUpdateRetryQueueItemHandler;
         private readonly Mock<IMessageAdapter> mockMessageAdapter;
         private readonly Mock<IMessageHeadersAdapter> mockMessageHeadersAdapter;
         private readonly MockRepository mockRepository;
         private readonly Mock<IRetryDurableQueueRepositoryProvider> mockRetryDurableQueueRepositoryProvider;
         private readonly Mock<IUtf8Encoder> mockUtf8Encoder;
-        private readonly RetryDurablePollingDefinition retryDurablePollingDefinition;
         private readonly RetryDurableQueueRepository retryDurableQueueRepository;
 
         public RetryDurableQueueRepositoryTests()
         {
-            this.mockRepository = new MockRepository(MockBehavior.Strict);
+            mockRepository = new MockRepository(MockBehavior.Strict);
 
-            this.mockRetryDurableQueueRepositoryProvider = this.mockRepository.Create<IRetryDurableQueueRepositoryProvider>();
-            this.mockIUpdateRetryQueueItemHandler = this.mockRepository.Create<IUpdateRetryQueueItemHandler>();
-            this.mockMessageHeadersAdapter = this.mockRepository.Create<IMessageHeadersAdapter>();
-            this.mockMessageAdapter = this.mockRepository.Create<IMessageAdapter>();
-            this.mockUtf8Encoder = this.mockRepository.Create<IUtf8Encoder>();
-            this.retryDurablePollingDefinition = new RetryDurablePollingDefinition(true, "0 0 0 ? * * *", 1, 1, "some_id");
+            mockRetryDurableQueueRepositoryProvider = mockRepository.Create<IRetryDurableQueueRepositoryProvider>();
+            var mockIUpdateRetryQueueItemHandler = mockRepository.Create<IUpdateRetryQueueItemHandler>();
+            mockMessageHeadersAdapter = mockRepository.Create<IMessageHeadersAdapter>();
+            mockMessageAdapter = mockRepository.Create<IMessageAdapter>();
+            mockUtf8Encoder = mockRepository.Create<IUtf8Encoder>();
+            var retryDurablePollingDefinition = new RetryDurablePollingDefinition(true, "0 0 0 ? * * *", 1, 1, "some_id");
 
             retryDurableQueueRepository = new RetryDurableQueueRepository(
-                this.mockRetryDurableQueueRepositoryProvider.Object,
-                new List<IUpdateRetryQueueItemHandler> { this.mockIUpdateRetryQueueItemHandler.Object },
-                this.mockMessageHeadersAdapter.Object,
-                this.mockMessageAdapter.Object,
-                this.mockUtf8Encoder.Object,
-                this.retryDurablePollingDefinition);
+                mockRetryDurableQueueRepositoryProvider.Object,
+                new List<IUpdateRetryQueueItemHandler> { mockIUpdateRetryQueueItemHandler.Object },
+                mockMessageHeadersAdapter.Object,
+                mockMessageAdapter.Object,
+                mockUtf8Encoder.Object,
+                retryDurablePollingDefinition);
         }
 
         [Theory]
@@ -112,7 +110,7 @@ public async Task AddIfQueueExistsAsync_WithValidMessage_ReturnResultStatusAdded
             // Assert
             Assert.NotNull(result);
             Assert.Equal(addedIfQueueExistsResultStatus, result.Status);
-            this.mockRepository.VerifyAll();
+            mockRepository.VerifyAll();
         }
     }
 }