Merge pull request #127 from EduardoKroetz/refactor/unit-tests

Refactor: refatorar testes de unidade

Hotel.Domain/Entities/CategoryEntity/Validate.cs

@@ -16,18 +16,18 @@ public override void Validate()
     public void ValidateName(string name)
     {
         if (string.IsNullOrEmpty(name))
-            throw new ValidationException("O nome da categoria é obrigatório.");
+            throw new ValidationException("Informe o nome da categoria");
     }
 
     public void ValidateDescription(string description)
     {
         if (string.IsNullOrEmpty(description))
-            throw new ValidationException("A descrição da categoria é obrigatório.");
+            throw new ValidationException("Informe a descrição da categoria");
     }
 
     public void ValidateAveragePrice(decimal price)
     {
         if (price < 0)
-            throw new ValidationException("O preço médio da categoria não pode ser negativo.");
+            throw new ValidationException("O preço médio da categoria não pode ser negativo");
     }
 }

Hotel.Domain/Entities/EmployeeEntity/PermissionMethods.cs

@@ -9,7 +9,7 @@ public partial class Employee
     public void AssignPermission(Permission permission)
     {
         if (Permissions.Contains(permission))
-            throw new ValidationException("Essa permissão já foi associada a esse funcionário.");
+            throw new ValidationException("Essa permissão já foi associada a esse funcionário");
         if (permission.IsActive)
             Permissions.Add(permission);
         else
@@ -22,7 +22,7 @@ public void UnassignPermission(Permission permission)
         if (Permissions.Contains(permission))
             Permissions.Remove(permission);
         else
-            throw new ValidationException("Essa permissão não está associada a esse funcionário.");
+            throw new ValidationException("Essa permissão não está associada a esse funcionário");
     }
 
 }

Hotel.Domain/Entities/EmployeeEntity/ResponsabilityMethods.cs

@@ -8,15 +8,15 @@ public partial class Employee : IResponsibilitiesMethods
     public void AddResponsibility(Responsibility responsibility)
     {
         if (Responsibilities.Contains(responsibility))
-            throw new ArgumentException("Essa responsabilidade já está atribuida.");
+            throw new ArgumentException("Essa responsabilidade já está atribuida a esse funcionário");
         Responsibilities.Add(responsibility);
     }
 
 
     public void RemoveResponsibility(Responsibility responsibility)
     {
         if (!Responsibilities.Contains(responsibility))
-            throw new ArgumentException("Essa responsabilidade não está atribuida.");
+            throw new ArgumentException("Essa responsabilidade não está atribuida a esse funcionário");
         Responsibilities.Remove(responsibility);
     }
 

Hotel.Domain/Entities/EmployeeEntity/UpdateProperties.cs

@@ -7,7 +7,7 @@ public partial class Employee
     public void ChangeSalary(decimal? salary)
     {
         if (salary < 0)
-            throw new ValidationException("O sálario do funcionário não pode ser menor ou igual a zero.");
+            throw new ValidationException("Salário deve ser maior ou igual a zero");
         Salary = salary;
     }
 }

Hotel.Domain/Entities/FeedbackEntity/Validate.cs

@@ -16,15 +16,13 @@ public override void Validate()
     public void ValidateRate(int rate)
     {
         if (rate > 10 || rate < 0)
-            throw new ValidationException("Informe uma avaliação válida.");
+            throw new ValidationException("A avaliação deve ser entre 1 e 10");
     }
 
     public void ValidateComment(string comment)
     {
         if (string.IsNullOrEmpty(comment))
-            throw new ValidationException("Informe o comentário do feedback.");
-        if (comment.Length > 500)
-            throw new ValidationException("Limite máximo de 500 caracteres por comentário foi atingido.");
+            throw new ValidationException("Informe o comentário do feedback");
     }
 
 }

Hotel.Domain/Entities/ReportEntity/UpdateProperties.cs

@@ -32,6 +32,11 @@ public void ChangeResolution(string resolution)
 
     public void Finish()
     {
+        if (Status == EStatus.Cancelled)
+            throw new ValidationException("Não é possível finalizar um relatório cancelado");
+        if (Status == EStatus.Finish)
+            throw new ValidationException("O relatório já está finalizado");
+
         if (Status == EStatus.Pending)
             Status = EStatus.Finish;
         else
@@ -41,6 +46,11 @@ public void Finish()
 
     public void Cancel()
     {
+        if (Status == EStatus.Cancelled)
+            throw new ValidationException("O relatório já está cancelado");
+        if (Status == EStatus.Finish)
+            throw new ValidationException("Não é possível cancelar um relatório finalizado");
+
         if (Status == EStatus.Pending)
             Status = EStatus.Cancelled;
         else

Hotel.Domain/Entities/ReportEntity/Validate.cs

@@ -17,9 +17,7 @@ public override void Validate()
     public void ValidateSummary(string summary)
     {
         if (string.IsNullOrEmpty(summary))
-            throw new ValidationException("O sumário do relatório é obrigatório.");
-        if (summary.Length > 50)
-            throw new ValidationException("Limite de 50 caracteres do sumário do relatório foi atingido.");
+            throw new ValidationException("Informe o sumário");
     }
 
     public void ValidateDescription(string description)

Hotel.Tests/UnitTests/Entities/AdminEntityTest.cs

@@ -10,19 +10,27 @@ public class AdminEntityTest
     public readonly Permission Permission = new("Permission", "Permission");
 
     [TestMethod]
-    public void ValidAdmin_MustBeValid()
+    public void NewAdminInstance_MustBeValid()
     {
-        var admin = new Admin(TestParameters.Name, TestParameters.Email, TestParameters.Phone, TestParameters.Password);
+        var admin = new Admin(TestParameters.Name, TestParameters.Email, TestParameters.Phone, "123");
+
+        Assert.IsFalse(admin.IsRootAdmin);
         Assert.IsTrue(admin.IsValid);
+        Assert.AreEqual(TestParameters.Name, admin.Name);
+        Assert.AreEqual(TestParameters.Email, admin.Email);
+        Assert.AreEqual(TestParameters.Phone, admin.Phone);
+        Assert.AreNotEqual("123", admin.PasswordHash);
+        Assert.AreEqual(0, admin.Permissions.Count);
+        Assert.IsNull(admin.Address);
+        Assert.IsNull(admin.DateOfBirth);
+        Assert.IsTrue(admin.IncompleteProfile);
     }
 
     [TestMethod]
-    [ExpectedException(typeof(ValidationException))]
-    public void ChangeAdminToRootAdmin_WithOutRootAdmin_MustBeInvalid()
+    public void ChangeAdminToRootAdmin_WithOutRootAdmin_ShouldThrowException()
     {
         var admin = new Admin(TestParameters.Name, TestParameters.Email, TestParameters.Phone, TestParameters.Password);
-        admin.ChangeToRootAdmin(TestParameters.Admin);
-        Assert.Fail();
+        var exception = Assert.ThrowsException<ValidationException>(() => admin.ChangeToRootAdmin(TestParameters.Admin));
     }
 
     [TestMethod]
@@ -34,14 +42,12 @@ public void AddPermission_MustBeAdded()
         Assert.AreEqual(1, admin.Permissions.Count);
     }
 
-
     [TestMethod]
-    [ExpectedException(typeof(ValidationException))]
-    public void AddSamePermission_ExpectedException()
+    public void AddSamePermission_ShouldThrowException()
     {
         var admin = new Admin(TestParameters.Name, TestParameters.Email, TestParameters.Phone, TestParameters.Password);
         admin.AddPermission(Permission);
-        admin.AddPermission(Permission);
+        var exception = Assert.ThrowsException<ValidationException>(() => admin.AddPermission(Permission));
         Assert.AreEqual(1, admin.Permissions.Count);
     }
 
@@ -56,11 +62,10 @@ public void RemovePermission_MustBeValid()
     }
 
     [TestMethod]
-    [ExpectedException(typeof(ValidationException))]
-    public void RemoveNonExistingPermission_ExpectedException()
+    public void RemoveNonExistingPermission_ShouldThrowException()
     {
         var admin = new Admin(TestParameters.Name, TestParameters.Email, TestParameters.Phone, TestParameters.Password);
-        admin.RemovePermission(Permission);
+        var exception = Assert.ThrowsException<ValidationException>(() => admin.RemovePermission(Permission));
         Assert.AreEqual(0, admin.Permissions.Count);
     }
-}
+}

Hotel.Tests/UnitTests/Entities/CategoryEntityTest.cs

@@ -7,21 +7,22 @@ namespace Hotel.Tests.UnitTests.Entities;
 public class CategoryEntityTest
 {
     [TestMethod]
-    public void ValidCategory_MustBeValid()
+    public void NewCategoryInstance_MustBeValid()
     {
         var category = new Category("Categoria", "Categoria", 1);
+
         Assert.IsTrue(category.IsValid);
+        Assert.AreEqual("Categoria",category.Name);
+        Assert.AreEqual("Categoria", category.Description);
+        Assert.AreEqual(1, category.AveragePrice);
     }
 
     [TestMethod]
-    [ExpectedException(typeof(ValidationException))]
-    [DataRow("", "", -1)]
-    [DataRow("Categoria", "", 1)]
-    [DataRow("", "Categoria", 1)]
-    [DataRow("Categoria", "Categoria", -1)]
-    public void InvalidCategoryParameters_ExpectedException(string name, string description, int averagePrice)
+    [DataRow("", "", -1, "Informe o nome da categoria")]
+    [DataRow("", "Categoria", 1, "Informe o nome da categoria")]
+    public void InvalidCategoryParameters_ShouldThrowException(string name, string description, int averagePrice, string errorMessage)
     {
-        new Category(name, description, averagePrice);
-        Assert.Fail();
+        var exception = Assert.ThrowsException<ValidationException>(() => new Category(name, description, averagePrice));
+        Assert.AreEqual(errorMessage, exception.Message);
     }
 }

Hotel.Tests/UnitTests/Entities/CustomerEntityTest.cs

@@ -6,9 +6,23 @@ namespace Hotel.Tests.UnitTests.Entities;
 public class CustomerEntityTest
 {
     [TestMethod]
-    public void ValidCustomer_MustBeValid()
+    public void NewCustomerInstance_MustBeValid()
     {
         var customer = new Customer(TestParameters.Name, TestParameters.Email, TestParameters.Phone, "password123");
+
         Assert.IsTrue(customer.IsValid);
+        Assert.AreEqual(TestParameters.Name, customer.Name);
+        Assert.AreEqual(TestParameters.Email, customer.Email);
+        Assert.AreEqual(TestParameters.Phone, customer.Phone);
+        Assert.AreNotEqual("password123", customer.PasswordHash);
+        Assert.AreEqual(0, customer.Feedbacks.Count);
+        Assert.AreEqual(0, customer.Invoices.Count);
+        Assert.AreEqual(0, customer.Reservations.Count);
+        Assert.AreEqual(0, customer.Dislikes.Count);
+        Assert.AreEqual(0, customer.Likes.Count);
+        Assert.AreEqual("", customer.StripeCustomerId);
+        Assert.IsNull(customer.Address);
+        Assert.IsNull(customer.DateOfBirth);
+        Assert.IsTrue(customer.IncompleteProfile);
     }
 }

Hotel.Tests/UnitTests/Entities/EmployeeEntityTest.cs

@@ -11,19 +11,17 @@ public class EmployeeEntityTest
     private readonly Responsibility Responsibility = new("Limpar os quartos", "Limpar", EPriority.Low);
 
     [TestMethod]
-    public void ValidEmployee_MustBeValid()
+    public void NewEmployeeInstance_MustBeValid()
     {
         var employee = new Employee(TestParameters.Name, TestParameters.Email, TestParameters.Phone, "password123");
         Assert.IsTrue(employee.IsValid);
     }
 
     [TestMethod]
-    [ExpectedException(typeof(ValidationException))]
-    public void ChangeToInvalidEmployeeSalary_ExpectedException()
+    public void ChangeToInvalidEmployeeSalary_ShouldThrowException()
     {
         var employee = new Employee(TestParameters.Name, TestParameters.Email, TestParameters.Phone, "password123");
-        employee.ChangeSalary(-1);
-        Assert.Fail();
+        var exception = Assert.ThrowsException<ValidationException>(() => employee.ChangeSalary(-1));
     }
 
     [TestMethod]
@@ -43,13 +41,12 @@ public void AddResponsibility_MustBeAdded()
     }
 
     [TestMethod]
-    [ExpectedException(typeof(ArgumentException))]
-    public void AddSameResponsibility_ExpectedException()
+    public void AddSameResponsibility_ShouldThrowException()
     {
         var employee = new Employee(TestParameters.Name, TestParameters.Email, TestParameters.Phone, "password123");
         employee.AddResponsibility(Responsibility);
-        employee.AddResponsibility(Responsibility);
-        Assert.Fail();
+        var exception = Assert.ThrowsException<ArgumentException>(() => employee.AddResponsibility(Responsibility));
+        Assert.AreEqual(1, employee.Responsibilities.Count);
     }
 
     [TestMethod]
@@ -62,37 +59,31 @@ public void RemoveResponsibility_MustBeRemoved()
     }
 
     [TestMethod]
-    [ExpectedException(typeof(ArgumentException))]
-    public void RemoveNonExistingResponsibility_ExpectedException()
+    public void RemoveNonExistingResponsibility_ShouldThrowException()
     {
         var employee = new Employee(TestParameters.Name, TestParameters.Email, TestParameters.Phone, "password123");
-        employee.RemoveResponsibility(Responsibility);
-        Assert.Fail();
+        var exception = Assert.ThrowsException<ArgumentException>(() => employee.RemoveResponsibility(Responsibility));
     }
 
-
     [TestMethod]
     public void AssignValidPermission_MustBeAssigned()
     {
         var employee = new Employee(TestParameters.Name, TestParameters.Email, TestParameters.Phone, TestParameters.Password);
         employee.AssignPermission(TestParameters.Permission);
-
         Assert.AreEqual(1, employee.Permissions.Count);
     }
 
-
     [TestMethod]
-    [ExpectedException(typeof(ValidationException))]
-    public void AssignSamePermission_ExpectedException()
+    public void AssignSamePermission_ShouldThrowException()
     {
         var employee = new Employee(TestParameters.Name, TestParameters.Email, TestParameters.Phone, TestParameters.Password);
         employee.AssignPermission(TestParameters.Permission);
-        employee.AssignPermission(TestParameters.Permission);
+        var exception = Assert.ThrowsException<ValidationException>(() => employee.AssignPermission(TestParameters.Permission));
         Assert.AreEqual(1, employee.Permissions.Count);
     }
 
     [TestMethod]
-    public void UnassignExistPermission_MustBeUnassign()
+    public void UnassignExistPermission_MustBeUnassigned()
     {
         var employee = new Employee(TestParameters.Name, TestParameters.Email, TestParameters.Phone, TestParameters.Password);
         employee.AssignPermission(TestParameters.Permission);
@@ -102,11 +93,9 @@ public void UnassignExistPermission_MustBeUnassign()
     }
 
     [TestMethod]
-    [ExpectedException(typeof(ValidationException))]
-    public void UnassignNonExistingPermission_ExpectedException()
+    public void UnassignNonExistingPermission_ShouldThrowException()
     {
         var employee = new Employee(TestParameters.Name, TestParameters.Email, TestParameters.Phone, TestParameters.Password);
-        employee.UnassignPermission(TestParameters.Permission);
-        Assert.AreEqual(0, employee.Permissions.Count);
+        var exception = Assert.ThrowsException<ValidationException>(() => employee.UnassignPermission(TestParameters.Permission));
     }
-}
+}

Hotel.Tests/UnitTests/Entities/FeedbackEntityTest.cs

@@ -7,35 +7,9 @@ namespace Hotel.Tests.UnitTests.Entities;
 public class FeedbackEntityTest
 {
     [TestMethod]
-    public void ValidFeedback_MustBeValid()
+    public void NewFeedbackInstance_MustBeValid()
     {
         var feedback = new Feedback("Feedback", 5, TestParameters.Customer.Id, TestParameters.Reservation.Id, TestParameters.Room.Id);
         Assert.IsTrue(feedback.IsValid);
     }
-
-    [TestMethod]
-    [ExpectedException(typeof(ValidationException))]
-    [DataRow("", 1)]
-    [DataRow("Feedback", -1)]
-    [DataRow("Feedback", 11)]
-    [DataRow(TestParameters.DescriptionMaxCaracteres, 5)]
-    public void InvalidFeedback_ExpectedException(string comment, int rate)
-    {
-        new Feedback(comment, rate, TestParameters.Customer.Id, TestParameters.Reservation.Id, TestParameters.Room.Id);
-        Assert.Fail();
-    }
-
-    [TestMethod]
-    [ExpectedException(typeof(ValidationException))]
-    [DataRow("", 1)]
-    [DataRow("Feedback", -1)]
-    [DataRow("Feedback", 11)]
-    [DataRow(TestParameters.DescriptionMaxCaracteres, 5)]
-    public void ChangeToInvalidFeedback_ExpectedException(string comment, int rate)
-    {
-        var feedback = new Feedback(comment, rate, TestParameters.Customer.Id, TestParameters.Reservation.Id, TestParameters.Room.Id);
-        feedback.ChangeComment(comment);
-        feedback.ChangeRate(rate);
-        Assert.Fail();
-    }
-}
+}