179 cleanup libs - analyzer

.github/workflows/codebreaker-lib-analyzers-stable.yml

@@ -0,0 +1,55 @@
+name: Analyzers stable lib
+
+on:
+
+  # Allow manually trigger 
+  workflow_dispatch:    
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    env:
+      solutionfile-path: src/Codebreaker.Analyzers.sln
+      projectfile-path: src/services/gameapi/Codebreaker.GameAPIs.Analyzers/Codebreaker.Analyzers.csproj
+      artifact-name: codebreaker-analyzers-stable   
+
+    steps:
+      - name: Checkout to the branch
+        uses: actions/checkout@v4
+        with:
+          ref: main
+
+      - name: Setup .NET
+        uses: actions/setup-dotnet@v4
+        with: 
+          dotnet-version: 8.0.x
+
+      - name: Build the library
+        run: dotnet build -c Release ${{ env.solutionfile-path }}
+
+      - name: Run the unit tests
+        run: dotnet test ${{ env.solutionfile-path }}
+
+      - name: Create a Package
+        run: dotnet pack -c Release ${{ env.projectfile-path }} -o packages
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ env.artifact-name }}
+          path: packages/*
+          retention-days: 30
+
+# publishdevops:
+#  uses: CodebreakerApp/Codebreaker.Backend/.github/workflows/publishnuget-azuredevops.yml@main
+#  needs: build
+#  with:
+#    artifact-name: codebreaker-analyzers
+#  secrets: inherit
+
+#   publishnuget:
+#     uses: CodebreakerApp/Codebreaker.Backend/.github/workflows/publishnuget-nugetserver.yml@main
+#     needs: publishdevops
+#    with:
+#      artifact-name: codebreaker-analyzers
+#    secrets: inherit

src/Directory.Build.props

@@ -15,6 +15,6 @@
   </PropertyGroup>
 
   <PropertyGroup>
-    <VersionPrefix>3.6.0</VersionPrefix>
+    <VersionPrefix>3.7.0</VersionPrefix>
   </PropertyGroup>
 </Project>

src/services/gameapi/Codebreaker.GameAPIs.Analyzers.Tests/Analyzers/ColorGame6x4AnalyzerTests.cs

@@ -1,5 +1,4 @@
 using System.Collections;
-using System.Reflection.Emit;
 
 using static Codebreaker.GameAPIs.Models.Colors;
 
@@ -8,10 +7,10 @@ namespace Codebreaker.GameAPIs.Analyzer.Tests;
 public class ColorGame6x4AnalyzerTests
 {
     [Fact]
-    public void SetMoveShouldReturnThreeWhite()
+    public void SetMove_ShouldReturnThreeWhite()
     {
         ColorResult expectedKeyPegs = new(0, 3);
-        ColorResult? resultKeyPegs = TestSkeleton(
+        ColorResult? resultKeyPegs = AnalyzeGame(
             [Green, Yellow, Green, Black],
             [Yellow, Green, Black, Blue]
         );
@@ -22,81 +21,83 @@ public void SetMoveShouldReturnThreeWhite()
     [InlineData(1, 2, Red, Yellow, Red, Blue)]
     [InlineData(2, 0, White, White, Blue, Red)]
     [Theory]
-    public void SetMoveUsingVariousData(int expectedBlack, int expectedWhite, params string[] guessValues)
+    public void SetMove_UsingVariousData(int expectedBlack, int expectedWhite, params string[] guessValues)
     {
         string[] code = [Red, Green, Blue, Red];
         ColorResult expectedKeyPegs = new (expectedBlack, expectedWhite);
-        ColorResult resultKeyPegs = TestSkeleton(code, guessValues);
+        ColorResult resultKeyPegs = AnalyzeGame(code, guessValues);
         Assert.Equal(expectedKeyPegs, resultKeyPegs);
     }
 
     [Theory]
     [ClassData(typeof(TestData6x4))]
-    public void SetMoveUsingVariousDataUsingDataClass(string[] code, string[] guess, ColorResult expectedKeyPegs)
+    public void SetMove_UsingVariousDataUsingDataClass(string[] code, string[] guess, ColorResult expectedKeyPegs)
     {
-        ColorResult actualKeyPegs = TestSkeleton(code, guess);
+        ColorResult actualKeyPegs = AnalyzeGame(code, guess);
         Assert.Equal(expectedKeyPegs, actualKeyPegs);
     }
 
     [Fact]
-    public void ShouldThrowOnInvalidGuessCount()
+    public void SetMove_ShouldThrowOnInvalidGuessCount()
     {
         Assert.Throws<ArgumentException>(() => 
-            TestSkeleton(
+            AnalyzeGame(
                 ["Black", "Black", "Black", "Black"],
                 ["Black"]
             ));
     }
 
     [Fact]
-    public void ShouldThrowOnInvalidGuessValues()
+    public void SetMove_ShouldThrowOnInvalidGuessValues()
     {
         Assert.Throws<ArgumentException>(() => 
-            TestSkeleton(
+            AnalyzeGame(
                 ["Black", "Black", "Black", "Black"],
                 ["Black", "Der", "Blue", "Yellow"]      // "Der" is the wrong value
             ));
     }
 
     [Fact]
-    public void ShouldThrowOnInvalidMoveNumber()
+    public void SetMove_ShouldThrowOnInvalidMoveNumber()
     {
         Assert.Throws<ArgumentException>(() => 
-            TestSkeleton(
+            AnalyzeGame(
                 [Green, Yellow, Green, Black],
                 [Yellow, Green, Black, Blue], moveNumber: 2));
     }
 
     [Fact]
-    public void ShouldNotIncrementMoveNumberOnInvalidMove()
+    public void SetMove_ShouldNotIncrementMoveNumberOnInvalidMove()
     {
-        IGame game = TestSkeletonWithGame(
+        IGame game = AnalyzeGameCatchingException(
             [Green, Yellow, Green, Black],
             [Yellow, Green, Black, Blue], moveNumber: 2);
 
         Assert.Equal(0, game?.LastMoveNumber);
     }
 
-    private static ColorResult TestSkeleton(string[] codes, string[] guesses, int moveNumber = 1)
-    {
-        MockColorGame game = new()
+    private static MockColorGame CreateGame(string[] codes) => 
+        new()
         {
             GameType = GameTypes.Game6x4,
             NumberCodes = 4,
             MaxMoves = 12,
             IsVictory = false,
             FieldValues = new Dictionary<string, IEnumerable<string>>()
             {
-                [FieldCategories.Colors ] = TestData6x4.Colors6.ToList()
+                [FieldCategories.Colors] = [.. TestData6x4.Colors6]
             },
             Codes = codes
         };
 
-        ColorGameGuessAnalyzer analyzer = new(game,guesses.ToPegs<ColorField>().ToArray(), moveNumber);
+    private static ColorResult AnalyzeGame(string[] codes, string[] guesses, int moveNumber = 1)
+    {
+        MockColorGame game = CreateGame(codes);
+        ColorGameGuessAnalyzer analyzer = new(game, [.. guesses.ToPegs<ColorField>() ], moveNumber);
         return analyzer.GetResult();
     }
 
-    private static IGame TestSkeletonWithGame(string[] codes, string[] guesses, int moveNumber = 1)
+    private static IGame AnalyzeGameCatchingException(string[] codes, string[] guesses, int moveNumber = 1)
     {
         MockColorGame game = new()
         {

src/services/gameapi/Codebreaker.GameAPIs.Analyzers.Tests/Analyzers/ColorGame8x5AnalyzerTests.cs

@@ -7,10 +7,10 @@ namespace Codebreaker.GameAPIs.Analyzer.Tests;
 public class ColorGame8x5AnalyzerTests
 {
     [Fact]
-    public void SetMoveShouldReturnThreeWhite()
+    public void SetMove_ShouldReturnThreeWhite()
     {
         ColorResult expectedKeyPegs = new(0, 3);
-        ColorResult? resultKeyPegs = TestSkeleton(
+        ColorResult? resultKeyPegs = AnalyzeGame(
             [Green, Yellow, Green, Black, Orange],
             [Yellow, Green, Black, Blue, Blue]
         );
@@ -21,45 +21,44 @@ public void SetMoveShouldReturnThreeWhite()
     [InlineData(1, 2, Red, Yellow, Red, Blue, Orange)]
     [InlineData(2, 0, White, White, Blue, Red, White)]
     [Theory]
-    public void SetMoveUsingVariousData(int expectedBlack, int expectedWhite, params string[] guessValues)
+    public void SetMove_UsingVariousData(int expectedBlack, int expectedWhite, params string[] guessValues)
     {
         string[] code = [Red, Green, Blue, Red, Brown];
         ColorResult expectedKeyPegs = new (expectedBlack, expectedWhite);
-        ColorResult resultKeyPegs = TestSkeleton(code, guessValues);
+        ColorResult resultKeyPegs = AnalyzeGame(code, guessValues);
         Assert.Equal(expectedKeyPegs, resultKeyPegs);
     }
 
     [Theory]
     [ClassData(typeof(TestData8x5))]
-    public void SetMoveUsingVariousDataUsingDataClass(string[] code, string[] guess, ColorResult expectedKeyPegs)
+    public void SetMove_UsingVariousDataUsingDataClass(string[] code, string[] guess, ColorResult expectedKeyPegs)
     {
-        ColorResult actualKeyPegs = TestSkeleton(code, guess);
+        ColorResult actualKeyPegs = AnalyzeGame(code, guess);
         Assert.Equal(expectedKeyPegs, actualKeyPegs);
     }
 
     [Fact]
-    public void ShouldThrowOnInvalidGuessCount()
+    public void SetMove_ShouldThrowOnInvalidGuessCount()
     {
         Assert.Throws<ArgumentException>(() => 
-            TestSkeleton(
+            AnalyzeGame(
                 ["Black", "Black", "Black", "Black", "Black"],
                 ["Black"]
             ));
     }
 
     [Fact]
-    public void ShouldThrowOnInvalidGuessValues()
+    public void SetMove_ShouldThrowOnInvalidGuessValues()
     {
         Assert.Throws<ArgumentException>(() => 
-            TestSkeleton(
+            AnalyzeGame(
                 ["Black", "Black", "Black", "Black", "Black"],
                 ["Black", "Der", "Blue", "Yellow", "Black"]      // "Der" is the wrong value
             ));
     }
 
-    private static ColorResult TestSkeleton(string[] codes, string[] guesses)
-    {
-        MockColorGame game = new()
+    private static MockColorGame CreateGame(string[] codes) => 
+        new()
         {
             GameType = GameTypes.Game8x5,
             NumberCodes = 5,
@@ -72,6 +71,10 @@ private static ColorResult TestSkeleton(string[] codes, string[] guesses)
             Codes = codes
         };
 
+    private static ColorResult AnalyzeGame(string[] codes, string[] guesses)
+    {
+        MockColorGame game = CreateGame(codes);
+
         ColorGameGuessAnalyzer analyzer = new(game, guesses.ToPegs<ColorField>().ToArray(), 1);
         return analyzer.GetResult();
     }