Added additional unit tests

Author: StevenJDH

MavenVersionChecker.Action.Tests/Chaos/ChaosManagerTests.cs

@@ -0,0 +1,99 @@
+/*
+ * This file is part of Maven Version Checker <https://github.com/StevenJDH/maven-version-checker>.
+ * Copyright (C) 2024 Steven Jenkins De Haro.
+ *
+ * Maven Version Checker is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Maven Version Checker is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Maven Version Checker.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+using MavenVersionChecker.Action.Chaos;
+using MavenVersionChecker.Action.Tests.Support;
+using Microsoft.Extensions.Logging;
+using Moq;
+using Polly;
+
+namespace MavenVersionChecker.Action.Tests.Chaos;
+
+[TestFixture]
+public class ChaosManagerTests
+{
+    // ReSharper disable InconsistentNaming
+    private const string ASPNETCORE_ENVIRONMENT = "ASPNETCORE_ENVIRONMENT";
+    private const string CHAOS_ENV = "Chaos";
+    private const string CHAOS_LOG_MESSAGE = "Chaos strategies are active.\n";
+    // ReSharper restore InconsistentNaming
+
+    [TearDown]
+    public void TearDown()
+    {
+        Environment.SetEnvironmentVariable(ASPNETCORE_ENVIRONMENT, null);
+    }
+
+    [Test, Description("Should enable chaos strategies when environment is set to chaos.")]
+    public async Task Should_EnableChaosStrategies_When_EnvironmentIsSetToChaos()
+    {
+        Environment.SetEnvironmentVariable(ASPNETCORE_ENVIRONMENT, CHAOS_ENV);
+        var mockLogger = new Mock<ILogger<ChaosManager>>();
+        var manager = new ChaosManager(mockLogger.Object);
+
+        var context = ResilienceContextPool.Shared.Get();
+        bool status = await manager.IsChaosEnabledAsync(context);
+        ResilienceContextPool.Shared.Return(context);
+
+        Assert.That(status, Is.True);
+        mockLogger.VerifyLog(LogLevel.Warning, Times.Once, CHAOS_LOG_MESSAGE);
+    }
+
+    [Test, Description("Should disable chaos strategies when environment is not set to chaos.")]
+    public async Task Should_DisableChaosStrategies_When_EnvironmentIsNotSetToChaos()
+    {
+        var mockLogger = new Mock<ILogger<ChaosManager>>();
+        var manager = new ChaosManager(mockLogger.Object);
+
+        var context = ResilienceContextPool.Shared.Get();
+        bool status = await manager.IsChaosEnabledAsync(context);
+        ResilienceContextPool.Shared.Return(context);
+
+        Assert.That(status, Is.False);
+        mockLogger.VerifyLog(LogLevel.Warning, Times.Never);
+    }
+
+    [Test, Description("Should return injection rate greater than zero when environment is set to chaos.")]
+    public async Task Should_ReturnInjectionRateGreaterThanZero_When_EnvironmentIsSetToChaos()
+    {
+        Environment.SetEnvironmentVariable(ASPNETCORE_ENVIRONMENT, CHAOS_ENV);
+        var mockLogger = new Mock<ILogger<ChaosManager>>();
+        var manager = new ChaosManager(mockLogger.Object);
+
+        var context = ResilienceContextPool.Shared.Get();
+        double injectionRate = await manager.GetInjectionRateAsync(context);
+        ResilienceContextPool.Shared.Return(context);
+
+        Assert.That(injectionRate, Is.EqualTo(0.1));
+        mockLogger.VerifyLog(LogLevel.Warning, Times.Once, CHAOS_LOG_MESSAGE);
+    }
+
+    [Test, Description("Should return injection rate of zero when environment is not set to chaos.")]
+    public async Task Should_ReturnInjectionRateOfZero_When_EnvironmentIsNotSetToChaos()
+    {
+        var mockLogger = new Mock<ILogger<ChaosManager>>();
+        var manager = new ChaosManager(mockLogger.Object);
+
+        var context = ResilienceContextPool.Shared.Get();
+        double injectionRate = await manager.GetInjectionRateAsync(context);
+        ResilienceContextPool.Shared.Return(context);
+
+        Assert.That(injectionRate, Is.EqualTo(0.0));
+        mockLogger.VerifyLog(LogLevel.Warning, Times.Never);
+    }
+}

MavenVersionChecker.Action.Tests/Extensions/ServiceCollectionExtensionsTests.cs

@@ -18,6 +18,7 @@
 
 // Ignore Spelling: Api
 
+using System.Text.Json;
 using MavenVersionChecker.Action.Chaos;
 using MavenVersionChecker.Action.Data;
 using MavenVersionChecker.Action.Extensions;
@@ -184,4 +185,51 @@ public void Should_RemoveHttpMessageHandlerBuilderFilter_ForDependencyInjection(
             Assert.That(messageHandlerBuilderFilter, Is.Null);
         });
     }
+
+    [Test, Description("Should use SourceGenerationContext for serializing and deserializing maven query response.")]
+    public void Should_UseSourceGenerationContext_ForSerializingAndDeserializingMavenQueryResponse()
+    {
+        var mavenQueryResponse = new MavenQueryResponse
+        {
+            Result = new QueryResult
+            {
+                NumberFound = 1,
+                Artifacts = [new Artifact { LatestVersion = "999.9.9" }]
+            }
+        };
+
+        string json = JsonSerializer.Serialize(mavenQueryResponse, SourceGenerationContext.Default.MavenQueryResponse);
+        var model = JsonSerializer.Deserialize<MavenQueryResponse>(json, SourceGenerationContext.Default.MavenQueryResponse);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(model, Is.Not.Null);
+            Assert.That(model!.Result.NumberFound, Is.EqualTo(1));
+            Assert.That(model!.Result.Artifacts, Has.Count.EqualTo(1));
+            Assert.That(model!.Result.Artifacts[0].LatestVersion, Is.EqualTo("999.9.9"));
+        });
+    }
+
+    [Test, Description("Should use SourceGenerationContext for serializing and deserializing dictionaries.")]
+    public void Should_UseSourceGenerationContext_ForSerializingAndDeserializingDictionaries()
+    {
+        const string expectedKey = "dependencies";
+        const string expectedValue = "foo:bar:2.0.0";
+        var dictionary = new Dictionary<string, List<string>>
+        {
+            { expectedKey, [expectedValue] }
+        };
+
+        string json = JsonSerializer.Serialize(dictionary, SourceGenerationContext.Default.DictionaryStringListString);
+        var model = JsonSerializer.Deserialize(json, SourceGenerationContext.Default.DictionaryStringListString);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(model, Is.Not.Null);
+            Assert.That(model, Has.Count.EqualTo(1));
+            Assert.That(model!, Contains.Key(expectedKey));
+            Assert.That(model!.GetValueOrDefault(expectedKey), Has.Count.EqualTo(1));
+            Assert.That(model!.GetValueOrDefault(expectedKey)![0], Is.EqualTo(expectedValue));
+        });
+    }
 }