Adding tests for users and roles

MainProject.Tests/Services/UserService_Tests.cs

@@ -15,6 +15,8 @@ using BasicDotnetTemplate.MainProject.Models.Api.Common.User;
 using BasicDotnetTemplate.MainProject.Models.Api.Common.Role;
 using BasicDotnetTemplate.MainProject.Models.Api.Response.Auth;
 using DatabaseSqlServer = BasicDotnetTemplate.MainProject.Models.Database.SqlServer;
+using BasicDotnetTemplate.MainProject.Models.Api.Data.User;
+using BasicDotnetTemplate.MainProject.Models.Database.SqlServer;
 
 
 
@@ -23,15 +25,29 @@ namespace BasicDotnetTemplate.MainProject.Tests;
 [TestClass]
 public class UserService_Tests
 {
+    protected static User? _expectedUser;
+    protected static User? _user;
+    protected static Role? _role;
+    protected static UserService? _userService;
+    protected static RoleService? _roleService;
+
+    [TestInitialize]
+    public void Setup()
+    {
+        _expectedUser = ModelsInit.CreateUser();
+        _userService = TestUtils.CreateUserService();
+        _roleService = TestUtils.CreateRoleService();
+    }
+
     [TestMethod]
     public void Inizialize()
     {
         try
         {
-            var userService = TestUtils.CreateUserService();
-            if (userService != null)
+            if (_userService != null)
             {
-                Assert.IsInstanceOfType(userService, typeof(UserService));
+                Assert.IsInstanceOfType(_userService, typeof(UserService));
+
             }
             else
             {
@@ -50,11 +66,10 @@ public class UserService_Tests
     {
         try
         {
-            var userService = TestUtils.CreateUserService();
             var testString = "test";
-            if (userService != null)
+            if (_userService != null)
             {
-                var user = await userService.GetUserByUsernameAndPassword(testString, testString);
+                var user = await _userService.GetUserByUsernameAndPassword(testString, testString);
                 Assert.IsTrue(user == null);
             }
             else
@@ -75,12 +90,12 @@ public class UserService_Tests
     {
         try
         {
-            var userService = TestUtils.CreateUserService();
+
             var testEmail = "test@email.it";
             var testPassword = "password";
-            if (userService != null)
+            if (_userService != null)
             {
-                var user = await userService.GetUserByUsernameAndPassword(testEmail, testPassword);
+                var user = await _userService.GetUserByUsernameAndPassword(testEmail, testPassword);
                 Assert.IsTrue(user != null);
                 Assert.IsTrue(user.Email == testEmail);
             }
@@ -96,6 +111,195 @@ public class UserService_Tests
         }
     }
 
+    [TestMethod]
+    public async Task CheckIfEmailIsValid_EmailNotExists()
+    {
+        try
+        {
+            if (_userService != null)
+            {
+                var valid = await _userService.CheckIfEmailIsValid(_expectedUser?.Email ?? String.Empty);
+                Assert.IsTrue(valid);
+            }
+            else
+            {
+                Assert.Fail($"UserService is null");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public async Task CreateUserData()
+    {
+        try
+        {
+            CreateUserRequestData data = new CreateUserRequestData()
+            {
+                FirstName = _expectedUser?.FirstName ?? String.Empty,
+                LastName = _expectedUser?.LastName ?? String.Empty,
+                Email = _expectedUser?.Email ?? String.Empty
+            };
+
+            Role role = new Role()
+            {
+                Name = _expectedUser?.Role?.Name ?? String.Empty,
+                IsNotEditable = _expectedUser?.Role?.IsNotEditable ?? false,
+                Guid = _expectedUser?.Role?.Guid ?? String.Empty
+            };
+
+            if (_userService != null)
+            {
+                var user = await _userService.CreateUserAsync(data, role);
+                Assert.IsInstanceOfType(user, typeof(User));
+                Assert.IsNotNull(user);
+                Assert.IsTrue(_expectedUser?.FirstName == user.FirstName);
+                Assert.IsTrue(_expectedUser?.LastName == user.LastName);
+                Assert.IsTrue(_expectedUser?.Email == user.Email);
+                Assert.IsTrue(_expectedUser?.Role?.Name == user.Role?.Name);
+                _user = user;
+                _role = user.Role;
+            }
+            else
+            {
+                Assert.Fail($"UserService is null");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public async Task CheckIfEmailIsValid_EmailCurrentUser()
+    {
+        try
+        {
+            if (_userService != null)
+            {
+                var valid = await _userService.CheckIfEmailIsValid(_expectedUser?.Email ?? String.Empty, _user?.Guid ?? String.Empty);
+                Assert.IsTrue(valid);
+            }
+            else
+            {
+                Assert.Fail($"UserService is null");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public async Task CheckIfEmailIsValid_EmailAlreadyExists()
+    {
+        try
+        {
+            if (_userService != null)
+            {
+                var valid = await _userService.CheckIfEmailIsValid(_expectedUser?.Email ?? String.Empty);
+                Assert.IsFalse(valid);
+            }
+            else
+            {
+                Assert.Fail($"UserService is null");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public async Task GetUserByIdAsync()
+    {
+        try
+        {
+            if (_userService != null)
+            {
+                var user = await _userService.GetUserByIdAsync(_user?.Id ?? 0);
+                Assert.IsNotNull(user);
+                Assert.IsTrue(user.Id == _user?.Id);
+            }
+            else
+            {
+                Assert.Fail($"UserService is null");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public async Task GetUserByGuidAsync()
+    {
+        try
+        {
+            if (_userService != null)
+            {
+                var user = await _userService.GetUserByGuidAsync(_user?.Guid ?? String.Empty);
+                Assert.IsNotNull(user);
+                Assert.IsTrue(user.Guid == _user?.Guid);
+            }
+            else
+            {
+                Assert.Fail($"UserService is null");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+    [TestMethod]
+    public async Task DeleteUser()
+    {
+        try
+        {
+            if (_userService != null)
+            {
+                var user = await _userService.GetUserByGuidAsync(_user?.Guid ?? String.Empty);
+                Assert.IsNotNull(user);
+                var deleted = await _userService.DeleteUserAsync(user);
+                Assert.IsTrue(deleted);
+            }
+            else
+            {
+                Assert.Fail($"UserService is null");
+            }
+        }
+        catch (Exception ex)
+        {
+            Console.WriteLine(ex.InnerException);
+            Assert.Fail($"An exception was thrown: {ex}");
+        }
+    }
+
+
+
+    [TestCleanup]
+    public static async Task CleanupAsync()
+    {
+        var role = await _roleService?.GetRoleByGuidAsync(_role?.Guid ?? String.Empty);
+        Assert.IsNotNull(role);
+        var deleted = await _roleService?.DeleteRoleAsync(role);
+        Assert.IsTrue(deleted);
+    }
 
 }