tests manageur

Sources/ConsoleApp2/ConsoleApp2.csproj

@@ -0,0 +1,15 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\CoreLibrary\CoreLibrary.csproj" />
+    <ProjectReference Include="..\Persistance\Persistance.csproj" />
+  </ItemGroup>
+
+</Project>

Sources/ConsoleApp2/Program.cs

@@ -0,0 +1 @@
+

Sources/Fichiers/joueurs.json

@@ -9,7 +9,7 @@
           },
           "Item2": 0
         },
-        "Value": 2
+        "Value": 8.666666666666666
       },
       {
         "Key": {
@@ -18,25 +18,7 @@
           },
           "Item2": 1
         },
-        "Value": 1
-      },
-      {
-        "Key": {
-          "Item1": {
-            "__type": "ReglesClassiques:#CoreLibrary.Regles"
-          },
-          "Item2": 2
-        },
-        "Value": 0
-      },
-      {
-        "Key": {
-          "Item1": {
-            "__type": "ReglesClassiques:#CoreLibrary.Regles"
-          },
-          "Item2": 3
-        },
-        "Value": 5
+        "Value": 3
       }
     ]
   },
@@ -50,16 +32,7 @@
           },
           "Item2": 0
         },
-        "Value": 1
-      },
-      {
-        "Key": {
-          "Item1": {
-            "__type": "ReglesClassiques:#CoreLibrary.Regles"
-          },
-          "Item2": 1
-        },
-        "Value": 5
+        "Value": 8.666666666666666
       },
       {
         "Key": {
@@ -68,71 +41,7 @@
           },
           "Item2": 2
         },
-        "Value": 2
-      },
-      {
-        "Key": {
-          "Item1": {
-            "__type": "ReglesClassiques:#CoreLibrary.Regles"
-          },
-          "Item2": 3
-        },
-        "Value": 10
-      }
-    ]
-  },
-  {
-    "Nom": "Camille",
-    "statistiques": [
-      {
-        "Key": {
-          "Item1": {
-            "__type": "ReglesClassiques:#CoreLibrary.Regles"
-          },
-          "Item2": 0
-        },
         "Value": 3
-      },
-      {
-        "Key": {
-          "Item1": {
-            "__type": "ReglesClassiques:#CoreLibrary.Regles"
-          },
-          "Item2": 1
-        },
-        "Value": 5
-      },
-      {
-        "Key": {
-          "Item1": {
-            "__type": "ReglesClassiques:#CoreLibrary.Regles"
-          },
-          "Item2": 2
-        },
-        "Value": 6
-      },
-      {
-        "Key": {
-          "Item1": {
-            "__type": "ReglesClassiques:#CoreLibrary.Regles"
-          },
-          "Item2": 3
-        },
-        "Value": 50
-      }
-    ]
-  },
-  {
-    "Nom": "a",
-    "statistiques": [
-      {
-        "Key": {
-          "Item1": {
-            "__type": "ReglesClassiques:#CoreLibrary.Regles"
-          },
-          "Item2": 3
-        },
-        "Value": 1
       }
     ]
   }

Sources/MauiSpark/MauiSpark.csproj

@@ -64,6 +64,7 @@
 
 	<ItemGroup>
 	  <ProjectReference Include="..\CoreLibrary\CoreLibrary.csproj" />
+	  <ProjectReference Include="..\Persistance\Persistance.csproj" />
 	</ItemGroup>
 
 	<ItemGroup>

Sources/Persistance/Persistance.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\CoreLibrary\CoreLibrary.csproj" />
+  </ItemGroup>
+
+</Project>

Sources/Persistance/PersistanceJson.cs

@@ -1,12 +1,15 @@
 using System.Runtime.Serialization.Json;
 using System.Text;
+using System.Diagnostics.CodeAnalysis;
 using System.Xml;
+using CoreLibrary.Persistance;
 
-namespace CoreLibrary.Persistance
+namespace Persistance.Persistance
 {
     /// <summary>
     /// Classe PersistanceJson, implémentant l'interface IPersistance, pour la persistance des données au format JSON.
     /// </summary>
+    [ExcludeFromCodeCoverage]
     public class PersistanceJson : IPersistance
     {
         /// <summary>

Sources/Persistance/PersistanceStub.cs

@@ -0,0 +1,49 @@
+using CoreLibrary;
+using CoreLibrary.Joueurs;
+using CoreLibrary.Persistance;
+using CoreLibrary.Regles;
+using System.Diagnostics.CodeAnalysis;
+
+namespace Persistance.Persistance
+{
+    /// <summary>
+    /// Classe PersistanceStub, implémentant l'interface IPersistance, pour la persistance des données en brut dans le code.
+    /// </summary>
+    [ExcludeFromCodeCoverage]
+    public class PersistanceStub : IPersistance
+    {
+        /// <summary>
+        /// En fonction du type T, renvoie une liste d'éléments.
+        /// </summary>
+        /// <returns>Renvoie un tableau de tous les éléments chargés.</returns>
+        public T[] Charger<T>() where T : IEstPersistant
+        {
+            if (typeof(T).Equals(typeof(Joueur)))
+            {
+                return [
+                    (T)(object)new Joueur("Céleste"),
+                    (T)(object)new Joueur("Pauline"),
+                    (T)(object)new Joueur("Camille")
+                ];
+            }
+
+            if (typeof(T).Equals(typeof(Partie)))
+            {
+                return [
+                    (T)(object)new Partie(new ReglesClassiques()),
+                    (T)(object)new Partie(new ReglesDifficiles())
+                ];
+            }
+
+            return Array.Empty<T>();
+        }
+
+        /// <summary>
+        /// Enregistre les éléments spécifiés dans le fichier de sauvegarde au format JSON.
+        /// </summary>
+        /// <param name="elements">Elements à enregistrer dans le fichier de sauvegarde.</param>
+        public void Enregistrer<T>(T[] elements) where T : IEstPersistant
+        {
+        }
+    }
+}

Sources/UnitTesting/JoueurUT.cs

@@ -122,7 +122,7 @@ namespace UnitTesting
             ReglesClassiques regles = new ReglesClassiques();
             Statistique statistique = new Statistique();
 
-            int result = joueur.Statistique(regles, statistique);
+            double result = joueur.Statistique(regles, statistique);
 
             Assert.Equal(0, result);
         }
@@ -135,7 +135,7 @@ namespace UnitTesting
             Statistique statistique = new Statistique();
             joueur.IncrementerStatistique(regles, statistique);
 
-            int result = joueur.Statistique(regles, statistique);
+            double result = joueur.Statistique(regles, statistique);
 
             Assert.Equal(1, result);
         }
@@ -148,7 +148,7 @@ namespace UnitTesting
             Statistique statistique = new Statistique();
 
             joueur.IncrementerStatistique(regles, statistique);
-            int result = joueur.Statistique(regles, statistique);
+            double result = joueur.Statistique(regles, statistique);
 
             Assert.Equal(1, result);
         }
@@ -162,7 +162,7 @@ namespace UnitTesting
 
             joueur.IncrementerStatistique(regles, statistique);
             joueur.IncrementerStatistique(regles, statistique);
-            int result = joueur.Statistique(regles, statistique);
+            double result = joueur.Statistique(regles, statistique);
 
             Assert.Equal(2, result);
         }

Sources/UnitTesting/ManagerUT.cs

@@ -1,18 +0,0 @@
-using CoreLibrary.Manageurs;
-using CoreLibrary.Persistance;
-using Xunit;
-
-namespace UnitTesting
-{
-    public class ManagerUT
-    {
-        [Fact]
-        public void TestConstruteur()
-        {
-            IPersistance persistance = new PersistanceJson();
-            Manageur manageur = new Manageur(persistance);
-            Assert.NotNull(manageur.Joueurs);
-            Assert.NotEmpty(manageur.Joueurs);
-        }
-    }
-}

Sources/UnitTesting/ManageurUT.cs

@@ -0,0 +1,188 @@
+using CoreLibrary;
+using CoreLibrary.Evenements;
+using CoreLibrary.Joueurs;
+using CoreLibrary.Manageurs;
+using CoreLibrary.Persistance;
+using CoreLibrary.Regles;
+using Persistance.Persistance;
+using System.Reflection;
+using Xunit;
+
+namespace UnitTesting
+{
+    public class ManageurUT
+    {
+        [Fact]
+        public void TestConstruteur()
+        {
+            IPersistance persistance = new PersistanceStub();
+            Manageur manageur = new Manageur(persistance);
+
+            Assert.NotNull(manageur.Joueurs);
+            Assert.NotEmpty(manageur.Joueurs);
+
+            Assert.NotNull(manageur.Parties);
+            Assert.NotEmpty(manageur.Joueurs);
+
+            Assert.NotNull(manageur.PartiesNonTerminees);
+            Assert.NotEmpty(manageur.Joueurs);
+        }
+
+        [Fact]
+        public void TestSauvegarder()
+        {
+            IPersistance persistance = new PersistanceStub();
+            Manageur manageur = new Manageur(persistance);
+
+            MethodInfo? infosMethode = typeof(Manageur).GetMethod("Sauvegarder", BindingFlags.NonPublic | BindingFlags.Instance);
+            Assert.NotNull(infosMethode);
+            infosMethode.Invoke(manageur, []);
+        }
+
+        [Fact]
+        public void TestChargerPartie()
+        {
+            IPersistance persistance = new PersistanceStub();
+            Manageur manageur = new Manageur(persistance);
+
+            Partie partie = manageur.PartiesNonTerminees.First();
+
+            Partie nouvellePartie = manageur.ChargerPartie(partie);
+
+            Assert.DoesNotContain(partie, manageur.Parties);
+            Assert.DoesNotContain(partie, manageur.PartiesNonTerminees);
+
+            Assert.Contains(nouvellePartie, manageur.Parties);
+            Assert.Contains(nouvellePartie, manageur.PartiesNonTerminees);
+        }
+
+        [Fact]
+        public void TestNouvellePartie()
+        {
+            IPersistance persistance = new PersistanceStub();
+            Manageur manageur = new Manageur(persistance);
+
+            Partie nouvellePartie = manageur.NouvellePartie(new ReglesClassiques());
+
+            Assert.Contains(nouvellePartie, manageur.Parties);
+            Assert.Contains(nouvellePartie, manageur.PartiesNonTerminees);
+        }
+
+        [Fact]
+        public void TestEcouterPartie()
+        {
+            IPersistance persistance = new PersistanceStub();
+            Manageur manageur = new Manageur(persistance);
+
+            MethodInfo? infosMethode = typeof(Manageur).GetMethod("EcouterPartie", BindingFlags.NonPublic | BindingFlags.Instance);
+            Assert.NotNull(infosMethode);
+
+            Partie partie = new Partie(new ReglesClassiques());
+
+            FieldInfo? PartieDemanderJoueurInfos = typeof(Partie)
+                .GetField("PartieDemanderJoueur", BindingFlags.Instance | BindingFlags.NonPublic);
+
+            Assert.NotNull(PartieDemanderJoueurInfos);
+
+            EventHandler<PartieDemanderJoueurEventArgs>? PartieDemanderJoueur =
+                PartieDemanderJoueurInfos.GetValue(partie) as EventHandler<PartieDemanderJoueurEventArgs>;
+
+            FieldInfo? PartieDebutPartieInfos = typeof(Partie)
+                .GetField("PartieDebutPartie", BindingFlags.Instance | BindingFlags.NonPublic);
+
+            Assert.NotNull(PartieDebutPartieInfos);
+
+            EventHandler<PartieDebutPartieEventArgs>? PartieDebutPartie =
+                PartieDebutPartieInfos.GetValue(partie) as EventHandler<PartieDebutPartieEventArgs>;
+            
+            FieldInfo? PartieDemanderJoueurJouerInfos = typeof(Partie)
+                .GetField("PartieDemanderJoueurJouer", BindingFlags.Instance | BindingFlags.NonPublic);
+
+            Assert.NotNull(PartieDemanderJoueurJouerInfos);
+
+            EventHandler<PartieDemanderJoueurJouerEventArgs>? PartieDemanderJoueurJouer =
+                PartieDemanderJoueurJouerInfos.GetValue(partie) as EventHandler<PartieDemanderJoueurJouerEventArgs>;
+            
+            FieldInfo? PartiePasserLaMainInfos = typeof(Partie)
+                .GetField("PartiePasserLaMain", BindingFlags.Instance | BindingFlags.NonPublic);
+
+            Assert.NotNull(PartiePasserLaMainInfos);
+
+            EventHandler<PartiePasserLaMainEventArgs>? PartiePasserLaMain =
+                PartiePasserLaMainInfos.GetValue(partie) as EventHandler<PartiePasserLaMainEventArgs>;
+            
+            FieldInfo? PartiePartieTermineeInfos = typeof(Partie)
+                .GetField("PartiePartieTerminee", BindingFlags.Instance | BindingFlags.NonPublic);
+
+            Assert.NotNull(PartiePartieTermineeInfos);
+
+            EventHandler<PartiePartieTermineeEventArgs>? PartiePartieTerminee =
+                PartiePartieTermineeInfos.GetValue(partie) as EventHandler<PartiePartieTermineeEventArgs>;
+
+            Assert.Null(PartieDemanderJoueur);
+            Assert.Null(PartieDebutPartie);
+            Assert.Null(PartieDemanderJoueurJouer);
+            Assert.Null(PartiePasserLaMain);
+            Assert.Null(PartiePartieTerminee);
+
+            infosMethode.Invoke(manageur, [partie]);
+
+            PartieDemanderJoueur =
+                PartieDemanderJoueurInfos.GetValue(partie) as EventHandler<PartieDemanderJoueurEventArgs>;
+
+            PartieDebutPartie =
+                PartieDebutPartieInfos.GetValue(partie) as EventHandler<PartieDebutPartieEventArgs>;
+
+            PartieDemanderJoueurJouer =
+                PartieDemanderJoueurJouerInfos.GetValue(partie) as EventHandler<PartieDemanderJoueurJouerEventArgs>;
+
+            PartiePasserLaMain =
+                PartiePasserLaMainInfos.GetValue(partie) as EventHandler<PartiePasserLaMainEventArgs>;
+
+            PartiePartieTerminee =
+                PartiePartieTermineeInfos.GetValue(partie) as EventHandler<PartiePartieTermineeEventArgs>;
+
+            Assert.NotNull(PartieDemanderJoueur);
+            Assert.NotNull(PartieDebutPartie);
+            Assert.NotNull(PartieDemanderJoueurJouer);
+            Assert.NotNull(PartiePasserLaMain);
+            Assert.NotNull(PartiePartieTerminee);
+
+            Assert.NotEmpty(PartieDemanderJoueur.GetInvocationList());
+            Assert.NotEmpty(PartieDebutPartie.GetInvocationList());
+            Assert.NotEmpty(PartieDemanderJoueurJouer.GetInvocationList());
+            Assert.NotEmpty(PartiePasserLaMain.GetInvocationList());
+            Assert.NotEmpty(PartiePartieTerminee.GetInvocationList());
+        }
+
+        [Fact]
+        public void TestDemanderJoueurExistant()
+        {
+            IPersistance persistance = new PersistanceStub();
+            Manageur manageur = new Manageur(persistance);
+
+            MethodInfo? infosMethode = typeof(Manageur).GetMethod("DemanderJoueurExistant", BindingFlags.NonPublic | BindingFlags.Instance);
+            Assert.NotNull(infosMethode);
+
+            object? celeste = infosMethode.Invoke(manageur, ["Céleste"]);
+            Assert.NotNull(celeste);
+            Assert.IsType<Joueur>(celeste);
+
+            object? toto = infosMethode.Invoke(manageur, ["Toto"]);
+            Assert.Null(toto);
+        }
+
+        [Fact]
+        public void TestDemanderJoueur()
+        {
+            IPersistance persistance = new PersistanceStub();
+            Manageur manageur = new Manageur(persistance);
+
+            Joueur joueur = manageur.DemanderJoueur("Céleste");
+            Joueur joueur2 = manageur.DemanderJoueur("Toto");
+
+            Assert.Contains(joueur, manageur.Joueurs);
+            Assert.Contains(joueur2, manageur.Joueurs);
+        }
+    }
+}

Sources/UnitTesting/PartiePartieTermineeEventArgsUT.cs

@@ -11,8 +11,10 @@ namespace UnitTesting
         {
             IReadOnlyList<string> gagnants = new List<string>(["joueur1", "joueur2"]);
             IReadOnlyList<string> perdants = new List<string>(["joueur3"]);
+            int tour = 10;
 
-            PartiePartieTermineeEventArgs evenement = new PartiePartieTermineeEventArgs(gagnants, perdants);
+            PartiePartieTermineeEventArgs evenement = new PartiePartieTermineeEventArgs(tour, gagnants, perdants);
+            Assert.Equal(tour, evenement.Tour);
             Assert.Equal(gagnants, evenement.Gagnants);
             Assert.Equal(perdants, evenement.Perdants);
         }

Sources/UnitTesting/UnitTesting.csproj

@@ -23,8 +23,8 @@
   </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\ConsoleApp\ConsoleApp.csproj" />
     <ProjectReference Include="..\CoreLibrary\CoreLibrary.csproj" />
+    <ProjectReference Include="..\Persistance\Persistance.csproj" />
   </ItemGroup>
 
 </Project>

Sources/mastermind.sln

@@ -14,6 +14,10 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "UnitTesting", "UnitTesting\
 		{341FB405-085D-4C34-B395-64EF0F9B93E0} = {341FB405-085D-4C34-B395-64EF0F9B93E0}
 	EndProjectSection
 EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Persistance", "Persistance\Persistance.csproj", "{B9E8C10D-9E0E-42F1-8F2C-1E2200DD96FA}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ConsoleApp2", "ConsoleApp2\ConsoleApp2.csproj", "{5F798F65-4226-49F9-8F01-B140507E9502}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -38,6 +42,14 @@ Global
 		{A2182054-C0D1-46D6-BD39-F3F7926CE2DD}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{A2182054-C0D1-46D6-BD39-F3F7926CE2DD}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{A2182054-C0D1-46D6-BD39-F3F7926CE2DD}.Release|Any CPU.Build.0 = Release|Any CPU
+		{B9E8C10D-9E0E-42F1-8F2C-1E2200DD96FA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{B9E8C10D-9E0E-42F1-8F2C-1E2200DD96FA}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{B9E8C10D-9E0E-42F1-8F2C-1E2200DD96FA}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{B9E8C10D-9E0E-42F1-8F2C-1E2200DD96FA}.Release|Any CPU.Build.0 = Release|Any CPU
+		{5F798F65-4226-49F9-8F01-B140507E9502}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{5F798F65-4226-49F9-8F01-B140507E9502}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{5F798F65-4226-49F9-8F01-B140507E9502}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{5F798F65-4226-49F9-8F01-B140507E9502}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE