Merge pull request 'Better UnitTest and added documentation' (#45) from Matheo into master

Reviewed-on: #45

src/UnitTests/UnitTestDataContractJson.cs

@@ -12,16 +12,16 @@ namespace UnitTests
         /// <summary>
         /// Vérifie que la propriété FileName a la valeur par défaut "SauvegardeDonnees.json".
         /// </summary>
-        public class DataContractXmlTests
+        public class DataContractJsonTests
         {
             [Fact]
             public void FileName_Should_HaveDefaultValue()
             {
                 // Arrange
-                var dataContractXml = new DataContractJson();
+                var dataContractJson = new DataContractJson();
 
                 // Assert
-                Assert.Equal("SauvegardeDonnees.json", dataContractXml.FileName);
+                Assert.Equal("SauvegardeDonnees.json", dataContractJson.FileName);
             }
 
             /// <summary>
@@ -31,10 +31,28 @@ namespace UnitTests
             public void FilePath_Should_HaveDefaultValue()
             {
                 // Arrange
-                var dataContractXml = new DataContractJson();
+                var dataContractJson = new DataContractJson();
 
                 // Assert
-                Assert.Equal(Path.Combine(AppDomain.CurrentDomain.BaseDirectory), dataContractXml.FilePath);
+                Assert.Equal(Path.Combine(AppDomain.CurrentDomain.BaseDirectory), dataContractJson.FilePath);
+            }
+
+            /// <summary>
+            /// Vérifie que la propriété FilePath peut être assignée avec une autre valeur et que la valeur assignée est correcte.
+            /// </summary>
+            [Theory]
+            [InlineData("C:\\Data\\")]
+            [InlineData("D:\\Backup\\")]
+            public void FilePath_Should_BeAssignable(string filePath)
+            {
+                // Arrange
+                var dataContractJson = new DataContractJson();
+
+                // Act
+                dataContractJson.FilePath = filePath;
+
+                // Assert
+                Assert.Equal(filePath, dataContractJson.FilePath);
             }
         }
     }

src/UnitTests/UnitTestDataContractXml.cs

@@ -41,6 +41,24 @@ namespace UnitTests
                 // Assert
                 Assert.Equal(Path.Combine(AppDomain.CurrentDomain.BaseDirectory), dataContractXml.FilePath);
             }
+
+            /// <summary>
+            /// Vérifie que la propriété FilePath peut être assignée avec une autre valeur et que la valeur assignée est correcte.
+            /// </summary>
+            [Theory]
+            [InlineData("C:\\Data\\")]
+            [InlineData("D:\\Backup\\")]
+            public void FilePath_Should_BeAssignable(string filePath)
+            {
+                // Arrange
+                var dataContractXml = new DataContractXml();
+
+                // Act
+                dataContractXml.FilePath = filePath;
+
+                // Assert
+                Assert.Equal(filePath, dataContractXml.FilePath);
+            }
         }
     }
 }

src/UnitTests/UnitTestDataToPersist.cs

@@ -12,7 +12,7 @@ namespace UnitTests
     public class UnitTestDataToPersist
     {
         /// <summary>
-        ///  Vérifie que la propriété Oeuvres est initialisée et est une instance de ObservableCollection<Oeuvre>.
+        /// Vérifie que la propriété Oeuvres est initialisée et est une instance de ObservableCollection<Oeuvre>.
         /// </summary>
         [Fact]
         public void Oeuvres_Should_BeInitialized()
@@ -42,16 +42,20 @@ namespace UnitTests
         /// <summary>
         /// Vérifie que la propriété Oeuvres peut être assignée avec une autre collection d'œuvres et que la valeur assignée est correcte.
         /// </summary>
-        [Fact]
+        [Theory]
-        public void Oeuvres_Should_BeAssignable()
+        [InlineData(1)]
+        [InlineData(2)]
+        public void Oeuvres_Should_BeAssignable(int oeuvresCount)
         {
             // Arrange
             var dataToPersist = new DataToPersist();
-            var oeuvres = new ObservableCollection<Oeuvre>
+            var oeuvres = new ObservableCollection<Oeuvre>();
+
+            // Add oeuvresCount number of oeuvres
+            for (int i = 0; i < oeuvresCount; i++)
             {
-                new Oeuvre("Evangelion", new List<string> { "Action", "Future" }, "TV", "C'est une bonne série", 4, 150, "evangelion.jpg"),
+                oeuvres.Add(new Oeuvre($"Oeuvre{i}", new List<string>(), "Type", "Description", 0, 0, "Affiche"));
-                new Oeuvre("[Oshi No Ko]", new List<string> { "Action", "Future" }, "DVD", "A la fin il meurt", 2, 24, "oshinoko.png"),
+            }
-            };
 
             // Act
             dataToPersist.Oeuvres = oeuvres;
@@ -61,14 +65,22 @@ namespace UnitTests
         }
 
         /// <summary>
-        /// vérifie que la propriété Utilisateurs peut être assignée avec une autre liste d'utilisateurs et que la valeur assignée est correcte.
+        /// Vérifie que la propriété Utilisateurs peut être assignée avec une autre liste d'utilisateurs et que la valeur assignée est correcte.
         /// </summary>
-        [Fact]
+        [Theory]
-        public void Utilisateurs_Should_BeAssignable()
+        [InlineData(1)]
+        [InlineData(2)]
+        public void Utilisateurs_Should_BeAssignable(int utilisateursCount)
         {
             // Arrange
             var dataToPersist = new DataToPersist();
-            var utilisateurs = new List<Utilisateur> { new Utilisateur(), new Utilisateur() };
+            var utilisateurs = new List<Utilisateur>();
+
+            // Add utilisateursCount number of utilisateurs
+            for (int i = 0; i < utilisateursCount; i++)
+            {
+                utilisateurs.Add(new Utilisateur());
+            }
 
             // Act
             dataToPersist.Utilisateurs = utilisateurs;

src/UnitTests/UnitTestIPersistanceManager.cs

@@ -11,6 +11,9 @@ namespace UnitTests
 {
     public class UnitTestIPersistanceManager
     {
+        /// <summary>
+        /// Vérifie que la méthode ChargeDonne renvoie les données attendues.
+        /// </summary>
         [Fact]
         public void ChargeDonne_ReturnsExpectedData()
         {
@@ -48,8 +51,12 @@ namespace UnitTests
             Assert.Equal(12, utilisateur.age);
         }
 
+        /// <summary>
+        /// Vérifie que la méthode Sauvegarder appelle Console.WriteLine.
+        /// </summary>
         [Fact]
-        public void Sauvegarder_CallsConsoleWriteLine()
+        public void Sauvegarder_CallsConsoleWriteLine()  //pas besoin d'utiliser les attributs [Theory] et [InlineData]
+                                                         //car il ne teste pas différentes variations de données.
         {
             // Arrange
             var stub = new Stub.Stub();
@@ -60,9 +67,8 @@ namespace UnitTests
             stub.sauvegarder(oeuvres, utilisateurs);
 
             // Assert
-            // Since the implementation of Sauvegarder only calls Console.WriteLine,
+            // Étant donné que l'implémentation de Sauvegarder appelle uniquement Console.WriteLine,
-            // we can't directly test the functionality, but we can assert that the method was called
+            // nous ne pouvons pas tester directement la fonctionnalité, mais nous pouvons vérifier que la méthode a été appelée.
         }
     }
 }
-

src/UnitTests/UnitTestManager.cs

@@ -12,13 +12,16 @@ namespace UnitTests
 {
     public class UnitTestManager
     {
+        /// <summary>
+        /// Vérifie que la méthode Charger charge les données à partir de PersistanceManager (Stub).
+        /// </summary>
         [Fact]
         public void Charger_Should_LoadDataFromPersistanceManager_Stub()
         {
             // Arrange
             var persistanceStub = new Stub.Stub();
             var manager = new Manager(persistanceStub);
-            var oeuvres = new ObservableCollection<Oeuvre> 
+            var oeuvres = new ObservableCollection<Oeuvre>
             {
                 new Oeuvre("Evangelion", new List<string> { "Action", "Future" }, "TV", "C'est une bonne série", 4, 150, "evangelion.jpg"),
                 new Oeuvre("[Oshi No Ko]", new List<string> { "Action", "Future" }, "DVD", "A la fin il meurt", 2, 24, "oshinoko.png"),
@@ -41,17 +44,20 @@ namespace UnitTests
             Assert.Equal("evangelion.jpg", evangelion.Affiche);
         }
 
+        /// <summary>
+        /// Vérifie que la méthode Charger charge les données à partir de PersistanceManager (DataContractXml).
+        /// </summary>
         [Fact]
         public void Charger_Should_LoadDataFromPersistanceManager_DataContractXml()
         {
             // Arrange
             var persistanceXml = new DataContractPersistance.DataContractXml();
             var manager = new Manager(persistanceXml);
-            var oeuvres = new ObservableCollection<Oeuvre> 
+            var oeuvres = new ObservableCollection<Oeuvre>
             {
                 new Oeuvre("Evangelion", new List<string> { "Action", "Future" }, "TV", "C'est une bonne série", 4, 150, "evangelion.jpg"),
                 new Oeuvre("[Oshi No Ko]", new List<string> { "Action", "Future" }, "DVD", "A la fin il meurt", 2, 24, "oshinoko.png"),
-            };  
+            };
             var utilisateurs = new List<Utilisateur> { new Utilisateur(), new Utilisateur() };
 
             // Act
@@ -64,16 +70,19 @@ namespace UnitTests
             Assert.Equal(utilisateurs.Count, manager.Utilisateurs.Count);
         }
 
+        /// <summary>
+        /// Vérifie que la méthode Sauvegarder enregistre les données en utilisant PersistanceManager (DataContractXml).
+        /// </summary>
         [Fact]
         public void Sauvegarder_Should_SaveDataUsingPersistanceManager_DataContractXml()
         {
             // Arrange
             var persistanceXml = new DataContractPersistance.DataContractXml();
             var manager = new Manager(persistanceXml);
-            var oeuvres = new ObservableCollection<Oeuvre> 
+            var oeuvres = new ObservableCollection<Oeuvre>
-            { 
+            {
-                new Oeuvre("Evangelion", new List<string> { "Action", "Future" }, "TV", "C'est une bonne série", 4, 150, "evangelion.jpg"), 
+                new Oeuvre("Evangelion", new List<string> { "Action", "Future" }, "TV", "C'est une bonne série", 4, 150, "evangelion.jpg"),
-                new Oeuvre("[Oshi No Ko]", new List<string> { "Action", "Future" }, "DVD", "A la fin il meurt", 2, 24, "oshinoko.png"), 
+                new Oeuvre("[Oshi No Ko]", new List<string> { "Action", "Future" }, "DVD", "A la fin il meurt", 2, 24, "oshinoko.png"),
             };
             var utilisateurs = new List<Utilisateur> { new Utilisateur(), new Utilisateur() };
 

src/UnitTests/UnitTestOeuvre.cs

@@ -9,6 +9,16 @@ namespace UnitTests
 {
     public class UnitTestOeuvre
     {
+        /// <summary>
+        /// Vérifie que le constructeur de la classe Oeuvre initialise correctement les propriétés avec tous les paramètres.
+        /// </summary>
+        /// <param name="nom">Le nom de l'œuvre.</param>
+        /// <param name="genres">Les genres de l'œuvre.</param>
+        /// <param name="type">Le type de l'œuvre.</param>
+        /// <param name="description">La description de l'œuvre.</param>
+        /// <param name="note">La note de l'œuvre.</param>
+        /// <param name="nbEpisodes">Le nombre d'épisodes de l'œuvre.</param>
+        /// <param name="affiche">L'affiche de l'œuvre.</param>
         [Theory]
         [InlineData("[Oshi No Ko]", new string[] { "Action", "Drama", "Fantasy" }, "TV Series", "A thrilling anime series.", 9, 25, "oshinoko.png")]
         public void Oeuvre_Constructor_WithAllParameters_ShouldSetPropertiesCorrectly(
@@ -27,6 +37,14 @@ namespace UnitTests
             Assert.Equal(affiche, oeuvre.Affiche);
         }
 
+        /// <summary>
+        /// Vérifie que le constructeur de la classe Oeuvre initialise correctement les propriétés avec les paramètres requis.
+        /// </summary>
+        /// <param name="nom">Le nom de l'œuvre.</param>
+        /// <param name="type">Le type de l'œuvre.</param>
+        /// <param name="description">La description de l'œuvre.</param>
+        /// <param name="nbEpisodes">Le nombre d'épisodes de l'œuvre.</param>
+        /// <param name="affiche">L'affiche de l'œuvre.</param>
         [Theory]
         [InlineData("One Piece", "TV Series", "An epic adventure.", 1000, "onepiece.jpg")]
         public void Oeuvre_Constructor_WithRequiredParameters_ShouldSetPropertiesCorrectly(
@@ -45,6 +63,15 @@ namespace UnitTests
             Assert.Equal(affiche, oeuvre.Affiche);
         }
 
+        /// <summary>
+        /// Vérifie que la méthode AjouterEpisode augmente le nombre d'épisodes de l'œuvre du montant donné.
+        /// </summary>
+        /// <param name="nom">Le nom de l'œuvre.</param>
+        /// <param name="type">Le type de l'œuvre.</param>
+        /// <param name="description">La description de l'œuvre.</param>
+        /// <param name="nbEpisodes">Le nombre d'épisodes de l'œuvre.</param>
+        /// <param name="affiche">L'affiche de l'œuvre.</param>
+        /// <param name="nbEpisodesToAdd">Le nombre d'épisodes à ajouter.</param>
         [Theory]
         [InlineData("Naruto", "TV Series", "A ninja's journey.", 220, "evangelion.jpg", 50)]
         [InlineData("Dragon Ball", "TV Series", "A Saiyan's story.", 291, "evangelion.jpg", 20)]

src/UnitTests/UnitTestUtilisateur.cs

@@ -4,6 +4,15 @@ namespace UnitTests
 {
     public class UnitTestUtilisateur
     {
+        /// <summary>
+        /// Vérifie que le constructeur de la classe Utilisateur initialise correctement les propriétés.
+        /// </summary>
+        /// <param name="email">L'adresse e-mail de l'utilisateur.</param>
+        /// <param name="pseudo">Le pseudo de l'utilisateur.</param>
+        /// <param name="mdp">Le mot de passe de l'utilisateur.</param>
+        /// <param name="nom">Le nom de l'utilisateur.</param>
+        /// <param name="prenom">Le prénom de l'utilisateur.</param>
+        /// <param name="age">L'âge de l'utilisateur.</param>
         [Theory]
         [InlineData("test@test.com", "pseudo", "mdp", "John", "Doe", 30)]
         [InlineData("test2@test.com", "pseudo2", "mdp2", "Jane", "Smith", 25)]
@@ -21,6 +30,10 @@ namespace UnitTests
             Assert.Equal(age, utilisateur.age);
         }
 
+        /// <summary>
+        /// Vérifie que la méthode SupprimerUtilisateur réinitialise les propriétés de l'utilisateur à null.
+        /// </summary>
+        /// <param name="utilisateur">L'utilisateur à supprimer.</param>
         // Utilisez [MemberData] pour des jeux de données dynamiques
         [Theory]
         [MemberData(nameof(UtilisateursTestData.GetTestData), MemberType = typeof(UtilisateursTestData))]
@@ -38,6 +51,9 @@ namespace UnitTests
         }
     }
 
+    /// <summary>
+    /// Classe de données pour les tests de la classe Utilisateur.
+    /// </summary>
     public class UtilisateursTestData
     {
         public static IEnumerable<object[]> GetTestData()
@@ -46,4 +62,4 @@ namespace UnitTests
             yield return new object[] { new Utilisateur("test2@test.com", "pseudo2", "mdp2", "Jane", "Smith", 25) };
         }
     }
-}
+}