From db37ebbdcee7cce0e87218462487d5b63814830f Mon Sep 17 00:00:00 2001 From: csimonapastore Date: Mon, 17 Mar 2025 23:34:52 +0100 Subject: [PATCH] Adding tests for users and roles --- .../Controllers/UserController_Tests.cs | 14 +- .../Services/RoleService_Tests.cs | 234 ++++++++++++++++++ .../Services/UserService_Tests.cs | 222 ++++++++++++++++- MainProject.Tests/TestsUtils/TestUtils.cs | 10 + MainProject/Services/RoleService.cs | 25 +- MainProject/Services/UserService.cs | 18 ++ MainProject/Utils/ProgramUtils.cs | 2 +- 7 files changed, 501 insertions(+), 24 deletions(-) create mode 100644 MainProject.Tests/Services/RoleService_Tests.cs diff --git a/MainProject.Tests/Controllers/UserController_Tests.cs b/MainProject.Tests/Controllers/UserController_Tests.cs index 4355f94..c9f8862 100644 --- a/MainProject.Tests/Controllers/UserController_Tests.cs +++ b/MainProject.Tests/Controllers/UserController_Tests.cs @@ -33,20 +33,13 @@ namespace BasicDotnetTemplate.MainProject.Tests; [TestClass] public class UserControllerTests { - private IMapper? _mapper; - private Mock _userServiceMock; - private Mock _roleServiceMock; - private UserController _userController; + private Mock? _userServiceMock; + private Mock? _roleServiceMock; + private UserController? _userController; [TestInitialize] public void Setup() { - var config = new MapperConfiguration(cfg => - { - cfg.AddProfile(); - }); - - _mapper = config.CreateMapper(); IConfiguration configuration = TestUtils.CreateConfiguration(); _userServiceMock = new Mock(); _roleServiceMock = new Mock(); @@ -527,5 +520,4 @@ public class UserControllerTests Assert.Fail($"Response is null"); } } - } diff --git a/MainProject.Tests/Services/RoleService_Tests.cs b/MainProject.Tests/Services/RoleService_Tests.cs new file mode 100644 index 0000000..ee98675 --- /dev/null +++ b/MainProject.Tests/Services/RoleService_Tests.cs @@ -0,0 +1,234 @@ +using BasicDotnetTemplate.MainProject.Models.Settings; +using Microsoft.AspNetCore.Builder; +using Microsoft.EntityFrameworkCore; +using BasicDotnetTemplate.MainProject.Utils; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Configuration; +using Moq; +using Newtonsoft.Json; +using BasicDotnetTemplate.MainProject.Core.Database; +using BasicDotnetTemplate.MainProject.Services; +using BasicDotnetTemplate.MainProject.Models.Api.Response; +using BasicDotnetTemplate.MainProject.Models.Api.Request.Auth; +using BasicDotnetTemplate.MainProject.Models.Api.Data.Auth; +using BasicDotnetTemplate.MainProject.Models.Api.Common.Role; +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.Role; +using BasicDotnetTemplate.MainProject.Models.Database.SqlServer; +using BasicDotnetTemplate.MainProject.Models.Api.Data.Role; + + + +namespace BasicDotnetTemplate.MainProject.Tests; + +[TestClass] +public class RoleService_Tests +{ + protected static Role? _expectedRole; + protected static Role? _role; + protected static RoleService? _roleService; + + [TestInitialize] + public void Setup() + { + _expectedRole = ModelsInit.CreateRole(); + _roleService = TestUtils.CreateRoleService(); + } + + [TestMethod] + public void Inizialize() + { + try + { + if (_roleService != null) + { + Assert.IsInstanceOfType(_roleService, typeof(RoleService)); + } + else + { + Assert.Fail($"RoleService is null"); + } + } + catch (Exception ex) + { + Console.WriteLine(ex.InnerException); + Assert.Fail($"An exception was thrown: {ex}"); + } + } + + [TestMethod] + public async Task CheckIfNameIsValid_NameNotExists() + { + try + { + if (_roleService != null) + { + var valid = await _roleService.CheckIfNameIsValid(_expectedRole?.Name ?? String.Empty); + Assert.IsTrue(valid); + } + else + { + Assert.Fail($"RoleService is null"); + } + } + catch (Exception ex) + { + Console.WriteLine(ex.InnerException); + Assert.Fail($"An exception was thrown: {ex}"); + } + } + + [TestMethod] + public async Task CreateRoleData() + { + try + { + CreateRoleRequestData data = new CreateRoleRequestData() + { + Name = _expectedRole?.Name ?? String.Empty, + IsNotEditable = false + }; + + if (_roleService != null) + { + var role = await _roleService.CreateRoleAsync(data); + Assert.IsInstanceOfType(role, typeof(Role)); + Assert.IsNotNull(role); + Assert.IsTrue(_expectedRole?.Name == role.Name); + Assert.IsTrue(_expectedRole?.IsNotEditable == role.IsNotEditable); + _role = role; + } + else + { + Assert.Fail($"RoleService is null"); + } + } + catch (Exception ex) + { + Console.WriteLine(ex.InnerException); + Assert.Fail($"An exception was thrown: {ex}"); + } + } + + [TestMethod] + public async Task CheckIfNameIsValid_NameCurrentRole() + { + try + { + if (_roleService != null) + { + var valid = await _roleService.CheckIfNameIsValid(_expectedRole?.Name ?? String.Empty, _role?.Guid ?? String.Empty); + Assert.IsTrue(valid); + } + else + { + Assert.Fail($"RoleService is null"); + } + } + catch (Exception ex) + { + Console.WriteLine(ex.InnerException); + Assert.Fail($"An exception was thrown: {ex}"); + } + } + + [TestMethod] + public async Task CheckIfNameIsValid_NameAlreadyExists() + { + try + { + if (_roleService != null) + { + var valid = await _roleService.CheckIfNameIsValid(_expectedRole?.Name ?? String.Empty); + Assert.IsFalse(valid); + } + else + { + Assert.Fail($"RoleService is null"); + } + } + catch (Exception ex) + { + Console.WriteLine(ex.InnerException); + Assert.Fail($"An exception was thrown: {ex}"); + } + } + + [TestMethod] + public async Task GetRoleByIdAsync() + { + try + { + if (_roleService != null) + { + var role = await _roleService.GetRoleByIdAsync(_role?.Id ?? 0); + Assert.IsNotNull(role); + Assert.IsTrue(role.Id == _role?.Id); + } + else + { + Assert.Fail($"RoleService is null"); + } + } + catch (Exception ex) + { + Console.WriteLine(ex.InnerException); + Assert.Fail($"An exception was thrown: {ex}"); + } + } + + [TestMethod] + public async Task GetRoleByGuidAsync() + { + try + { + if (_roleService != null) + { + var role = await _roleService.GetRoleByGuidAsync(_role?.Guid ?? String.Empty); + Assert.IsNotNull(role); + Assert.IsTrue(role.Guid == _role?.Guid); + } + else + { + Assert.Fail($"RoleService is null"); + } + } + catch (Exception ex) + { + Console.WriteLine(ex.InnerException); + Assert.Fail($"An exception was thrown: {ex}"); + } + } + + [TestMethod] + public async Task DeleteRole() + { + try + { + if (_roleService != null) + { + var role = await _roleService.GetRoleByGuidAsync(_role?.Guid ?? String.Empty); + Assert.IsNotNull(role); + var deleted = await _roleService.DeleteRoleAsync(role); + Assert.IsTrue(deleted); + } + else + { + Assert.Fail($"RoleService is null"); + } + } + catch (Exception ex) + { + Console.WriteLine(ex.InnerException); + Assert.Fail($"An exception was thrown: {ex}"); + } + } + + +} + + + + diff --git a/MainProject.Tests/Services/UserService_Tests.cs b/MainProject.Tests/Services/UserService_Tests.cs index 77da091..a1cd018 100644 --- a/MainProject.Tests/Services/UserService_Tests.cs +++ b/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); + } } diff --git a/MainProject.Tests/TestsUtils/TestUtils.cs b/MainProject.Tests/TestsUtils/TestUtils.cs index fd8c317..262a14b 100644 --- a/MainProject.Tests/TestsUtils/TestUtils.cs +++ b/MainProject.Tests/TestsUtils/TestUtils.cs @@ -81,6 +81,16 @@ public static class TestUtils var httpContextAccessor = new Mock(); return new JwtService(httpContextAccessor.Object, configuration, sqlServerContext); } + + public static RoleService CreateRoleService() + { + IConfiguration configuration = CreateConfiguration(); + var optionsBuilder = new DbContextOptionsBuilder(); + optionsBuilder.UseSqlServer(GetSqlConnectionString(configuration)); + SqlServerContext sqlServerContext = new SqlServerContext(optionsBuilder.Options); + var httpContextAccessor = new Mock(); + return new RoleService(httpContextAccessor.Object, configuration, sqlServerContext); + } } diff --git a/MainProject/Services/RoleService.cs b/MainProject/Services/RoleService.cs index 038d1ba..d729d60 100644 --- a/MainProject/Services/RoleService.cs +++ b/MainProject/Services/RoleService.cs @@ -12,8 +12,9 @@ public interface IRoleService Task GetRoleByIdAsync(int id); Task GetRoleByGuidAsync(string guid); Task CheckIfNameIsValid(string name, string? guid = ""); - Task CreateRole(CreateRoleRequestData data); + Task CreateRoleAsync(CreateRoleRequestData data); Task GetRoleForUser(string? guid); + Task DeleteRoleAsync(Role role); } public class RoleService : BaseService, IRoleService @@ -29,7 +30,6 @@ public class RoleService : BaseService, IRoleService { return this._sqlServerContext.Roles.Where(x => !x.IsDeleted); } - private IQueryable GetRoleByNameQueryable(string name) { return this.GetRolesQueryable().Where(x => @@ -88,7 +88,7 @@ public class RoleService : BaseService, IRoleService return valid; } - public async Task CreateRole(CreateRoleRequestData data) + public async Task CreateRoleAsync(CreateRoleRequestData data) { Role? role = null; @@ -119,5 +119,24 @@ public class RoleService : BaseService, IRoleService return role; } + + public async Task DeleteRoleAsync(Role role) + { + bool? deleted = false; + + using (var transaction = _sqlServerContext.Database.BeginTransactionAsync()) + { + role.IsDeleted = true; + role.DeletionTime = DateTime.UtcNow; + _sqlServerContext.Update(role); + await _sqlServerContext.SaveChangesAsync(); + await (await transaction).CommitAsync(); + deleted = true; + } + + return deleted; + } + + } diff --git a/MainProject/Services/UserService.cs b/MainProject/Services/UserService.cs index 3a27c66..c5f5766 100644 --- a/MainProject/Services/UserService.cs +++ b/MainProject/Services/UserService.cs @@ -14,6 +14,7 @@ public interface IUserService Task GetUserByUsernameAndPassword(string email, string password); Task CheckIfEmailIsValid(string email, string? guid = ""); Task CreateUserAsync(CreateUserRequestData data, Role role); + Task DeleteUserAsync(User user); } public class UserService : BaseService, IUserService @@ -117,6 +118,23 @@ public class UserService : BaseService, IUserService return user; } + public async Task DeleteUserAsync(User user) + { + bool? deleted = false; + + using (var transaction = _sqlServerContext.Database.BeginTransactionAsync()) + { + user.IsDeleted = true; + user.DeletionTime = DateTime.UtcNow; + _sqlServerContext.Update(user); + await _sqlServerContext.SaveChangesAsync(); + await (await transaction).CommitAsync(); + deleted = true; + } + + return deleted; + } + } diff --git a/MainProject/Utils/ProgramUtils.cs b/MainProject/Utils/ProgramUtils.cs index c70a139..7b55858 100644 --- a/MainProject/Utils/ProgramUtils.cs +++ b/MainProject/Utils/ProgramUtils.cs @@ -256,7 +256,7 @@ public static class ProgramUtils Name = roleName, IsNotEditable = true }; - var createThread = Task.Run(() => roleService!.Invoke()?.CreateRole(data)); + var createThread = Task.Run(() => roleService!.Invoke()?.CreateRoleAsync(data)); Role? role = createThread.Result; if (role != null) {