Feature/ag 14044 Testing sonar

.github/workflows/sonarcloud.yml

@@ -0,0 +1,67 @@
+name: SonarCloud Analysis (C#)
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  sonarcloud:
+    name: Analyze with SonarCloud
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup .NET
+        uses: actions/setup-dotnet@v3
+        with:
+          dotnet-version: '8.0.x'
+
+      - name: Install SonarScanner for .NET
+        run: dotnet tool install --global dotnet-sonarscanner
+
+      - name: Install Coverlet.Console
+        run: dotnet tool install --global coverlet.console
+
+      - name: Restore dependencies
+        run: dotnet restore ./AutoGuru.KeyValuePush.sln
+
+      - name: Build tests
+        run: dotnet build ./src/KeyValuePush.Tests/KeyValuePush.Tests.csproj --configuration Debug --framework net8.0
+
+      - name: Run tests with coverage
+        run: |
+          coverlet ./src/KeyValuePush.Tests/bin/Debug/net8.0/KeyValuePush.Tests.dll \
+            --target "dotnet" \
+            --targetargs "test ./src/KeyValuePush.Tests/KeyValuePush.Tests.csproj --no-build --framework net8.0 --logger trx --results-directory ./TestResults/" \
+            --output ./TestResults/Coverage/ \
+            --format opencover
+
+      - name: Upload test results (optional, for visibility in GitHub Actions)
+        uses: actions/upload-artifact@v3
+        with:
+          name: TestResults
+          path: ./TestResults/
+
+      - name: Run SonarCloud analysis
+        env:
+          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
+        run: |
+          dotnet sonarscanner begin \
+            /k:"autoguru-au_kv-push" \
+            /o:"autoguru-au" \
+            /d:sonar.cs.opencover.reportsPaths="./TestResults/Coverage/coverage.opencover.xml" \
+            /d:sonar.inclusions="**/*.cs" \
+            /d:sonar.exclusions="**/bin/**,**/obj/**" \
+            /d:sonar.scanner.skipJreProvisioning=true \
+            /d:sonar.verbose=true \
+            /d:sonar.login="${{ secrets.SONAR_TOKEN }}"
+          dotnet build ./AutoGuru.KeyValuePush.sln
+          dotnet sonarscanner end /d:sonar.login="${{ secrets.SONAR_TOKEN }}"

AutoGuru.KeyValuePush.sln

@@ -15,6 +15,10 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = ".Repo Items", ".Repo Items"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "AutoGuru.KeyValuePush.Redis", "src\KeyValuePush.Redis\AutoGuru.KeyValuePush.Redis.csproj", "{379E9996-CE05-44CD-B255-5C88B1CE1BED}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{6598E4B4-D7D3-4633-9E2F-5C470917258D}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "KeyValuePush.Tests", "src\KeyValuePush.Tests\KeyValuePush.Tests.csproj", "{14E2DBAE-46BF-4109-8F87-5894B0C7E07E}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -29,11 +33,18 @@ Global
 		{379E9996-CE05-44CD-B255-5C88B1CE1BED}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{379E9996-CE05-44CD-B255-5C88B1CE1BED}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{379E9996-CE05-44CD-B255-5C88B1CE1BED}.Release|Any CPU.Build.0 = Release|Any CPU
+		{14E2DBAE-46BF-4109-8F87-5894B0C7E07E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{14E2DBAE-46BF-4109-8F87-5894B0C7E07E}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{14E2DBAE-46BF-4109-8F87-5894B0C7E07E}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{14E2DBAE-46BF-4109-8F87-5894B0C7E07E}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {EE37C22E-E3CE-4E6B-8004-BB25FE05CB98}
 	EndGlobalSection
+	GlobalSection(NestedProjects) = preSolution
+		{14E2DBAE-46BF-4109-8F87-5894B0C7E07E} = {6598E4B4-D7D3-4633-9E2F-5C470917258D}
+	EndGlobalSection
 EndGlobal

Directory.Build.props

@@ -1,5 +1,4 @@
 <Project>
-
   <PropertyGroup>
     <TargetFrameworks>net6.0;net7.0;net8.0</TargetFrameworks>
     <IsPackable>false</IsPackable>
@@ -12,11 +11,9 @@
     <PackageProjectUrl>https://github.com/autoguru-au/kv-push</PackageProjectUrl>
     <RepositoryUrl>https://github.com/autoguru-au/kv-push</RepositoryUrl>
     <RepositoryType>git</RepositoryType>
-    <IsPackable>false</IsPackable>
     <NoPackageAnalysis>true</NoPackageAnalysis>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
     <GenerateFullPaths Condition="'$(TERM_PROGRAM)' == 'vscode'">true</GenerateFullPaths>
     <Nullable>enable</Nullable>
   </PropertyGroup>
-
 </Project>

src/KeyValuePush.Redis.Tests/KeyValuePush.Redis.Tests.csproj

@@ -0,0 +1,19 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="xunit" Version="2.4.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5" />
+    <PackageReference Include="StackExchange.Redis" Version="2.7.17" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.6.3" />
+    <PackageReference Include="coverlet.collector" Version="3.2.0" />
+    <PackageReference Include="Moq" Version="4.20.2" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\KeyValuePush.Redis\AutoGuru.KeyValuePush.Redis.csproj" />
+  </ItemGroup>
+
+</Project>

src/KeyValuePush.Redis.Tests/RedisPusherTests.cs

@@ -0,0 +1,29 @@
+using Moq;
+using StackExchange.Redis;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace AutoGuru.KeyValuePush.Redis.Tests
+{
+    public class RedisPusherTests
+    {
+        private readonly Mock<IDatabase> _mockDatabase;
+        private readonly RedisPusher _pusher;
+
+        public RedisPusherTests()
+        {
+            _mockDatabase = new Mock<IDatabase>();
+            _pusher = new RedisPusher();
+
+            // Usamos reflexión para inyectar el mock en el campo privado
+            var field = typeof(RedisPusher).GetField("_db", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
+            field?.SetValue(_pusher, _mockDatabase.Object);
+        }
+
+
+    }
+}

src/KeyValuePush.Tests/BasicTests.cs

@@ -0,0 +1,13 @@
+using Xunit;
+
+namespace KeyValuePush.Tests
+{
+    public class BasicTests
+    {
+        [Fact]
+        public void ExampleTest()
+        {
+            Assert.True(1 + 1 == 2);
+        }
+    }
+}

src/KeyValuePush.Tests/DefaultDictionaryBuilderTests.cs

@@ -0,0 +1,158 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using AutoGuru.KeyValuePush;
+using Xunit;
+
+namespace KeyValuePush.Tests
+{
+    public class DefaultDictionaryBuilderTests
+    {
+        private readonly DefaultDictionaryBuilder _builder;
+
+        public DefaultDictionaryBuilderTests()
+        {
+            _builder = new DefaultDictionaryBuilder();
+        }
+
+        [Fact]
+        public void TryAdd_ShouldAddKeyValuePair_WhenKeyDoesNotExist()
+        {
+            var dict = new Dictionary<string, string>();
+            var key = "key1";
+            var value = "value1";
+
+            DefaultDictionaryBuilder.TryAdd(dict, key, value);
+
+            Assert.Single(dict);
+            Assert.Equal(value, dict[key]);
+        }
+
+        [Fact]
+        public void TryAdd_ShouldNotThrow_WhenKeyExistsWithSameValue()
+        {
+            var dict = new Dictionary<string, string> { { "key1", "value1" } };
+            var key = "key1";
+            var value = "value1";
+
+            DefaultDictionaryBuilder.TryAdd(dict, key, value);
+
+            Assert.Single(dict);
+            Assert.Equal(value, dict[key]);
+        }
+
+        [Fact]
+        public void TryAdd_ShouldThrowException_WhenKeyExistsWithDifferentValue()
+        {
+            var dict = new Dictionary<string, string> { { "key1", "value1" } };
+            var key = "key1";
+            var value = "differentValue";
+
+            var exception = Assert.Throws<Exception>(() => DefaultDictionaryBuilder.TryAdd(dict, key, value));
+            Assert.Equal("Duplicate key of 'key1' with a different value detected.", exception.Message);
+        }
+
+        [Fact]
+        public async Task BuildAsync_ShouldThrowException_WhenFileAccessFailsAsync()
+        {
+            var path = "RestrictedFiles";
+            Directory.CreateDirectory(path);
+            var filePath = Path.Combine(path, "file1.txt");
+            File.WriteAllText(filePath, "Content1");
+
+            // Bloquear el archivo para simular acceso denegado
+            using (var fileStream = File.Open(filePath, FileMode.Open, FileAccess.Read, FileShare.None))
+            {
+                var exception = await Assert.ThrowsAsync<IOException>(() =>
+                    _builder.BuildAsync(path, "*.txt", SearchOption.TopDirectoryOnly, false, CancellationToken.None));
+
+                Assert.Contains("being used by another process", exception.Message);
+            }
+
+            File.Delete(filePath);
+            Directory.Delete(path);
+        }
+
+
+        [Fact]
+        public async Task BuildAsync_ShouldRespectCancellationTokenAsync()
+        {
+            var path = "TestFiles";
+            Directory.CreateDirectory(path);
+            File.WriteAllText(Path.Combine(path, "file1.txt"), "Content1");
+
+            using var cts = new CancellationTokenSource();
+            cts.Cancel();
+
+            await Assert.ThrowsAsync<OperationCanceledException>(() =>
+                _builder.BuildAsync(path, "*.txt", SearchOption.TopDirectoryOnly, false, cts.Token));
+
+            Directory.Delete(path, true);
+        }
+
+        [Fact]
+        public async Task BuildAsync_ShouldHandleDuplicateKeysInJsonFilesAsync()
+        {
+            var path = "TestFiles";
+            Directory.CreateDirectory(path);
+
+            // Crear un archivo JSON con claves únicas
+            var jsonContent = JsonSerializer.Serialize(new Dictionary<string, string>
+            {
+                { "Key1", "Value1" },
+                { "Key2", "Value2" }
+            });
+            File.WriteAllText(Path.Combine(path, "file1.json"), jsonContent);
+
+            var result = await _builder.BuildAsync(path, "*.json", SearchOption.TopDirectoryOnly, true, CancellationToken.None);
+
+            Assert.Equal(2, result.Count);
+            Assert.Equal("Value1", result["Key1"]);
+            Assert.Equal("Value2", result["Key2"]);
+
+            Directory.Delete(path, true);
+        }
+
+
+        [Fact]
+        public async Task BuildAsync_ShouldIgnoreFilesWithNonJsonExtensionsAsync()
+        {
+            var path = "TestFiles";
+            Directory.CreateDirectory(path);
+
+            // Crear un archivo con extensión no soportada
+            File.WriteAllText(Path.Combine(path, "file1.unsupported"), "Unsupported Content");
+
+            var result = await _builder.BuildAsync(path, "*.json", SearchOption.TopDirectoryOnly, false, CancellationToken.None);
+
+            Assert.Empty(result);
+            Directory.Delete(path, true);
+        }
+
+
+        [Fact]
+        public async Task BuildAsync_ShouldCombineJsonAndTextFilesAsync()
+        {
+            var path = "TestFiles";
+            Directory.CreateDirectory(path);
+            var jsonContent = JsonSerializer.Serialize(new Dictionary<string, string>
+            {
+                { "Key1", "Value1" },
+                { "Key2", "Value2" }
+            });
+            File.WriteAllText(Path.Combine(path, "file1.json"), jsonContent);
+            File.WriteAllText(Path.Combine(path, "file2.txt"), "TextContent");
+
+            var result = await _builder.BuildAsync(path, "*.*", SearchOption.TopDirectoryOnly, true, CancellationToken.None);
+
+            Assert.Equal(3, result.Count);
+            Assert.Equal("Value1", result["Key1"]);
+            Assert.Equal("Value2", result["Key2"]);
+            Assert.Equal("TextContent", result["file2"]);
+            Directory.Delete(path, true);
+        }
+    }
+}