diff options
Diffstat (limited to 'src/DevHive.Tests')
24 files changed, 4441 insertions, 0 deletions
diff --git a/src/DevHive.Tests/DevHive.Data.Tests/CommentRepository.Tests.cs b/src/DevHive.Tests/DevHive.Data.Tests/CommentRepository.Tests.cs new file mode 100644 index 0000000..9cbb43b --- /dev/null +++ b/src/DevHive.Tests/DevHive.Data.Tests/CommentRepository.Tests.cs @@ -0,0 +1,99 @@ +using System; +using System.Threading.Tasks; +using DevHive.Data.Models; +using DevHive.Data.Repositories; +using Microsoft.EntityFrameworkCore; +using NUnit.Framework; + +namespace DevHive.Data.Tests +{ + [TestFixture] + public class CommentRepositoryTests + { + private const string COMMENT_MESSAGE = "Comment message"; + + protected DevHiveContext Context { get; set; } + + protected CommentRepository CommentRepository { get; set; } + + #region Setups + [SetUp] + public void Setup() + { + var optionsBuilder = new DbContextOptionsBuilder<DevHiveContext>() + .UseInMemoryDatabase(databaseName: "DevHive_Test_Database"); + + this.Context = new DevHiveContext(optionsBuilder.Options); + + CommentRepository = new CommentRepository(Context); + } + + [TearDown] + public void TearDown() + { + this.Context.Database.EnsureDeleted(); + } + #endregion + + #region GetCommentByIssuerAndTimeCreatedAsync + [Test] + public async Task GetCommentByCreatorAndTimeCreatedAsync_ReturnsTheCorrectComment_IfItExists() + { + Comment comment = await this.AddEntity(); + + Comment resultComment = await this.CommentRepository.GetCommentByIssuerAndTimeCreatedAsync(comment.Creator.Id, comment.TimeCreated); + + Assert.AreEqual(comment.Id, resultComment.Id, "GetCommentByIssuerAndTimeCreatedAsync does not return the corect comment when it exists"); + } + + [Test] + public async Task GetPostByCreatorAndTimeCreatedAsync_ReturnsNull_IfThePostDoesNotExist() + { + Comment comment = await this.AddEntity(); + + Comment resultComment = await this.CommentRepository.GetCommentByIssuerAndTimeCreatedAsync(Guid.Empty, DateTime.Now); + + Assert.IsNull(resultComment, "GetCommentByIssuerAndTimeCreatedAsync does not return null when the comment does not exist"); + } + #endregion + + #region DoesCommentExist + [Test] + public async Task DoesCommentExist_ReturnsTrue_WhenTheCommentExists() + { + Comment comment = await this.AddEntity(); + + bool result = await this.CommentRepository.DoesCommentExist(comment.Id); + + Assert.IsTrue(result, "DoesCommentExist does not return true whenm the Comment exists"); + } + + [Test] + public async Task DoesCommentExist_ReturnsFalse_WhenTheCommentDoesNotExist() + { + bool result = await this.CommentRepository.DoesCommentExist(Guid.Empty); + + Assert.IsFalse(result, "DoesCommentExist does not return false whenm the Comment" + + " does not exist"); + } + #endregion + + #region HelperMethods + private async Task<Comment> AddEntity(string name = COMMENT_MESSAGE) + { + User creator = new User { Id = Guid.NewGuid() }; + Comment comment = new Comment + { + Message = COMMENT_MESSAGE, + Creator = creator, + TimeCreated = DateTime.Now + }; + + this.Context.Comments.Add(comment); + await this.Context.SaveChangesAsync(); + + return comment; + } + #endregion + } +} diff --git a/src/DevHive.Tests/DevHive.Data.Tests/DevHive.Data.Tests.csproj b/src/DevHive.Tests/DevHive.Data.Tests/DevHive.Data.Tests.csproj new file mode 100644 index 0000000..d320450 --- /dev/null +++ b/src/DevHive.Tests/DevHive.Data.Tests/DevHive.Data.Tests.csproj @@ -0,0 +1,25 @@ +<Project Sdk="Microsoft.NET.Sdk"> + + <PropertyGroup> + <TargetFramework>net5.0</TargetFramework> + + <IsPackable>false</IsPackable> + </PropertyGroup> + + <ItemGroup> + <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="5.0.1" /> + <PackageReference Include="Moq" Version="4.16.0" /> + <PackageReference Include="NUnit" Version="3.13.0" /> + <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" /> + <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.8.3" /> + </ItemGroup> + + <ItemGroup> + <ProjectReference Include="..\..\DevHive.Data\DevHive.Data.csproj" /> + </ItemGroup> + + <PropertyGroup> + <EnableNETAnalyzers>true</EnableNETAnalyzers> + <AnalysisLevel>latest</AnalysisLevel> + </PropertyGroup> +</Project> diff --git a/src/DevHive.Tests/DevHive.Data.Tests/FeedRepository.Tests.cs b/src/DevHive.Tests/DevHive.Data.Tests/FeedRepository.Tests.cs new file mode 100644 index 0000000..f134bf3 --- /dev/null +++ b/src/DevHive.Tests/DevHive.Data.Tests/FeedRepository.Tests.cs @@ -0,0 +1,119 @@ +using System; +using System.Collections.Generic; +using System.Threading.Tasks; +using DevHive.Data.Models; +using DevHive.Data.Repositories; +using Microsoft.EntityFrameworkCore; +using NUnit.Framework; + +namespace DevHive.Data.Tests +{ + [TestFixture] + public class FeedRepositoryTests + { + protected DevHiveContext Context { get; set; } + + protected FeedRepository FeedRepository { get; set; } + + #region Setups + [SetUp] + public void Setup() + { + var optionsBuilder = new DbContextOptionsBuilder<DevHiveContext>() + .UseInMemoryDatabase(databaseName: "DevHive_Test_Database"); + + this.Context = new DevHiveContext(optionsBuilder.Options); + + FeedRepository = new FeedRepository(Context); + } + + [TearDown] + public void TearDown() + { + this.Context.Database.EnsureDeleted(); + } + #endregion + + #region GetFriendsPosts + [Test] + public async Task GetFriendsPosts_ReturnsListOfPosts_WhenTheyExist() + { + User dummyUser = this.CreateDummyUser(); + List<User> friendsList = new List<User>(); + friendsList.Add(dummyUser); + + DateTime dateTime = new DateTime(3000, 05, 09, 9, 15, 0); + Console.WriteLine(dateTime.ToFileTime()); + + Post dummyPost = this.CreateDummyPost(dummyUser); + Post anotherDummnyPost = this.CreateDummyPost(dummyUser); + + const int PAGE_NUMBER = 1; + const int PAGE_SIZE = 10; + + List<Post> resultList = await this.FeedRepository.GetFriendsPosts(friendsList, dateTime, PAGE_NUMBER, PAGE_SIZE); + + Assert.GreaterOrEqual(2, resultList.Count, "GetFriendsPosts does not return all correct posts"); + } + + [Test] + public async Task GetFriendsPosts_ReturnsNull_WhenNoSuitablePostsExist() + { + User dummyUser = this.CreateDummyUser(); + List<User> friendsList = new List<User>(); + friendsList.Add(dummyUser); + + DateTime dateTime = new DateTime(3000, 05, 09, 9, 15, 0); + + const int PAGE_NUMBER = 1; + const int PAGE_SIZE = 10; + + List<Post> resultList = await this.FeedRepository.GetFriendsPosts(friendsList, dateTime, PAGE_NUMBER, PAGE_SIZE); + + Assert.LessOrEqual(0, resultList.Count, "GetFriendsPosts does not return all correct posts"); + } + #endregion + + #region HelperMethods + private User CreateDummyUser() + { + HashSet<Role> roles = new() + { + new Role() + { + Id = Guid.NewGuid(), + Name = Role.DefaultRole + }, + }; + + return new() + { + Id = Guid.NewGuid(), + UserName = "pioneer10", + FirstName = "Spas", + LastName = "Spasov", + Email = "abv@abv.bg", + Roles = roles + }; + } + + private Post CreateDummyPost(User poster) + { + const string POST_MESSAGE = "random message"; + Guid id = Guid.NewGuid(); + Post post = new Post + { + Id = id, + Message = POST_MESSAGE, + Creator = poster, + TimeCreated = new DateTime(2000, 05, 09, 9, 15, 0) + }; + + this.Context.Posts.Add(post); + this.Context.SaveChanges(); + + return post; + } + #endregion + } +} diff --git a/src/DevHive.Tests/DevHive.Data.Tests/LenguageRepository.Tests.cs b/src/DevHive.Tests/DevHive.Data.Tests/LenguageRepository.Tests.cs new file mode 100644 index 0000000..f02a1e4 --- /dev/null +++ b/src/DevHive.Tests/DevHive.Data.Tests/LenguageRepository.Tests.cs @@ -0,0 +1,116 @@ +using System; +using System.Linq; +using System.Threading.Tasks; +using DevHive.Data.Models; +using DevHive.Data.Repositories; +using Microsoft.EntityFrameworkCore; +using NUnit.Framework; + +namespace DevHive.Data.Tests +{ + [TestFixture] + public class LenguageRepositoryTests + { + private const string LANGUAGE_NAME = "Language test name"; + protected DevHiveContext Context { get; set; } + protected LanguageRepository LanguageRepository { get; set; } + + #region Setups + [SetUp] + public void Setup() + { + var optionsBuilder = new DbContextOptionsBuilder<DevHiveContext>() + .UseInMemoryDatabase(databaseName: "DevHive_Test_Database"); + + this.Context = new DevHiveContext(optionsBuilder.Options); + + LanguageRepository = new LanguageRepository(Context); + } + + [TearDown] + public void TearDown() + { + this.Context.Database.EnsureDeleted(); + } + #endregion + + #region GetByNameAsync + [Test] + public async Task GetByNameAsync_ReturnsTheCorrectLanguage_IfItExists() + { + await AddEntity(); + + Language language = this.Context.Languages.Where(x => x.Name == LANGUAGE_NAME).ToList().FirstOrDefault(); + + Language languageResult = await this.LanguageRepository.GetByNameAsync(LANGUAGE_NAME); + + Assert.AreEqual(language.Id, languageResult.Id); + } + + [Test] + public async Task GetByNameAsync_ReturnsNull_IfTechnologyDoesNotExists() + { + Language languageResult = await this.LanguageRepository.GetByNameAsync(LANGUAGE_NAME); + + Assert.IsNull(languageResult); + } + #endregion + + #region DoesLanguageExistAsync + [Test] + public async Task DoesLanguageExist_ReturnsTrue_IfIdExists() + { + await AddEntity(); + Language language = this.Context.Languages.Where(x => x.Name == LANGUAGE_NAME).ToList().FirstOrDefault(); + + Guid id = language.Id; + + bool result = await this.LanguageRepository.DoesLanguageExistAsync(id); + + Assert.IsTrue(result, "DoesLanguageExistAsync returns flase when language exists"); + } + + [Test] + public async Task DoesLanguageExist_ReturnsFalse_IfIdDoesNotExists() + { + Guid id = Guid.NewGuid(); + + bool result = await this.LanguageRepository.DoesLanguageExistAsync(id); + + Assert.IsFalse(result, "DoesLanguageExistAsync returns true when language does not exist"); + } + #endregion + + #region DoesTechnologyNameExistAsync + [Test] + public async Task DoesLanguageNameExist_ReturnsTrue_IfLanguageExists() + { + await AddEntity(); + + bool result = await this.LanguageRepository.DoesLanguageNameExistAsync(LANGUAGE_NAME); + + Assert.IsTrue(result, "DoesLanguageNameExists returns true when language name does not exist"); + } + + [Test] + public async Task DoesLanguageNameExist_ReturnsFalse_IfLanguageDoesNotExists() + { + bool result = await this.LanguageRepository.DoesLanguageNameExistAsync(LANGUAGE_NAME); + + Assert.False(result, "DoesTechnologyNameExistAsync returns true when language name does not exist"); + } + #endregion + + #region HelperMethods + private async Task AddEntity(string name = LANGUAGE_NAME) + { + Language language = new Language + { + Name = name + }; + + await this.LanguageRepository.AddAsync(language); + } + #endregion + } +} diff --git a/src/DevHive.Tests/DevHive.Data.Tests/PostRepository.Tests.cs b/src/DevHive.Tests/DevHive.Data.Tests/PostRepository.Tests.cs new file mode 100644 index 0000000..6dacf0b --- /dev/null +++ b/src/DevHive.Tests/DevHive.Data.Tests/PostRepository.Tests.cs @@ -0,0 +1,145 @@ +using System; +using System.Collections.Generic; +using System.Threading.Tasks; +using DevHive.Data.Interfaces.Repositories; +using DevHive.Data.Models; +using DevHive.Data.RelationModels; +using DevHive.Data.Repositories; +using Microsoft.EntityFrameworkCore; +using Moq; +using NUnit.Framework; + +namespace DevHive.Data.Tests +{ + [TestFixture] + public class PostRepositoryTests + { + private const string POST_MESSAGE = "Post test message"; + + private DevHiveContext Context { get; set; } + + private Mock<IUserRepository> UserRepository { get; set; } + + private PostRepository PostRepository { get; set; } + + #region Setups + [SetUp] + public void Setup() + { + var optionsBuilder = new DbContextOptionsBuilder<DevHiveContext>() + .UseInMemoryDatabase(databaseName: "DevHive_Test_Database"); + + this.Context = new DevHiveContext(optionsBuilder.Options); + + this.UserRepository = new Mock<IUserRepository>(); + + PostRepository = new PostRepository(Context, this.UserRepository.Object); + } + + [TearDown] + public void TearDown() + { + this.Context.Database.EnsureDeleted(); + } + #endregion + + #region AddNewPostToCreator + // [Test] + // public async Task AddNewPostToCreator_ReturnsTrue_WhenNewPostIsAddedToCreator() + // { + // Post post = await this.AddEntity(); + // User user = new User { Id = Guid.NewGuid() }; + // + // this.UserRepository.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(user)); + // + // bool result = await this.PostRepository.AddNewPostToCreator(user.Id, post); + // + // Assert.IsTrue(result, "AddNewPostToCreator does not return true when Post Is Added To Creator successfully"); + // } + #endregion + + #region GetByIdAsync + [Test] + public async Task GetByNameAsync_ReturnsTheCorrectPost_IfItExists() + { + Post post = await AddEntity(); + + Post resultTechnology = await this.PostRepository.GetByIdAsync(post.Id); + + Assert.AreEqual(post.Id, resultTechnology.Id, "GetByIdAsync does not return the correct post"); + } + + [Test] + public async Task GetByIdAsync_ReturnsNull_IfTechnologyDoesNotExists() + { + Post resultPost = await this.PostRepository.GetByIdAsync(Guid.NewGuid()); + + Assert.IsNull(resultPost); + } + #endregion + + #region GetPostByCreatorAndTimeCreatedAsync + [Test] + public async Task GetPostByCreatorAndTimeCreatedAsync_ReturnsTheCorrectPost_IfItExists() + { + Post post = await this.AddEntity(); + + Post resultPost = await this.PostRepository.GetPostByCreatorAndTimeCreatedAsync(post.Creator.Id, post.TimeCreated); + + Assert.AreEqual(post.Id, resultPost.Id, "GetPostByCreatorAndTimeCreatedAsync does not return the corect post when it exists"); + } + + [Test] + public async Task GetPostByCreatorAndTimeCreatedAsync_ReturnsNull_IfThePostDoesNotExist() + { + Post post = await this.AddEntity(); + + Post resutPost = await this.PostRepository.GetPostByCreatorAndTimeCreatedAsync(Guid.Empty, DateTime.Now); + + Assert.IsNull(resutPost, "GetPostByCreatorAndTimeCreatedAsync does not return null when the post does not exist"); + } + #endregion + + #region DoesPostExist + [Test] + public async Task DoesPostExist_ReturnsTrue_WhenThePostExists() + { + Post post = await this.AddEntity(); + + bool result = await this.PostRepository.DoesPostExist(post.Id); + + Assert.IsTrue(result, "DoesPostExist does not return true whenm the Post exists"); + } + + [Test] + public async Task DoesPostExist_ReturnsFalse_WhenThePostDoesNotExist() + { + bool result = await this.PostRepository.DoesPostExist(Guid.Empty); + + Assert.IsFalse(result, "DoesPostExist does not return false whenm the Post does not exist"); + } + #endregion + + #region HelperMethods + private async Task<Post> AddEntity(string name = POST_MESSAGE) + { + User creator = new User { Id = Guid.NewGuid() }; + await this.Context.Users.AddAsync(creator); + Post post = new Post + { + Message = POST_MESSAGE, + Id = Guid.NewGuid(), + Creator = creator, + TimeCreated = DateTime.Now, + Attachments = new List<PostAttachments> { new PostAttachments { FileUrl = "kur" }, new PostAttachments { FileUrl = "za" }, new PostAttachments { FileUrl = "tva" } }, + Comments = new List<Comment>() + }; + + await this.Context.Posts.AddAsync(post); + await this.Context.SaveChangesAsync(); + + return post; + } + #endregion + } +} diff --git a/src/DevHive.Tests/DevHive.Data.Tests/RoleRepository.Tests.cs b/src/DevHive.Tests/DevHive.Data.Tests/RoleRepository.Tests.cs new file mode 100644 index 0000000..7f62c24 --- /dev/null +++ b/src/DevHive.Tests/DevHive.Data.Tests/RoleRepository.Tests.cs @@ -0,0 +1,119 @@ +using System; +using System.Linq; +using System.Threading.Tasks; +using DevHive.Data.Models; +using DevHive.Data.Repositories; +using Microsoft.EntityFrameworkCore; +using NUnit.Framework; + +namespace DevHive.Data.Tests +{ + [TestFixture] + public class RoleRepositoryTests + { + private const string ROLE_NAME = "Role test name"; + + protected DevHiveContext Context { get; set; } + + protected RoleRepository RoleRepository { get; set; } + + #region Setups + [SetUp] + public void Setup() + { + var optionsBuilder = new DbContextOptionsBuilder<DevHiveContext>() + .UseInMemoryDatabase(databaseName: "DevHive_Test_Database"); + + this.Context = new DevHiveContext(optionsBuilder.Options); + + RoleRepository = new RoleRepository(Context); + } + + [TearDown] + public void TearDown() + { + this.Context.Database.EnsureDeleted(); + } + #endregion + + #region GetByNameAsync + [Test] + public async Task GetByNameAsync_ReturnsTheRole_WhenItExists() + { + Role role = await this.AddEntity(); + + Role resultRole = await this.RoleRepository.GetByNameAsync(role.Name); + + Assert.AreEqual(role.Id, resultRole.Id, "GetByNameAsync does not return the correct role"); + } + + [Test] + public async Task GetByNameAsync_ReturnsNull_WhenTheRoleDoesNotExist() + { + Role resultRole = await this.RoleRepository.GetByNameAsync(ROLE_NAME); + + Assert.IsNull(resultRole, "GetByNameAsync does not return when the role does not exist"); + } + #endregion + + #region DoesNameExist + [Test] + public async Task DoesNameExist_ReturnsTrue_WhenTheNameExists() + { + Role role = await this.AddEntity(); + + bool result = await this.RoleRepository.DoesNameExist(role.Name); + + Assert.IsTrue(result, "DoesNameExist returns false when the role name exist"); + } + + [Test] + public async Task DoesNameExist_ReturnsFalse_WhenTheNameDoesNotExist() + { + bool result = await this.RoleRepository.DoesNameExist(ROLE_NAME); + + Assert.IsFalse(result, "DoesNameExist returns false when the role name exist"); + } + #endregion + + #region DoesRoleExist + [Test] + public async Task DoesRoleExist_ReturnsTrue_IfIdExists() + { + await AddEntity(); + Role role = this.Context.Roles.Where(x => x.Name == ROLE_NAME).ToList().FirstOrDefault(); + Guid id = role.Id; + + bool result = await this.RoleRepository.DoesRoleExist(id); + + Assert.IsTrue(result, "DoesRoleExistAsync returns flase when role exists"); + } + + [Test] + public async Task DoesRoleExist_ReturnsFalse_IfIdDoesNotExists() + { + Guid id = Guid.NewGuid(); + + bool result = await this.RoleRepository.DoesRoleExist(id); + + Assert.IsFalse(result, "DoesRoleExist returns true when role does not exist"); + } + #endregion + + #region HelperMethods + private async Task<Role> AddEntity(string name = ROLE_NAME) + { + Role role = new Role + { + Id = Guid.NewGuid(), + Name = name + }; + + this.Context.Roles.Add(role); + await this.Context.SaveChangesAsync(); + + return role; + } + #endregion + } +} diff --git a/src/DevHive.Tests/DevHive.Data.Tests/TechnologyRepository.Tests.cs b/src/DevHive.Tests/DevHive.Data.Tests/TechnologyRepository.Tests.cs new file mode 100644 index 0000000..d25fd3b --- /dev/null +++ b/src/DevHive.Tests/DevHive.Data.Tests/TechnologyRepository.Tests.cs @@ -0,0 +1,118 @@ +using DevHive.Data.Models; +using DevHive.Data.Repositories; +using Microsoft.EntityFrameworkCore; +using NUnit.Framework; +using System; +using System.Linq; +using System.Threading.Tasks; + +namespace DevHive.Data.Tests +{ + [TestFixture] + public class TechnologyRepositoryTests + { + private const string TECHNOLOGY_NAME = "Technology test name"; + + protected DevHiveContext Context { get; set; } + + protected TechnologyRepository TechnologyRepository { get; set; } + + #region Setups + [SetUp] + public void Setup() + { + var optionsBuilder = new DbContextOptionsBuilder<DevHiveContext>() + .UseInMemoryDatabase(databaseName: "DevHive_Test_Database"); + + this.Context = new DevHiveContext(optionsBuilder.Options); + + TechnologyRepository = new TechnologyRepository(Context); + } + + [TearDown] + public void TearDown() + { + this.Context.Database.EnsureDeleted(); + } + #endregion + + #region GetByNameAsync + [Test] + public async Task GetByNameAsync_ReturnsTheCorrectTechnology_IfItExists() + { + await AddEntity(); + + Technology technology = this.Context.Technologies.Where(x => x.Name == TECHNOLOGY_NAME).ToList().FirstOrDefault(); + + Technology resultTechnology = await this.TechnologyRepository.GetByNameAsync(TECHNOLOGY_NAME); + + Assert.AreEqual(technology.Id, resultTechnology.Id); + } + + [Test] + public async Task GetByNameAsync_ReturnsNull_IfTechnologyDoesNotExists() + { + Technology resultTechnology = await this.TechnologyRepository.GetByNameAsync(TECHNOLOGY_NAME); + + Assert.IsNull(resultTechnology); + } + #endregion + + #region DoesTechnologyExistAsync + [Test] + public async Task DoesTechnologyExist_ReturnsTrue_IfIdExists() + { + await AddEntity(); + Technology technology = this.Context.Technologies.Where(x => x.Name == TECHNOLOGY_NAME).ToList().FirstOrDefault(); + Guid id = technology.Id; + + bool result = await this.TechnologyRepository.DoesTechnologyExistAsync(id); + + Assert.IsTrue(result, "DoesTechnologyExistAsync returns flase hwen technology exists"); + } + + [Test] + public async Task DoesTechnologyExist_ReturnsFalse_IfIdDoesNotExists() + { + Guid id = Guid.NewGuid(); + + bool result = await this.TechnologyRepository.DoesTechnologyExistAsync(id); + + Assert.IsFalse(result, "DoesTechnologyExistAsync returns true when technology does not exist"); + } + #endregion + + #region DoesTechnologyNameExistAsync + [Test] + public async Task DoesTechnologyNameExist_ReturnsTrue_IfTechnologyExists() + { + await AddEntity(); + + bool result = await this.TechnologyRepository.DoesTechnologyNameExistAsync(TECHNOLOGY_NAME); + + Assert.IsTrue(result, "DoesTechnologyNameExists returns true when technology name does not exist"); + } + + [Test] + public async Task DoesTechnologyNameExist_ReturnsFalse_IfTechnologyDoesNotExists() + { + bool result = await this.TechnologyRepository.DoesTechnologyNameExistAsync(TECHNOLOGY_NAME); + + Assert.False(result, "DoesTechnologyNameExistAsync returns true when technology name does not exist"); + } + #endregion + + #region HelperMethods + private async Task AddEntity(string name = TECHNOLOGY_NAME) + { + Technology technology = new Technology + { + Name = name + }; + + this.Context.Technologies.Add(technology); + await this.Context.SaveChangesAsync(); + } + #endregion + } +} diff --git a/src/DevHive.Tests/DevHive.Data.Tests/UserRepositoryTests.cs b/src/DevHive.Tests/DevHive.Data.Tests/UserRepositoryTests.cs new file mode 100644 index 0000000..43e9a36 --- /dev/null +++ b/src/DevHive.Tests/DevHive.Data.Tests/UserRepositoryTests.cs @@ -0,0 +1,350 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Threading.Tasks; +using DevHive.Data.Models; +using DevHive.Data.Repositories; +using Microsoft.EntityFrameworkCore; +using NUnit.Framework; + +namespace DevHive.Data.Tests +{ + [TestFixture] + public class UserRepositoryTests + { + private DevHiveContext _context; + private UserRepository _userRepository; + + #region Setups + [SetUp] + public void Setup() + { + var options = new DbContextOptionsBuilder<DevHiveContext>() + .UseInMemoryDatabase("DevHive_UserRepository_Database"); + + this._context = new DevHiveContext(options.Options); + this._userRepository = new UserRepository(_context); + } + + [TearDown] + public async Task Teardown() + { + await this._context.Database.EnsureDeletedAsync(); + } + #endregion + + #region QueryAll + // [Test] + // public async Task QueryAll_ShouldReturnAllUsersFromDatabase_WhenTheyExist() + // { + // //Arrange + // User dummyUserOne = CreateDummyUser(); + // User dummyUserTwo = CreateAnotherDummyUser(); + // + // await this._userRepository.AddAsync(dummyUserOne); + // await this._userRepository.AddAsync(dummyUserTwo); + // + // //Act + // IEnumerable<User> users = this._userRepository.QueryAll(); + // + // //Assert + // Assert.AreEqual(2, users.Count(), "Method doesn't return all instances of user"); + // } + + // [Test] + // public void QueryAll_ReturnsNull_WhenNoUsersExist() + // { + // IEnumerable<User> users = this._userRepository.QueryAll(); + // + // Assert.AreEqual(0, users.Count(), "Method returns Users when there are non"); + // } + #endregion + + #region EditAsync + [Test] + public async Task EditAsync_ReturnsTrue_WhenUserIsUpdatedSuccessfully() + { + User oldUser = this.CreateDummyUser(); + this._context.Users.Add(oldUser); + await this._context.SaveChangesAsync(); + + oldUser.UserName = "SuperSecretUserName"; + bool result = await this._userRepository.EditAsync(oldUser.Id, oldUser); + + Assert.IsTrue(result, "EditAsync does not return true when User is updated successfully"); + } + #endregion + + #region GetByIdAsync + [Test] + public async Task GetByIdAsync_ReturnsTheUse_WhenItExists() + { + User dummyUserOne = CreateDummyUser(); + await this._userRepository.AddAsync(dummyUserOne); + + User resultUser = await this._userRepository.GetByIdAsync(dummyUserOne.Id); + + Assert.AreEqual(dummyUserOne.UserName, resultUser.UserName); + } + + [Test] + public async Task GetByIdAsync_ReturnsNull_WhenUserDoesNotExist() + { + Guid id = Guid.NewGuid(); + + User resultUser = await this._userRepository.GetByIdAsync(id); + + Assert.IsNull(resultUser); + } + #endregion + + #region GetByUsernameAsync + [Test] + public async Task GetByUsernameAsync_ReturnsUserFromDatabase_WhenItExists() + { + //Arrange + User dummyUser = CreateDummyUser(); + await this._userRepository.AddAsync(dummyUser); + string username = dummyUser.UserName; + + //Act + User user = await this._userRepository.GetByUsernameAsync(username); + + //Assert + Assert.AreEqual(dummyUser.Id, user.Id, "Method doesn't get the proper user from database"); + } + + [Test] + public async Task GetByUsernameAsync_ReturnsNull_WhenUserDoesNotExist() + { + //Act + User user = await this._userRepository.GetByUsernameAsync(null); + + //Assert + Assert.IsNull(user, "Method returns user when it does not exist"); + } + #endregion + + #region DoesUserExistAsync + [Test] + public async Task DoesUserExistAsync_ReturnsTrue_WhenUserExists() + { + User dummyUser = this.CreateDummyUser(); + this._context.Users.Add(dummyUser); + await this._context.SaveChangesAsync(); + + bool result = await this._userRepository.DoesUserExistAsync(dummyUser.Id); + + Assert.IsTrue(result, "DoesUserExistAsync does not return true when user exists"); + } + + [Test] + public async Task DoesUserExistAsync_ReturnsFalse_WhenUserDoesNotExist() + { + Guid id = Guid.NewGuid(); + + bool result = await this._userRepository.DoesUserExistAsync(id); + + Assert.IsFalse(result, "DoesUserExistAsync does not return false when user does not exist"); + } + #endregion + + #region DoesUserNameExistAsync + [Test] + public async Task DoesUsernameExistAsync_ReturnsTrue_WhenUserWithTheNameExists() + { + User dummyUser = this.CreateDummyUser(); + this._context.Users.Add(dummyUser); + await this._context.SaveChangesAsync(); + + bool result = await this._userRepository.DoesUsernameExistAsync(dummyUser.UserName); + + Assert.IsTrue(result, "DoesUserNameExistAsync does not return true when username exists"); + } + + [Test] + public async Task DoesUsernameExistAsync_ReturnsFalse_WhenUserWithTheNameDoesNotExist() + { + string userName = "Fake name"; + + bool result = await this._userRepository.DoesUsernameExistAsync(userName); + + Assert.IsFalse(result, "DoesUserNameExistAsync does not return false when username does not exist"); + } + #endregion + + #region DoesEmailExistAsync + [Test] + public async Task DoesEmailExistAsync_ReturnsTrue_WhenUserWithTheEmailExists() + { + User dummyUser = this.CreateDummyUser(); + this._context.Users.Add(dummyUser); + await this._context.SaveChangesAsync(); + + bool result = await this._userRepository.DoesEmailExistAsync(dummyUser.Email); + + Assert.IsTrue(result, "DoesUserNameExistAsync does not return true when email exists"); + } + + [Test] + public async Task DoesEmailExistAsync_ReturnsFalse_WhenUserWithTheEmailDoesNotExist() + { + string email = "Fake email"; + + bool result = await this._userRepository.DoesUsernameExistAsync(email); + + Assert.IsFalse(result, "DoesUserNameExistAsync does not return false when email does not exist"); + } + #endregion + + #region DoesUserHaveThisFriendAsync + //[Test] + //public async Task DoesUserHaveThisFriendAsync_ReturnsTrue_WhenUserHasTheGivenFriend() + //{ + // User dummyUser = this.CreateDummyUser(); + // User anotherDummyUser = this.CreateAnotherDummyUser(); + // HashSet<User> friends = new HashSet<User> + // { + // anotherDummyUser + // }; + // dummyUser.Friends = friends; + + // this._context.Users.Add(dummyUser); + // this._context.Users.Add(anotherDummyUser); + // await this._context.SaveChangesAsync(); + + // bool result = await this._userRepository.DoesUserHaveThisFriendAsync(dummyUser.Id, anotherDummyUser.Id); + + // Assert.IsTrue(result, "DoesUserHaveThisFriendAsync does not return true when user has the given friend"); + //} + + // [Test] + // public async Task DoesUserHaveThisFriendAsync_ReturnsFalse_WhenUserDoesNotHaveTheGivenFriend() + // { + // User dummyUser = this.CreateDummyUser(); + // User anotherDummyUser = this.CreateAnotherDummyUser(); + // + // this._context.Users.Add(dummyUser); + // this._context.Users.Add(anotherDummyUser); + // await this._context.SaveChangesAsync(); + // + // bool result = await this._userRepository.DoesUserHaveThisFriendAsync(dummyUser.Id, anotherDummyUser.Id); + // + // Assert.IsFalse(result, "DoesUserHaveThisFriendAsync does not return false when user des not have the given friend"); + // } + #endregion + + #region DoesUserHaveThisUsername + [Test] + public async Task DoesUserHaveThisUsername_ReturnsTrue_WhenUserHasTheGivenUsername() + { + User dummyUser = this.CreateDummyUser(); + this._context.Users.Add(dummyUser); + await this._context.SaveChangesAsync(); + + bool result = this._userRepository.DoesUserHaveThisUsername(dummyUser.Id, dummyUser.UserName); + + Assert.IsTrue(result, "DoesUserHaveThisUsername does not return true when the user has the given name"); + } + + [Test] + public async Task DoesUserHaveThisUsername_ReturnsFalse_WhenUserDoesntHaveTheGivenUsername() + { + string username = "Fake username"; + User dummyUser = this.CreateDummyUser(); + this._context.Users.Add(dummyUser); + await this._context.SaveChangesAsync(); + + bool result = this._userRepository.DoesUserHaveThisUsername(dummyUser.Id, username); + + Assert.IsFalse(result, "DoesUserNameExistAsync does not return false when user doesnt have the given name"); + } + #endregion + + #region HelperMethods + private User CreateDummyUser() + { + HashSet<Language> languages = new() + { + new Language() + { + Id = Guid.NewGuid(), + Name = "csharp" + }, + }; + + HashSet<Technology> technologies = new() + { + new Technology() + { + Id = Guid.NewGuid(), + Name = "ASP.NET Core" + }, + }; + + HashSet<Role> roles = new() + { + new Role() + { + Id = Guid.NewGuid(), + Name = Role.DefaultRole + }, + }; + + return new() + { + Id = Guid.NewGuid(), + UserName = "dummyUser", + FirstName = "Spas", + LastName = "Spasov", + Email = "abv@abv.bg", + Languages = languages, + Technologies = technologies, + Roles = roles + }; + } + + private User CreateAnotherDummyUser() + { + HashSet<Language> languages = new() + { + new Language() + { + Id = Guid.NewGuid(), + Name = "typescript" + }, + }; + + HashSet<Technology> technologies = new() + { + new Technology() + { + Id = Guid.NewGuid(), + Name = "Angular" + }, + }; + + HashSet<Role> roles = new() + { + new Role() + { + Id = Guid.NewGuid(), + Name = Role.DefaultRole + }, + }; + + return new() + { + Id = Guid.NewGuid(), + UserName = "anotherDummyUser", + FirstName = "Alex", + LastName = "Spiridonov", + Email = "a_spiridonov@abv.bg", + Languages = languages, + Technologies = technologies, + Roles = roles + }; + } + #endregion + } +} diff --git a/src/DevHive.Tests/DevHive.Services.Tests/CommentService.Tests.cs b/src/DevHive.Tests/DevHive.Services.Tests/CommentService.Tests.cs new file mode 100644 index 0000000..ac022ea --- /dev/null +++ b/src/DevHive.Tests/DevHive.Services.Tests/CommentService.Tests.cs @@ -0,0 +1,262 @@ +using System; +using System.Threading.Tasks; +using AutoMapper; +using DevHive.Data.Interfaces.Repositories; +using DevHive.Data.Models; +using DevHive.Services.Models.Comment; +using DevHive.Services.Services; +using Moq; +using NUnit.Framework; + +namespace DevHive.Services.Tests +{ + [TestFixture] + public class CommentServiceTests + { + private const string MESSAGE = "Gosho Trapov"; + private Mock<IUserRepository> UserRepositoryMock { get; set; } + private Mock<IPostRepository> PostRepositoryMock { get; set; } + private Mock<ICommentRepository> CommentRepositoryMock { get; set; } + private Mock<IMapper> MapperMock { get; set; } + private CommentService CommentService { get; set; } + + #region Setup + [SetUp] + public void Setup() + { + this.UserRepositoryMock = new Mock<IUserRepository>(); + this.PostRepositoryMock = new Mock<IPostRepository>(); + this.CommentRepositoryMock = new Mock<ICommentRepository>(); + this.MapperMock = new Mock<IMapper>(); + this.CommentService = new CommentService(this.UserRepositoryMock.Object, this.PostRepositoryMock.Object, this.CommentRepositoryMock.Object, this.MapperMock.Object); + } + #endregion + + #region AddComment + [Test] + public async Task AddComment_ReturnsNonEmptyGuid_WhenEntityIsAddedSuccessfully() + { + Guid id = Guid.NewGuid(); + User creator = new User { Id = Guid.NewGuid() }; + CreateCommentServiceModel createCommentServiceModel = new CreateCommentServiceModel + { + Message = MESSAGE + }; + Comment comment = new Comment + { + Message = MESSAGE, + Id = id, + }; + + this.CommentRepositoryMock.Setup(p => p.AddAsync(It.IsAny<Comment>())).Returns(Task.FromResult(true)); + this.CommentRepositoryMock.Setup(p => p.GetCommentByIssuerAndTimeCreatedAsync(It.IsAny<Guid>(), It.IsAny<DateTime>())).Returns(Task.FromResult(comment)); + this.PostRepositoryMock.Setup(p => p.DoesPostExist(It.IsAny<Guid>())).Returns(Task.FromResult(true)); + this.UserRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(creator)); + this.MapperMock.Setup(p => p.Map<Comment>(It.IsAny<CreateCommentServiceModel>())).Returns(comment); + + Guid result = await this.CommentService.AddComment(createCommentServiceModel); + + Assert.AreEqual(id, result); + } + + [Test] + public async Task AddComment_ReturnsEmptyGuid_WhenEntityIsNotAddedSuccessfully() + { + CreateCommentServiceModel createCommentServiceModel = new CreateCommentServiceModel + { + Message = MESSAGE + }; + Comment comment = new Comment + { + Message = MESSAGE, + }; + + this.CommentRepositoryMock.Setup(p => p.AddAsync(It.IsAny<Comment>())).Returns(Task.FromResult(false)); + this.PostRepositoryMock.Setup(p => p.DoesPostExist(It.IsAny<Guid>())).Returns(Task.FromResult(true)); + this.MapperMock.Setup(p => p.Map<Comment>(It.IsAny<CreateCommentServiceModel>())).Returns(comment); + + Guid result = await this.CommentService.AddComment(createCommentServiceModel); + + Assert.IsTrue(result == Guid.Empty); + } + + [Test] + public void AddComment_ThrowsException_WhenPostDoesNotExist() + { + const string EXCEPTION_MESSAGE = "Post does not exist!"; + + CreateCommentServiceModel createCommentServiceModel = new CreateCommentServiceModel + { + Message = MESSAGE + }; + + Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this.CommentService.AddComment(createCommentServiceModel), "AddComment does not throw excpeion when the post does not exist"); + + Assert.AreEqual(EXCEPTION_MESSAGE, ex.Message, "Incorecct exception message"); + } + #endregion + + #region GetCommentById + [Test] + public async Task GetCommentById_ReturnsTheComment_WhenItExists() + { + Guid creatorId = new Guid(); + User creator = new User { Id = creatorId }; + Comment comment = new Comment + { + Message = MESSAGE, + Creator = creator + }; + ReadCommentServiceModel commentServiceModel = new ReadCommentServiceModel + { + Message = MESSAGE + }; + User user = new User + { + Id = creatorId, + }; + + this.CommentRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(comment)); + this.UserRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(user)); + this.MapperMock.Setup(p => p.Map<ReadCommentServiceModel>(It.IsAny<Comment>())).Returns(commentServiceModel); + + ReadCommentServiceModel result = await this.CommentService.GetCommentById(new Guid()); + + Assert.AreEqual(MESSAGE, result.Message); + } + + [Test] + public void GetCommentById_ThorwsException_WhenTheUserDoesNotExist() + { + const string EXCEPTION_MESSAGE = "The user does not exist"; + Guid creatorId = new Guid(); + User creator = new User { Id = creatorId }; + Comment comment = new Comment + { + Message = MESSAGE, + Creator = creator + }; + + this.CommentRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(comment)); + + Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this.CommentService.GetCommentById(new Guid()), "GetCommentById does not throw exception when the user does not exist"); + + Assert.AreEqual(EXCEPTION_MESSAGE, ex.Message); + } + + [Test] + public void GetCommentById_ThrowsException_WhenCommentDoesNotExist() + { + string exceptionMessage = "The comment does not exist"; + Guid creatorId = new Guid(); + User user = new User + { + Id = creatorId, + }; + + this.CommentRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult<Comment>(null)); + this.UserRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(user)); + + Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this.CommentService.GetCommentById(new Guid())); + + Assert.AreEqual(exceptionMessage, ex.Message, "Incorecct exception message"); + } + #endregion + + #region UpdateComment + [Test] + public async Task UpdateComment_ReturnsTheIdOfTheComment_WhenUpdatedSuccessfully() + { + Guid id = Guid.NewGuid(); + Comment comment = new Comment + { + Id = id, + Message = MESSAGE + }; + UpdateCommentServiceModel updateCommentServiceModel = new UpdateCommentServiceModel + { + CommentId = id, + NewMessage = MESSAGE + }; + + this.CommentRepositoryMock.Setup(p => p.DoesCommentExist(It.IsAny<Guid>())).Returns(Task.FromResult(true)); + this.CommentRepositoryMock.Setup(p => p.EditAsync(It.IsAny<Guid>(), It.IsAny<Comment>())).Returns(Task.FromResult(true)); + this.CommentRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(comment)); + this.MapperMock.Setup(p => p.Map<Comment>(It.IsAny<UpdateCommentServiceModel>())).Returns(comment); + + Guid result = await this.CommentService.UpdateComment(updateCommentServiceModel); + + Assert.AreEqual(updateCommentServiceModel.CommentId, result); + } + + [Test] + public async Task UpdateComment_ReturnsEmptyId_WhenTheCommentIsNotUpdatedSuccessfully() + { + Comment comment = new Comment + { + Message = MESSAGE + }; + UpdateCommentServiceModel updateCommentServiceModel = new UpdateCommentServiceModel + { + CommentId = Guid.NewGuid(), + NewMessage = MESSAGE + }; + + this.CommentRepositoryMock.Setup(p => p.DoesCommentExist(It.IsAny<Guid>())).Returns(Task.FromResult(true)); + this.CommentRepositoryMock.Setup(p => p.EditAsync(It.IsAny<Guid>(), It.IsAny<Comment>())).Returns(Task.FromResult(false)); + this.MapperMock.Setup(p => p.Map<Comment>(It.IsAny<UpdateCommentServiceModel>())).Returns(comment); + + Guid result = await this.CommentService.UpdateComment(updateCommentServiceModel); + + Assert.AreEqual(Guid.Empty, result); + } + + [Test] + public void UpdateComment_ThrowsArgumentException_WhenCommentDoesNotExist() + { + string exceptionMessage = "Comment does not exist!"; + UpdateCommentServiceModel updateCommentServiceModel = new UpdateCommentServiceModel + { + }; + + this.CommentRepositoryMock.Setup(p => p.DoesCommentExist(It.IsAny<Guid>())).Returns(Task.FromResult(false)); + + Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this.CommentService.UpdateComment(updateCommentServiceModel)); + + Assert.AreEqual(exceptionMessage, ex.Message, "Incorecct exception message"); + } + #endregion + + #region DeleteComment + [Test] + [TestCase(true)] + [TestCase(false)] + public async Task DeleteComment_ShouldReturnIfDeletionIsSuccessfull_WhenCommentExists(bool shouldPass) + { + Guid id = new Guid(); + Comment comment = new Comment(); + + this.CommentRepositoryMock.Setup(p => p.DoesCommentExist(It.IsAny<Guid>())).Returns(Task.FromResult(true)); + this.CommentRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(comment)); + this.CommentRepositoryMock.Setup(p => p.DeleteAsync(It.IsAny<Comment>())).Returns(Task.FromResult(shouldPass)); + + bool result = await this.CommentService.DeleteComment(id); + + Assert.AreEqual(shouldPass, result); + } + + [Test] + public void DeleteComment_ThrowsException_WhenCommentDoesNotExist() + { + string exceptionMessage = "Comment does not exist!"; + Guid id = new Guid(); + + this.CommentRepositoryMock.Setup(p => p.DoesCommentExist(It.IsAny<Guid>())).Returns(Task.FromResult(false)); + + Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this.CommentService.DeleteComment(id)); + + Assert.AreEqual(exceptionMessage, ex.Message, "Incorecct exception message"); + } + #endregion + } +} diff --git a/src/DevHive.Tests/DevHive.Services.Tests/DevHive.Services.Tests.csproj b/src/DevHive.Tests/DevHive.Services.Tests/DevHive.Services.Tests.csproj new file mode 100644 index 0000000..ce5cb62 --- /dev/null +++ b/src/DevHive.Tests/DevHive.Services.Tests/DevHive.Services.Tests.csproj @@ -0,0 +1,25 @@ +<Project Sdk="Microsoft.NET.Sdk"> + + <PropertyGroup> + <TargetFramework>net5.0</TargetFramework> + + <IsPackable>false</IsPackable> + </PropertyGroup> + + <ItemGroup> + <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="5.0.1" /> + <PackageReference Include="Moq" Version="4.16.0" /> + <PackageReference Include="NUnit" Version="3.13.0" /> + <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" /> + <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.8.3" /> + </ItemGroup> + + <ItemGroup> + <ProjectReference Include="..\..\DevHive.Services\DevHive.Services.csproj" /> + </ItemGroup> + + <PropertyGroup> + <EnableNETAnalyzers>true</EnableNETAnalyzers> + <AnalysisLevel>latest</AnalysisLevel> + </PropertyGroup> +</Project> diff --git a/src/DevHive.Tests/DevHive.Services.Tests/FeedService.Tests.cs b/src/DevHive.Tests/DevHive.Services.Tests/FeedService.Tests.cs new file mode 100644 index 0000000..e4020c5 --- /dev/null +++ b/src/DevHive.Tests/DevHive.Services.Tests/FeedService.Tests.cs @@ -0,0 +1,155 @@ +//using System; +//using System.Collections.Generic; +//using System.Threading.Tasks; +//using AutoMapper; +//using DevHive.Data.Interfaces.Repositories; +//using DevHive.Data.Models; +//using DevHive.Services.Models; +//using DevHive.Services.Models.Post; +//using DevHive.Services.Services; +//using Moq; +//using NUnit.Framework; + +//namespace DevHive.Services.Tests +//{ +// [TestFixture] +// public class FeedServiceTests +// { +// private Mock<IFeedRepository> FeedRepositoryMock { get; set; } +// private Mock<IUserRepository> UserRepositoryMock { get; set; } +// private Mock<IMapper> MapperMock { get; set; } +// private FeedService FeedService { get; set; } + +// #region SetUps +// [SetUp] +// public void Setup() +// { +// this.FeedRepositoryMock = new Mock<IFeedRepository>(); +// this.UserRepositoryMock = new Mock<IUserRepository>(); +// this.MapperMock = new Mock<IMapper>(); +// this.FeedService = new FeedService(this.FeedRepositoryMock.Object, this.UserRepositoryMock.Object, this.MapperMock.Object); +// } +// #endregion + +// #region GetPage +// [Test] +// public async Task GetPage_ReturnsReadPageServiceModel_WhenSuitablePostsExist() +// { +// GetPageServiceModel getPageServiceModel = new GetPageServiceModel +// { +// UserId = Guid.NewGuid() +// }; + +// User dummyUser = CreateDummyUser(); +// User anotherDummyUser = CreateAnotherDummyUser(); +// HashSet<User> friends = new HashSet<User>(); +// friends.Add(anotherDummyUser); +// dummyUser.Friends = friends; + +// List<Post> posts = new List<Post> +// { +// new Post{ Message = "Message"} +// }; + +// ReadPostServiceModel readPostServiceModel = new ReadPostServiceModel +// { +// PostId = Guid.NewGuid(), +// Message = "Message" +// }; +// List<ReadPostServiceModel> readPostServiceModels = new List<ReadPostServiceModel>(); +// readPostServiceModels.Add(readPostServiceModel); +// ReadPageServiceModel readPageServiceModel = new ReadPageServiceModel +// { +// Posts = readPostServiceModels +// }; + +// this.UserRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(dummyUser)); +// this.FeedRepositoryMock.Setup(p => p.GetFriendsPosts(It.IsAny<List<User>>(), It.IsAny<DateTime>(), It.IsAny<int>(), It.IsAny<int>())).Returns(Task.FromResult(posts)); +// this.MapperMock.Setup(p => p.Map<ReadPostServiceModel>(It.IsAny<Post>())).Returns(readPostServiceModel); + +// ReadPageServiceModel result = await this.FeedService.GetPage(getPageServiceModel); + +// Assert.GreaterOrEqual(1, result.Posts.Count, "GetPage does not correctly return the posts"); +// } + +// [Test] +// public void GetPage_ThrowsException_WhenNoSuitablePostsExist() +// { +// const string EXCEPTION_MESSAGE = "No friends of user have posted anything yet!"; +// GetPageServiceModel getPageServiceModel = new GetPageServiceModel +// { +// UserId = Guid.NewGuid() +// }; + +// User dummyUser = CreateDummyUser(); +// User anotherDummyUser = CreateAnotherDummyUser(); +// HashSet<User> friends = new HashSet<User>(); +// friends.Add(anotherDummyUser); +// dummyUser.Friends = friends; + +// ReadPostServiceModel readPostServiceModel = new ReadPostServiceModel +// { +// PostId = Guid.NewGuid(), +// Message = "Message" +// }; +// List<ReadPostServiceModel> readPostServiceModels = new List<ReadPostServiceModel>(); +// readPostServiceModels.Add(readPostServiceModel); +// ReadPageServiceModel readPageServiceModel = new ReadPageServiceModel +// { +// Posts = readPostServiceModels +// }; + +// this.UserRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(dummyUser)); +// this.FeedRepositoryMock.Setup(p => p.GetFriendsPosts(It.IsAny<List<User>>(), It.IsAny<DateTime>(), It.IsAny<int>(), It.IsAny<int>())).Returns(Task.FromResult(new List<Post>())); + +// Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this.FeedService.GetPage(getPageServiceModel)); + +// Assert.AreEqual(EXCEPTION_MESSAGE, ex.Message, "Wrong exception message"); +// } + +// [Test] +// public void GetPage_ThrowsException_WhenUserHasNoFriendsToGetPostsFrom() +// { +// const string EXCEPTION_MESSAGE = "User has no friends to get feed from!"; +// GetPageServiceModel getPageServiceModel = new GetPageServiceModel +// { +// UserId = Guid.NewGuid() +// }; + +// User dummyUser = CreateDummyUser(); + +// this.UserRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(dummyUser)); + +// Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this.FeedService.GetPage(getPageServiceModel)); + +// Assert.AreEqual(EXCEPTION_MESSAGE, ex.Message, "Wrong exception message"); +// } +// #endregion + +// #region HelperMethods +// private User CreateDummyUser() +// { +// return new() +// { +// Id = Guid.NewGuid(), +// UserName = "dummyUser", +// FirstName = "Spas", +// LastName = "Spasov", +// Email = "abv@abv.bg", +// }; +// } + +// private User CreateAnotherDummyUser() +// { +// return new() +// { +// Id = Guid.NewGuid(), +// UserName = "anotherDummyUser", +// FirstName = "Alex", +// LastName = "Spiridonov", +// Email = "a_spiridonov@abv.bg", +// }; +// } +// #endregion +// } +//} diff --git a/src/DevHive.Tests/DevHive.Services.Tests/LanguageService.Tests.cs b/src/DevHive.Tests/DevHive.Services.Tests/LanguageService.Tests.cs new file mode 100644 index 0000000..1b59f91 --- /dev/null +++ b/src/DevHive.Tests/DevHive.Services.Tests/LanguageService.Tests.cs @@ -0,0 +1,262 @@ +using System; +using System.Collections.Generic; +using System.Threading.Tasks; +using AutoMapper; +using DevHive.Data.Interfaces.Repositories; +using DevHive.Data.Models; +using DevHive.Services.Models.Language; +using DevHive.Services.Services; +using Moq; +using NUnit.Framework; + +namespace DevHive.Services.Tests +{ + [TestFixture] + public class LanguageServiceTests + { + private Mock<ILanguageRepository> LanguageRepositoryMock { get; set; } + private Mock<IMapper> MapperMock { get; set; } + private LanguageService LanguageService { get; set; } + + #region SetUps + [SetUp] + public void SetUp() + { + this.LanguageRepositoryMock = new Mock<ILanguageRepository>(); + this.MapperMock = new Mock<IMapper>(); + this.LanguageService = new LanguageService(this.LanguageRepositoryMock.Object, this.MapperMock.Object); + } + #endregion + + #region CreateLanguage + [Test] + public async Task CreateLanguage_ReturnsNonEmptyGuid_WhenEntityIsAddedSuccessfully() + { + string technologyName = "Gosho Trapov"; + Guid id = Guid.NewGuid(); + CreateLanguageServiceModel createLanguageServiceModel = new CreateLanguageServiceModel + { + Name = technologyName + }; + Language language = new Language + { + Name = technologyName, + Id = id + }; + + this.LanguageRepositoryMock.Setup(p => p.DoesLanguageNameExistAsync(It.IsAny<string>())).Returns(Task.FromResult(false)); + this.LanguageRepositoryMock.Setup(p => p.AddAsync(It.IsAny<Language>())).Returns(Task.FromResult(true)); + this.LanguageRepositoryMock.Setup(p => p.GetByNameAsync(It.IsAny<string>())).Returns(Task.FromResult(language)); + this.MapperMock.Setup(p => p.Map<Language>(It.IsAny<CreateLanguageServiceModel>())).Returns(language); + + Guid result = await this.LanguageService.CreateLanguage(createLanguageServiceModel); + + Assert.AreEqual(id, result); + } + + [Test] + public async Task CreateLanguage_ReturnsEmptyGuid_WhenEntityIsNotAddedSuccessfully() + { + string languageName = "Gosho Trapov"; + + CreateLanguageServiceModel createLanguageServiceModel = new CreateLanguageServiceModel + { + Name = languageName + }; + Language language = new Language + { + Name = languageName + }; + + this.LanguageRepositoryMock.Setup(p => p.DoesLanguageNameExistAsync(It.IsAny<string>())).Returns(Task.FromResult(false)); + this.LanguageRepositoryMock.Setup(p => p.AddAsync(It.IsAny<Language>())).Returns(Task.FromResult(false)); + this.MapperMock.Setup(p => p.Map<Language>(It.IsAny<CreateLanguageServiceModel>())).Returns(language); + + Guid result = await this.LanguageService.CreateLanguage(createLanguageServiceModel); + + Assert.IsTrue(result == Guid.Empty); + + } + + [Test] + public void CreateLanguage_ThrowsArgumentException_WhenEntityAlreadyExists() + { + string exceptionMessage = "Language already exists!"; + string languageName = "Gosho Trapov"; + + CreateLanguageServiceModel createLanguageServiceModel = new CreateLanguageServiceModel + { + Name = languageName + }; + Language language = new Language + { + Name = languageName + }; + + this.LanguageRepositoryMock.Setup(p => p.DoesLanguageNameExistAsync(It.IsAny<string>())).Returns(Task.FromResult(true)); + + Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this.LanguageService.CreateLanguage(createLanguageServiceModel)); + + Assert.AreEqual(exceptionMessage, ex.Message, "Incorecct exception message"); + } + #endregion + + #region GetLanguageById + [Test] + public async Task GetLanguageById_ReturnsTheLanguage_WhenItExists() + { + Guid id = new Guid(); + string name = "Gosho Trapov"; + Language language = new Language + { + Name = name + }; + ReadLanguageServiceModel readLanguageServiceModel = new ReadLanguageServiceModel + { + Name = name + }; + + this.LanguageRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(language)); + this.MapperMock.Setup(p => p.Map<ReadLanguageServiceModel>(It.IsAny<Language>())).Returns(readLanguageServiceModel); + + ReadLanguageServiceModel result = await this.LanguageService.GetLanguageById(id); + + Assert.AreEqual(name, result.Name); + } + + [Test] + public void GetLanguageById_ThrowsException_WhenLanguageDoesNotExist() + { + string exceptionMessage = "The language does not exist"; + Guid id = new Guid(); + this.LanguageRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult<Language>(null)); + + Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this.LanguageService.GetLanguageById(id)); + + Assert.AreEqual(exceptionMessage, ex.Message, "Incorecct exception message"); + } + #endregion + + #region GetLanguages + [Test] + public void GetLanguages_ReturnsAllLanguages_IfAnyExist() + { + ReadLanguageServiceModel firstLanguage = new ReadLanguageServiceModel(); + ReadLanguageServiceModel secondLanguage = new ReadLanguageServiceModel(); + HashSet<ReadLanguageServiceModel> languges = new HashSet<ReadLanguageServiceModel>(); + languges.Add(firstLanguage); + languges.Add(secondLanguage); + + this.LanguageRepositoryMock.Setup(p => p.GetLanguages()).Returns(new HashSet<Language>()); + this.MapperMock.Setup(p => p.Map<HashSet<ReadLanguageServiceModel>>(It.IsAny<HashSet<Language>>())).Returns(languges); + + HashSet<ReadLanguageServiceModel> result = this.LanguageService.GetLanguages(); + + Assert.GreaterOrEqual(2, result.Count, "GetLanguages does not return all languages"); + } + + [Test] + public void GetLanguages_ReturnsEmptyHashSet_IfNoLanguagesExist() + { + this.LanguageRepositoryMock.Setup(p => p.GetLanguages()).Returns(new HashSet<Language>()); + this.MapperMock.Setup(p => p.Map<HashSet<ReadLanguageServiceModel>>(It.IsAny<HashSet<Language>>())).Returns(new HashSet<ReadLanguageServiceModel>()); + + HashSet<ReadLanguageServiceModel> result = this.LanguageService.GetLanguages(); + + Assert.IsEmpty(result, "GetLanguages does not return empty string when no languages exist"); + } + #endregion + + #region UpdateLanguage + [Test] + [TestCase(true)] + [TestCase(false)] + public async Task UpdateLanguage_ReturnsIfUpdateIsSuccessfull_WhenLanguageExistsy(bool shouldPass) + { + string name = "Gosho Trapov"; + Guid id = Guid.NewGuid(); + Language language = new Language + { + Name = name, + Id = id + }; + UpdateLanguageServiceModel updateLanguageServiceModel = new UpdateLanguageServiceModel + { + Name = name, + }; + + this.LanguageRepositoryMock.Setup(p => p.DoesLanguageExistAsync(It.IsAny<Guid>())).Returns(Task.FromResult(true)); + this.LanguageRepositoryMock.Setup(p => p.DoesLanguageNameExistAsync(It.IsAny<string>())).Returns(Task.FromResult(false)); + this.LanguageRepositoryMock.Setup(p => p.EditAsync(It.IsAny<Guid>(), It.IsAny<Language>())).Returns(Task.FromResult(shouldPass)); + this.MapperMock.Setup(p => p.Map<Language>(It.IsAny<UpdateLanguageServiceModel>())).Returns(language); + + bool result = await this.LanguageService.UpdateLanguage(updateLanguageServiceModel); + + Assert.AreEqual(shouldPass, result); + } + + [Test] + public void UpdateLanguage_ThrowsArgumentException_WhenLanguageDoesNotExist() + { + string exceptionMessage = "Language does not exist!"; + UpdateLanguageServiceModel updateTechnologyServiceModel = new UpdateLanguageServiceModel + { + }; + + this.LanguageRepositoryMock.Setup(p => p.DoesLanguageExistAsync(It.IsAny<Guid>())).Returns(Task.FromResult(false)); + + Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this.LanguageService.UpdateLanguage(updateTechnologyServiceModel)); + + Assert.AreEqual(exceptionMessage, ex.Message, "Incorecct exception message"); + } + + [Test] + public void UpdateLanguage_ThrowsException_WhenLanguageNameAlreadyExists() + { + string exceptionMessage = "Language name already exists in our data base!"; + UpdateLanguageServiceModel updateTechnologyServiceModel = new UpdateLanguageServiceModel + { + }; + + this.LanguageRepositoryMock.Setup(p => p.DoesLanguageExistAsync(It.IsAny<Guid>())).Returns(Task.FromResult(true)); + this.LanguageRepositoryMock.Setup(p => p.DoesLanguageNameExistAsync(It.IsAny<string>())).Returns(Task.FromResult(true)); + + Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this.LanguageService.UpdateLanguage(updateTechnologyServiceModel)); + + Assert.AreEqual(exceptionMessage, ex.Message, "Incorecct exception message"); + } + #endregion + + #region DeleteLanguage + [Test] + [TestCase(true)] + [TestCase(false)] + public async Task DeleteLanguage_ShouldReturnIfDeletionIsSuccessfull_WhenLanguageExists(bool shouldPass) + { + Guid id = new Guid(); + Language language = new Language(); + + this.LanguageRepositoryMock.Setup(p => p.DoesLanguageExistAsync(It.IsAny<Guid>())).Returns(Task.FromResult(true)); + this.LanguageRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(language)); + this.LanguageRepositoryMock.Setup(p => p.DeleteAsync(It.IsAny<Language>())).Returns(Task.FromResult(shouldPass)); + + bool result = await this.LanguageService.DeleteLanguage(id); + + Assert.AreEqual(shouldPass, result); + } + + [Test] + public void DeleteLanguage_ThrowsException_WhenLanguageDoesNotExist() + { + string exceptionMessage = "Language does not exist!"; + Guid id = new Guid(); + + this.LanguageRepositoryMock.Setup(p => p.DoesLanguageExistAsync(It.IsAny<Guid>())).Returns(Task.FromResult(false)); + + Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this.LanguageService.DeleteLanguage(id)); + + Assert.AreEqual(exceptionMessage, ex.Message, "Incorecct exception message"); + } + #endregion + } +} diff --git a/src/DevHive.Tests/DevHive.Services.Tests/PostService.Tests.cs b/src/DevHive.Tests/DevHive.Services.Tests/PostService.Tests.cs new file mode 100644 index 0000000..900608c --- /dev/null +++ b/src/DevHive.Tests/DevHive.Services.Tests/PostService.Tests.cs @@ -0,0 +1,271 @@ +using System; +using System.Collections.Generic; +using System.Threading.Tasks; +using AutoMapper; +using DevHive.Data.Interfaces.Repositories; +using DevHive.Data.Models; +using DevHive.Services.Interfaces; +using DevHive.Services.Models.Post; +using DevHive.Services.Services; +using Microsoft.AspNetCore.Http; +using Moq; +using NUnit.Framework; + +namespace DevHive.Services.Tests +{ + [TestFixture] + public class PostServiceTests + { + private const string MESSAGE = "Gosho Trapov"; + private Mock<ICloudService> CloudServiceMock { get; set; } + private Mock<IPostRepository> PostRepositoryMock { get; set; } + private Mock<ICommentRepository> CommentRepositoryMock { get; set; } + private Mock<IUserRepository> UserRepositoryMock { get; set; } + private Mock<IMapper> MapperMock { get; set; } + private PostService PostService { get; set; } + + #region SetUps + [SetUp] + public void Setup() + { + this.PostRepositoryMock = new Mock<IPostRepository>(); + this.CloudServiceMock = new Mock<ICloudService>(); + this.UserRepositoryMock = new Mock<IUserRepository>(); + this.CommentRepositoryMock = new Mock<ICommentRepository>(); + this.MapperMock = new Mock<IMapper>(); + this.PostService = new PostService(this.CloudServiceMock.Object, this.UserRepositoryMock.Object, this.PostRepositoryMock.Object, this.CommentRepositoryMock.Object, this.MapperMock.Object); + } + #endregion + + #region CreatePost + [Test] + public async Task CreatePost_ReturnsIdOfThePost_WhenItIsSuccessfullyCreated() + { + Guid postId = Guid.NewGuid(); + User creator = new User { Id = Guid.NewGuid() }; + CreatePostServiceModel createPostServiceModel = new CreatePostServiceModel + { + Files = new List<IFormFile>() + }; + Post post = new Post + { + Message = MESSAGE, + Id = postId, + }; + + this.PostRepositoryMock.Setup(p => p.AddAsync(It.IsAny<Post>())).Returns(Task.FromResult(true)); + this.PostRepositoryMock.Setup(p => p.GetPostByCreatorAndTimeCreatedAsync(It.IsAny<Guid>(), It.IsAny<DateTime>())).Returns(Task.FromResult(post)); + this.UserRepositoryMock.Setup(p => p.DoesUserExistAsync(It.IsAny<Guid>())).Returns(Task.FromResult(true)); + this.UserRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(creator)); + this.MapperMock.Setup(p => p.Map<Post>(It.IsAny<CreatePostServiceModel>())).Returns(post); + + Guid result = await this.PostService.CreatePost(createPostServiceModel); + + Assert.AreEqual(postId, result, "CreatePost does not return the correct id"); + } + + [Test] + public async Task CreatePost_ReturnsEmptyGuid_WhenItIsNotSuccessfullyCreated() + { + CreatePostServiceModel createPostServiceModel = new CreatePostServiceModel + { + Files = new List<IFormFile>() + }; + Post post = new Post + { + Message = MESSAGE, + }; + + this.PostRepositoryMock.Setup(p => p.AddAsync(It.IsAny<Post>())).Returns(Task.FromResult(false)); + this.UserRepositoryMock.Setup(p => p.DoesUserExistAsync(It.IsAny<Guid>())).Returns(Task.FromResult(true)); + this.MapperMock.Setup(p => p.Map<Post>(It.IsAny<CreatePostServiceModel>())).Returns(post); + + Guid result = await this.PostService.CreatePost(createPostServiceModel); + + Assert.AreEqual(Guid.Empty, result, "CreatePost does not return empty id"); + } + + [Test] + public void CreatePost_ThrowsException_WhenUserDoesNotExist() + { + const string EXCEPTION_MESSAGE = "User does not exist!"; + CreatePostServiceModel createPostServiceModel = new CreatePostServiceModel + { + }; + Post post = new Post + { + Message = MESSAGE, + }; + + Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this.PostService.CreatePost(createPostServiceModel), "CreatePost does not throw excpeion when the user does not exist"); + + Assert.AreEqual(EXCEPTION_MESSAGE, ex.Message, "Excapetion message is not correct"); + } + #endregion + + #region GetPostById + [Test] + public async Task GetPostById_ReturnsThePost_WhenItExists() + { + Guid creatorId = new Guid(); + User creator = new User { Id = creatorId }; + Post post = new Post + { + Message = MESSAGE, + Creator = creator + }; + ReadPostServiceModel readPostServiceModel = new ReadPostServiceModel + { + Message = MESSAGE + }; + User user = new User + { + Id = creatorId, + }; + + this.PostRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(post)); + this.UserRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(user)); + this.MapperMock.Setup(p => p.Map<ReadPostServiceModel>(It.IsAny<Post>())).Returns(readPostServiceModel); + + ReadPostServiceModel result = await this.PostService.GetPostById(new Guid()); + + Assert.AreEqual(MESSAGE, result.Message); + } + + [Test] + public void GetPostById_ThorwsException_WhenTheUserDoesNotExist() + { + const string EXCEPTION_MESSAGE = "The user does not exist!"; + Guid creatorId = new Guid(); + User creator = new User { Id = creatorId }; + Post post = new Post + { + Message = MESSAGE, + Creator = creator + }; + + this.PostRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(post)); + + Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this.PostService.GetPostById(new Guid()), "GetPostById does not throw exception when the user does not exist"); + + Assert.AreEqual(EXCEPTION_MESSAGE, ex.Message); + } + + [Test] + public void GetPostById_ThrowsException_WhenCommentDoesNotExist() + { + string exceptionMessage = "The post does not exist!"; + Guid creatorId = new Guid(); + User user = new User + { + Id = creatorId, + }; + + this.PostRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult<Post>(null)); + this.UserRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(user)); + + Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this.PostService.GetPostById(new Guid())); + + Assert.AreEqual(exceptionMessage, ex.Message, "Incorecct exception message"); + } + #endregion + + #region UpdatePost + [Test] + public async Task UpdatePost_ReturnsTheIdOfThePost_WhenUpdatedSuccessfully() + { + Guid id = Guid.NewGuid(); + Post post = new Post + { + Id = id, + Message = MESSAGE + }; + UpdatePostServiceModel updatePostServiceModel = new UpdatePostServiceModel + { + PostId = id, + NewMessage = MESSAGE, + Files = new List<IFormFile>() + }; + + this.PostRepositoryMock.Setup(p => p.DoesPostExist(It.IsAny<Guid>())).Returns(Task.FromResult(true)); + this.PostRepositoryMock.Setup(p => p.EditAsync(It.IsAny<Guid>(), It.IsAny<Post>())).Returns(Task.FromResult(true)); + this.PostRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(post)); + this.MapperMock.Setup(p => p.Map<Post>(It.IsAny<UpdatePostServiceModel>())).Returns(post); + + Guid result = await this.PostService.UpdatePost(updatePostServiceModel); + + Assert.AreEqual(updatePostServiceModel.PostId, result); + } + + [Test] + public async Task UpdatePost_ReturnsEmptyId_WhenThePostIsNotUpdatedSuccessfully() + { + Post post = new Post + { + Message = MESSAGE + }; + UpdatePostServiceModel updatePostServiceModel = new UpdatePostServiceModel + { + PostId = Guid.NewGuid(), + NewMessage = MESSAGE, + Files = new List<IFormFile>() + }; + + this.PostRepositoryMock.Setup(p => p.DoesPostExist(It.IsAny<Guid>())).Returns(Task.FromResult(true)); + this.PostRepositoryMock.Setup(p => p.EditAsync(It.IsAny<Guid>(), It.IsAny<Post>())).Returns(Task.FromResult(false)); + this.MapperMock.Setup(p => p.Map<Post>(It.IsAny<UpdatePostServiceModel>())).Returns(post); + + Guid result = await this.PostService.UpdatePost(updatePostServiceModel); + + Assert.AreEqual(Guid.Empty, result); + } + + [Test] + public void UpdatePost_ThrowsArgumentException_WhenCommentDoesNotExist() + { + string exceptionMessage = "Post does not exist!"; + UpdatePostServiceModel updatePostServiceModel = new UpdatePostServiceModel + { + }; + + this.PostRepositoryMock.Setup(p => p.DoesPostExist(It.IsAny<Guid>())).Returns(Task.FromResult(false)); + + Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this.PostService.UpdatePost(updatePostServiceModel)); + + Assert.AreEqual(exceptionMessage, ex.Message, "Incorecct exception message"); + } + #endregion + + #region DeletePost + [Test] + [TestCase(true)] + [TestCase(false)] + public async Task Deletepost_ShouldReturnIfDeletionIsSuccessfull_WhenPostExists(bool shouldPass) + { + Guid id = new Guid(); + Post post = new Post(); + + this.PostRepositoryMock.Setup(p => p.DoesPostExist(It.IsAny<Guid>())).Returns(Task.FromResult(true)); + this.PostRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(post)); + this.PostRepositoryMock.Setup(p => p.DeleteAsync(It.IsAny<Post>())).Returns(Task.FromResult(shouldPass)); + + bool result = await this.PostService.DeletePost(id); + + Assert.AreEqual(shouldPass, result); + } + + [Test] + public void DeletePost_ThrowsException_WhenPostDoesNotExist() + { + string exceptionMessage = "Post does not exist!"; + Guid id = new Guid(); + + this.PostRepositoryMock.Setup(p => p.DoesPostExist(It.IsAny<Guid>())).Returns(Task.FromResult(false)); + + Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this.PostService.DeletePost(id)); + + Assert.AreEqual(exceptionMessage, ex.Message, "Incorecct exception message"); + } + #endregion + } +} diff --git a/src/DevHive.Tests/DevHive.Services.Tests/RoleService.Tests.cs b/src/DevHive.Tests/DevHive.Services.Tests/RoleService.Tests.cs new file mode 100644 index 0000000..e500dd1 --- /dev/null +++ b/src/DevHive.Tests/DevHive.Services.Tests/RoleService.Tests.cs @@ -0,0 +1,230 @@ +using System; +using System.Threading.Tasks; +using AutoMapper; +using DevHive.Data.Interfaces.Repositories; +using DevHive.Data.Models; +using DevHive.Services.Models.Identity.Role; +using DevHive.Services.Services; +using Moq; +using NUnit.Framework; + +namespace DevHive.Services.Tests +{ + [TestFixture] + public class RoleServiceTests + { + private Mock<IRoleRepository> RoleRepositoryMock { get; set; } + private Mock<IMapper> MapperMock { get; set; } + private RoleService RoleService { get; set; } + + #region SetUps + [SetUp] + public void Setup() + { + this.RoleRepositoryMock = new Mock<IRoleRepository>(); + this.MapperMock = new Mock<IMapper>(); + this.RoleService = new RoleService(this.RoleRepositoryMock.Object, this.MapperMock.Object); + } + #endregion + + #region CreateRole + [Test] + public async Task CreateRole_ReturnsNonEmptyGuid_WhenEntityIsAddedSuccessfully() + { + string roleName = "Gosho Trapov"; + Guid id = Guid.NewGuid(); + CreateRoleServiceModel createRoleServiceModel = new CreateRoleServiceModel + { + Name = roleName + }; + Role role = new() + { + Name = roleName, + Id = id + }; + + this.RoleRepositoryMock.Setup(p => p.DoesNameExist(It.IsAny<string>())).Returns(Task.FromResult(false)); + this.RoleRepositoryMock.Setup(p => p.AddAsync(It.IsAny<Role>())).Returns(Task.FromResult(true)); + this.RoleRepositoryMock.Setup(p => p.GetByNameAsync(It.IsAny<string>())).Returns(Task.FromResult(role)); + this.MapperMock.Setup(p => p.Map<Role>(It.IsAny<CreateRoleServiceModel>())).Returns(role); + + Guid result = await this.RoleService.CreateRole(createRoleServiceModel); + + Assert.AreEqual(id, result); + } + + [Test] + public async Task CreateRoley_ReturnsEmptyGuid_WhenEntityIsNotAddedSuccessfully() + { + string roleName = "Gosho Trapov"; + + CreateRoleServiceModel createRoleServiceModel = new CreateRoleServiceModel + { + Name = roleName + }; + Role role = new Role + { + Name = roleName + }; + + this.RoleRepositoryMock.Setup(p => p.DoesNameExist(It.IsAny<string>())).Returns(Task.FromResult(false)); + this.RoleRepositoryMock.Setup(p => p.AddAsync(It.IsAny<Role>())).Returns(Task.FromResult(false)); + this.MapperMock.Setup(p => p.Map<Role>(It.IsAny<CreateRoleServiceModel>())).Returns(role); + + Guid result = await this.RoleService.CreateRole(createRoleServiceModel); + + Assert.IsTrue(result == Guid.Empty); + } + + [Test] + public void CreateTechnology_ThrowsArgumentException_WhenEntityAlreadyExists() + { + string exceptionMessage = "Role already exists!"; + string roleName = "Gosho Trapov"; + + CreateRoleServiceModel createRoleServiceModel = new CreateRoleServiceModel + { + Name = roleName + }; + Role role = new Role + { + Name = roleName + }; + + this.RoleRepositoryMock.Setup(p => p.DoesNameExist(It.IsAny<string>())).Returns(Task.FromResult(true)); + + Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this.RoleService.CreateRole(createRoleServiceModel)); + + Assert.AreEqual(exceptionMessage, ex.Message, "Incorecct exception message"); + } + #endregion + + #region GetRoleById + [Test] + public async Task GetRoleById_ReturnsTheRole_WhenItExists() + { + Guid id = new Guid(); + string name = "Gosho Trapov"; + Role role = new Role + { + Name = name + }; + RoleServiceModel roleServiceModel = new RoleServiceModel + { + Name = name + }; + + this.RoleRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(role)); + this.MapperMock.Setup(p => p.Map<RoleServiceModel>(It.IsAny<Role>())).Returns(roleServiceModel); + + RoleServiceModel result = await this.RoleService.GetRoleById(id); + + Assert.AreEqual(name, result.Name); + } + + [Test] + public void GetRoleById_ThrowsException_WhenRoleDoesNotExist() + { + string exceptionMessage = "Role does not exist!"; + Guid id = new Guid(); + this.RoleRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult<Role>(null)); + + Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this.RoleService.GetRoleById(id)); + + Assert.AreEqual(exceptionMessage, ex.Message, "Incorecct exception message"); + } + #endregion + + #region UpdateRole + [Test] + [TestCase(true)] + [TestCase(false)] + public async Task UpdateRole_ReturnsIfUpdateIsSuccessfull_WhenRoleExistsy(bool shouldPass) + { + string name = "Gosho Trapov"; + Guid id = Guid.NewGuid(); + Role role = new Role + { + Name = name, + Id = id + }; + UpdateRoleServiceModel updateRoleServiceModel = new UpdateRoleServiceModel + { + Name = name, + }; + + this.RoleRepositoryMock.Setup(p => p.DoesRoleExist(It.IsAny<Guid>())).Returns(Task.FromResult(true)); + this.RoleRepositoryMock.Setup(p => p.DoesNameExist(It.IsAny<string>())).Returns(Task.FromResult(false)); + this.RoleRepositoryMock.Setup(p => p.EditAsync(It.IsAny<Guid>(), It.IsAny<Role>())).Returns(Task.FromResult(shouldPass)); + this.MapperMock.Setup(p => p.Map<Role>(It.IsAny<UpdateRoleServiceModel>())).Returns(role); + + bool result = await this.RoleService.UpdateRole(updateRoleServiceModel); + + Assert.AreEqual(shouldPass, result); + } + + [Test] + public void UpdateRole_ThrowsException_WhenRoleDoesNotExist() + { + string exceptionMessage = "Role does not exist!"; + UpdateRoleServiceModel updateRoleServiceModel = new UpdateRoleServiceModel + { + }; + + this.RoleRepositoryMock.Setup(p => p.DoesRoleExist(It.IsAny<Guid>())).Returns(Task.FromResult(false)); + + Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this.RoleService.UpdateRole(updateRoleServiceModel)); + + Assert.AreEqual(exceptionMessage, ex.Message, "Incorecct exception message"); + } + + [Test] + public void UpdateRole_ThrowsException_WhenRoleNameAlreadyExists() + { + string exceptionMessage = "Role name already exists!"; + UpdateRoleServiceModel updateRoleServiceModel = new UpdateRoleServiceModel + { + }; + + this.RoleRepositoryMock.Setup(p => p.DoesRoleExist(It.IsAny<Guid>())).Returns(Task.FromResult(true)); + this.RoleRepositoryMock.Setup(p => p.DoesNameExist(It.IsAny<string>())).Returns(Task.FromResult(true)); + + Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this.RoleService.UpdateRole(updateRoleServiceModel)); + + Assert.AreEqual(exceptionMessage, ex.Message, "Incorecct exception message"); + } + #endregion + + #region DeleteRole + [Test] + [TestCase(true)] + [TestCase(false)] + public async Task DeleteRole_ShouldReturnIfDeletionIsSuccessfull_WhenRoleExists(bool shouldPass) + { + Guid id = new Guid(); + Role role = new Role(); + + this.RoleRepositoryMock.Setup(p => p.DoesRoleExist(It.IsAny<Guid>())).Returns(Task.FromResult(true)); + this.RoleRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(role)); + this.RoleRepositoryMock.Setup(p => p.DeleteAsync(It.IsAny<Role>())).Returns(Task.FromResult(shouldPass)); + + bool result = await this.RoleService.DeleteRole(id); + + Assert.AreEqual(shouldPass, result); + } + + [Test] + public void DeleteRole_ThrowsException_WhenRoleDoesNotExist() + { + string exceptionMessage = "Role does not exist!"; + Guid id = new Guid(); + + this.RoleRepositoryMock.Setup(p => p.DoesRoleExist(It.IsAny<Guid>())).Returns(Task.FromResult(false)); + + Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this.RoleService.DeleteRole(id)); + + Assert.AreEqual(exceptionMessage, ex.Message, "Incorecct exception message"); + } + #endregion + } +} diff --git a/src/DevHive.Tests/DevHive.Services.Tests/TechnologyServices.Tests.cs b/src/DevHive.Tests/DevHive.Services.Tests/TechnologyServices.Tests.cs new file mode 100644 index 0000000..e671adb --- /dev/null +++ b/src/DevHive.Tests/DevHive.Services.Tests/TechnologyServices.Tests.cs @@ -0,0 +1,262 @@ +using AutoMapper; +using DevHive.Data.Interfaces.Repositories; +using DevHive.Data.Models; +using DevHive.Services.Models.Technology; +using DevHive.Services.Services; +using Moq; +using NUnit.Framework; +using System; +using System.Collections.Generic; +using System.Threading.Tasks; + +namespace DevHive.Services.Tests +{ + [TestFixture] + public class TechnologyServicesTests + { + private Mock<ITechnologyRepository> TechnologyRepositoryMock { get; set; } + private Mock<IMapper> MapperMock { get; set; } + private TechnologyService TechnologyService { get; set; } + + #region SetUps + [SetUp] + public void Setup() + { + this.TechnologyRepositoryMock = new Mock<ITechnologyRepository>(); + this.MapperMock = new Mock<IMapper>(); + this.TechnologyService = new TechnologyService(this.TechnologyRepositoryMock.Object, this.MapperMock.Object); + } + #endregion + + #region CreateTechnology + [Test] + public async Task CreateTechnology_ReturnsNonEmptyGuid_WhenEntityIsAddedSuccessfully() + { + string technologyName = "Gosho Trapov"; + Guid id = Guid.NewGuid(); + CreateTechnologyServiceModel createTechnologyServiceModel = new() + { + Name = technologyName + }; + Technology technology = new() + { + Name = technologyName, + Id = id + }; + + this.TechnologyRepositoryMock.Setup(p => p.DoesTechnologyNameExistAsync(It.IsAny<string>())).Returns(Task.FromResult(false)); + this.TechnologyRepositoryMock.Setup(p => p.AddAsync(It.IsAny<Technology>())).Returns(Task.FromResult(true)); + this.TechnologyRepositoryMock.Setup(p => p.GetByNameAsync(It.IsAny<string>())).Returns(Task.FromResult(technology)); + this.MapperMock.Setup(p => p.Map<Technology>(It.IsAny<CreateTechnologyServiceModel>())).Returns(technology); + + Guid result = await this.TechnologyService.CreateTechnology(createTechnologyServiceModel); + + Assert.AreEqual(id, result); + } + + [Test] + public async Task CreateTechnology_ReturnsEmptyGuid_WhenEntityIsNotAddedSuccessfully() + { + string technologyName = "Gosho Trapov"; + + CreateTechnologyServiceModel createTechnologyServiceModel = new() + { + Name = technologyName + }; + Technology technology = new() + { + Name = technologyName + }; + + this.TechnologyRepositoryMock.Setup(p => p.DoesTechnologyNameExistAsync(It.IsAny<string>())).Returns(Task.FromResult(false)); + this.TechnologyRepositoryMock.Setup(p => p.AddAsync(It.IsAny<Technology>())).Returns(Task.FromResult(false)); + this.MapperMock.Setup(p => p.Map<Technology>(It.IsAny<CreateTechnologyServiceModel>())).Returns(technology); + + Guid result = await this.TechnologyService.CreateTechnology(createTechnologyServiceModel); + + Assert.IsTrue(result == Guid.Empty); + } + + [Test] + public void CreateTechnology_ThrowsArgumentException_WhenEntityAlreadyExists() + { + string exceptionMessage = "Technology already exists!"; + string technologyName = "Gosho Trapov"; + + CreateTechnologyServiceModel createTechnologyServiceModel = new() + { + Name = technologyName + }; + Technology technology = new() + { + Name = technologyName + }; + + this.TechnologyRepositoryMock.Setup(p => p.DoesTechnologyNameExistAsync(It.IsAny<string>())).Returns(Task.FromResult(true)); + + Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this.TechnologyService.CreateTechnology(createTechnologyServiceModel)); + + Assert.AreEqual(exceptionMessage, ex.Message, "Incorecct exception message"); + } + #endregion + + #region GetTechnologyById + [Test] + public async Task GetTechnologyById_ReturnsTheTechnology_WhenItExists() + { + Guid id = new Guid(); + string name = "Gosho Trapov"; + Technology technology = new() + { + Name = name + }; + ReadTechnologyServiceModel readTechnologyServiceModel = new() + { + Name = name + }; + + this.TechnologyRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(technology)); + this.MapperMock.Setup(p => p.Map<ReadTechnologyServiceModel>(It.IsAny<Technology>())).Returns(readTechnologyServiceModel); + + ReadTechnologyServiceModel result = await this.TechnologyService.GetTechnologyById(id); + + Assert.AreEqual(name, result.Name); + } + + [Test] + public void GetTechnologyById_ThrowsException_WhenTechnologyDoesNotExist() + { + string exceptionMessage = "The technology does not exist"; + Guid id = new Guid(); + this.TechnologyRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult<Technology>(null)); + + Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this.TechnologyService.GetTechnologyById(id)); + + Assert.AreEqual(exceptionMessage, ex.Message, "Incorecct exception message"); + } + #endregion + + #region GetTechnologies + [Test] + public void GetTechnologies_ReturnsAllLanguages_IfAnyExist() + { + ReadTechnologyServiceModel firstTechnology = new ReadTechnologyServiceModel(); + ReadTechnologyServiceModel secondTechnology = new ReadTechnologyServiceModel(); + HashSet<ReadTechnologyServiceModel> technologies = new HashSet<ReadTechnologyServiceModel>(); + technologies.Add(firstTechnology); + technologies.Add(secondTechnology); + + this.TechnologyRepositoryMock.Setup(p => p.GetTechnologies()).Returns(new HashSet<Technology>()); + this.MapperMock.Setup(p => p.Map<HashSet<ReadTechnologyServiceModel>>(It.IsAny<HashSet<Technology>>())).Returns(technologies); + + HashSet<ReadTechnologyServiceModel> result = this.TechnologyService.GetTechnologies(); + + Assert.GreaterOrEqual(2, result.Count, "GetTechnologies does not return all technologies"); + } + + [Test] + public void GetLanguages_ReturnsEmptyHashSet_IfNoLanguagesExist() + { + this.TechnologyRepositoryMock.Setup(p => p.GetTechnologies()).Returns(new HashSet<Technology>()); + this.MapperMock.Setup(p => p.Map<HashSet<ReadTechnologyServiceModel>>(It.IsAny<HashSet<Technology>>())).Returns(new HashSet<ReadTechnologyServiceModel>()); + + HashSet<ReadTechnologyServiceModel> result = this.TechnologyService.GetTechnologies(); + + Assert.IsEmpty(result, "GetTechnologies does not return empty string when no technologies exist"); + } + #endregion + + #region UpdateTechnology + [Test] + [TestCase(true)] + [TestCase(false)] + public async Task UpdateTechnology_ReturnsIfUpdateIsSuccessfull_WhenTechnologyExistsy(bool shouldPass) + { + string name = "Gosho Trapov"; + Guid id = Guid.NewGuid(); + Technology technology = new Technology + { + Name = name, + Id = id + }; + UpdateTechnologyServiceModel updatetechnologyServiceModel = new UpdateTechnologyServiceModel + { + Name = name, + }; + + this.TechnologyRepositoryMock.Setup(p => p.DoesTechnologyExistAsync(It.IsAny<Guid>())).Returns(Task.FromResult(true)); + this.TechnologyRepositoryMock.Setup(p => p.DoesTechnologyNameExistAsync(It.IsAny<string>())).Returns(Task.FromResult(false)); + this.TechnologyRepositoryMock.Setup(p => p.EditAsync(It.IsAny<Guid>(), It.IsAny<Technology>())).Returns(Task.FromResult(shouldPass)); + this.MapperMock.Setup(p => p.Map<Technology>(It.IsAny<UpdateTechnologyServiceModel>())).Returns(technology); + + bool result = await this.TechnologyService.UpdateTechnology(updatetechnologyServiceModel); + + Assert.AreEqual(shouldPass, result); + } + + [Test] + public void UpdateTechnology_ThrowsException_WhenTechnologyDoesNotExist() + { + string exceptionMessage = "Technology does not exist!"; + UpdateTechnologyServiceModel updateTechnologyServiceModel = new UpdateTechnologyServiceModel + { + }; + + this.TechnologyRepositoryMock.Setup(p => p.DoesTechnologyExistAsync(It.IsAny<Guid>())).Returns(Task.FromResult(false)); + + Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this.TechnologyService.UpdateTechnology(updateTechnologyServiceModel)); + + Assert.AreEqual(exceptionMessage, ex.Message, "Incorecct exception message"); + } + + [Test] + public void UpdateTechnology_ThrowsException_WhenTechnologyNameAlreadyExists() + { + string exceptionMessage = "Technology name already exists!"; + UpdateTechnologyServiceModel updateTechnologyServiceModel = new UpdateTechnologyServiceModel + { + }; + + this.TechnologyRepositoryMock.Setup(p => p.DoesTechnologyExistAsync(It.IsAny<Guid>())).Returns(Task.FromResult(true)); + this.TechnologyRepositoryMock.Setup(p => p.DoesTechnologyNameExistAsync(It.IsAny<string>())).Returns(Task.FromResult(true)); + + Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this.TechnologyService.UpdateTechnology(updateTechnologyServiceModel)); + + Assert.AreEqual(exceptionMessage, ex.Message, "Incorecct exception message"); + } + #endregion + + #region DeleteTechnology + + [Test] + [TestCase(true)] + [TestCase(false)] + public async Task DeleteTechnology_ShouldReturnIfDeletionIsSuccessfull_WhenTechnologyExists(bool shouldPass) + { + Guid id = new Guid(); + Technology technology = new Technology(); + + this.TechnologyRepositoryMock.Setup(p => p.DoesTechnologyExistAsync(It.IsAny<Guid>())).Returns(Task.FromResult(true)); + this.TechnologyRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(technology)); + this.TechnologyRepositoryMock.Setup(p => p.DeleteAsync(It.IsAny<Technology>())).Returns(Task.FromResult(shouldPass)); + + bool result = await this.TechnologyService.DeleteTechnology(id); + + Assert.AreEqual(shouldPass, result); + } + + [Test] + public void DeleteTechnology_ThrowsException_WhenTechnologyDoesNotExist() + { + string exceptionMessage = "Technology does not exist!"; + Guid id = new Guid(); + + this.TechnologyRepositoryMock.Setup(p => p.DoesTechnologyExistAsync(It.IsAny<Guid>())).Returns(Task.FromResult(false)); + + Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this.TechnologyService.DeleteTechnology(id)); + + Assert.AreEqual(exceptionMessage, ex.Message, "Incorecct exception message"); + } + #endregion + } +} diff --git a/src/DevHive.Tests/DevHive.Services.Tests/UserService.Tests.cs b/src/DevHive.Tests/DevHive.Services.Tests/UserService.Tests.cs new file mode 100644 index 0000000..21d4862 --- /dev/null +++ b/src/DevHive.Tests/DevHive.Services.Tests/UserService.Tests.cs @@ -0,0 +1,394 @@ +using System; +using System.Collections.Generic; +using System.IdentityModel.Tokens.Jwt; +using System.Security.Claims; +using System.Text; +using System.Threading.Tasks; +using AutoMapper; +using DevHive.Common.Models.Identity; +using DevHive.Common.Models.Misc; +using DevHive.Data.Interfaces.Repositories; +using DevHive.Data.Models; +using DevHive.Services.Interfaces; +using DevHive.Services.Models.Identity.User; +using DevHive.Services.Options; +using DevHive.Services.Services; +using Microsoft.AspNetCore.Identity; +using Microsoft.IdentityModel.Tokens; +using Moq; +using NUnit.Framework; + +namespace DevHive.Services.Tests +{ + [TestFixture] + public class UserServiceTests + { + private Mock<ICloudService> CloudServiceMock { get; set; } + private Mock<IUserRepository> UserRepositoryMock { get; set; } + private Mock<IRoleRepository> RoleRepositoryMock { get; set; } + private Mock<ILanguageRepository> LanguageRepositoryMock { get; set; } + private Mock<ITechnologyRepository> TechnologyRepositoryMock { get; set; } + private Mock<IMapper> MapperMock { get; set; } + private JWTOptions JWTOptions { get; set; } + private UserService UserService { get; set; } + + #region SetUps + [SetUp] + public void Setup() + { + this.UserRepositoryMock = new Mock<IUserRepository>(); + this.RoleRepositoryMock = new Mock<IRoleRepository>(); + this.CloudServiceMock = new Mock<ICloudService>(); + this.LanguageRepositoryMock = new Mock<ILanguageRepository>(); + this.TechnologyRepositoryMock = new Mock<ITechnologyRepository>(); + this.JWTOptions = new JWTOptions("gXfQlU6qpDleFWyimscjYcT3tgFsQg3yoFjcvSLxG56n1Vu2yptdIUq254wlJWjm"); + this.MapperMock = new Mock<IMapper>(); + // TODO: give actual UserManager and RoleManager to UserService + this.UserService = new UserService(this.UserRepositoryMock.Object, this.LanguageRepositoryMock.Object, this.RoleRepositoryMock.Object, this.TechnologyRepositoryMock.Object, null, null, this.MapperMock.Object, this.JWTOptions, this.CloudServiceMock.Object); + } + #endregion + + #region LoginUser + [Test] + public async Task LoginUser_ReturnsTokenModel_WhenLoggingUserIn() + { + string somePassword = "GoshoTrapovImaGolemChep"; + const string name = "GoshoTrapov"; + string hashedPassword = PasswordModifications.GeneratePasswordHash(somePassword); + LoginServiceModel loginServiceModel = new LoginServiceModel + { + Password = somePassword + }; + User user = new User + { + Id = Guid.NewGuid(), + PasswordHash = hashedPassword, + UserName = name + }; + + this.UserRepositoryMock.Setup(p => p.DoesUsernameExistAsync(It.IsAny<string>())).Returns(Task.FromResult(true)); + this.UserRepositoryMock.Setup(p => p.GetByUsernameAsync(It.IsAny<string>())).Returns(Task.FromResult(user)); + + string JWTSecurityToken = this.WriteJWTSecurityToken(user.Id, user.UserName, user.Roles); + + TokenModel tokenModel = await this.UserService.LoginUser(loginServiceModel); + + Assert.AreEqual(JWTSecurityToken, tokenModel.Token, "LoginUser does not return the correct token"); + } + + [Test] + public void LoginUser_ThrowsException_WhenUserNameDoesNotExist() + { + const string EXCEPTION_MESSAGE = "Invalid username!"; + LoginServiceModel loginServiceModel = new LoginServiceModel + { + }; + + this.UserRepositoryMock.Setup(p => p.DoesUsernameExistAsync(It.IsAny<string>())).Returns(Task.FromResult(false)); + + Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this.UserService.LoginUser(loginServiceModel)); + + Assert.AreEqual(EXCEPTION_MESSAGE, ex.Message, "Incorect Exception message"); + } + + [Test] + public void LoginUser_ThroiwsException_WhenPasswordIsIncorect() + { + const string EXCEPTION_MESSAGE = "Incorrect password!"; + string somePassword = "GoshoTrapovImaGolemChep"; + LoginServiceModel loginServiceModel = new LoginServiceModel + { + Password = somePassword + }; + User user = new User + { + Id = Guid.NewGuid(), + PasswordHash = "InvalidPasswordHas" + }; + + this.UserRepositoryMock.Setup(p => p.DoesUsernameExistAsync(It.IsAny<string>())).Returns(Task.FromResult(true)); + this.UserRepositoryMock.Setup(p => p.GetByUsernameAsync(It.IsAny<string>())).Returns(Task.FromResult(user)); + + Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this.UserService.LoginUser(loginServiceModel)); + + Assert.AreEqual(EXCEPTION_MESSAGE, ex.Message, "Incorect Exception message"); + } + #endregion + + #region RegisterUser + // [Test] + // public async Task RegisterUser_ReturnsTokenModel_WhenUserIsSuccessfull() + // { + // string somePassword = "GoshoTrapovImaGolemChep"; + // const string name = "GoshoTrapov"; + // RegisterServiceModel registerServiceModel = new RegisterServiceModel + // { + // Password = somePassword + // }; + // User user = new User + // { + // Id = Guid.NewGuid(), + // UserName = name + // }; + // Role role = new Role { Name = Role.DefaultRole }; + // HashSet<Role> roles = new HashSet<Role> { role }; + // + // this.UserRepositoryMock.Setup(p => p.DoesUsernameExistAsync(It.IsAny<string>())).Returns(Task.FromResult(false)); + // this.UserRepositoryMock.Setup(p => p.DoesEmailExistAsync(It.IsAny<string>())).Returns(Task.FromResult(false)); + // this.RoleRepositoryMock.Setup(p => p.DoesNameExist(It.IsAny<string>())).Returns(Task.FromResult(true)); + // this.RoleRepositoryMock.Setup(p => p.GetByNameAsync(It.IsAny<string>())).Returns(Task.FromResult(role)); + // this.MapperMock.Setup(p => p.Map<User>(It.IsAny<RegisterServiceModel>())).Returns(user); + // this.UserRepositoryMock.Setup(p => p.AddAsync(It.IsAny<User>())).Verifiable(); + // + // string JWTSecurityToken = this.WriteJWTSecurityToken(user.Id, user.UserName, roles); + // + // TokenModel tokenModel = await this.UserService.RegisterUser(registerServiceModel); + // + // Mock.Verify(); + // Assert.AreEqual(JWTSecurityToken, tokenModel.Token, "RegisterUser does not return the correct token"); + // } + + [Test] + public void RegisterUser_ThrowsException_WhenUsernameAlreadyExists() + { + const string EXCEPTION_MESSAGE = "Username already exists!"; + RegisterServiceModel registerServiceModel = new RegisterServiceModel + { + }; + + this.UserRepositoryMock.Setup(p => p.DoesUsernameExistAsync(It.IsAny<string>())).Returns(Task.FromResult(true)); + + Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this.UserService.RegisterUser(registerServiceModel)); + + Assert.AreEqual(EXCEPTION_MESSAGE, ex.Message, "Incorect Exception message"); + } + + [Test] + public void RegisterUser_ThrowsException_WhenEmailAlreadyExists() + { + const string EXCEPTION_MESSAGE = "Email already exists!"; + + RegisterServiceModel registerServiceModel = new RegisterServiceModel + { + }; + + this.UserRepositoryMock.Setup(p => p.DoesUsernameExistAsync(It.IsAny<string>())).Returns(Task.FromResult(false)); + this.UserRepositoryMock.Setup(p => p.DoesEmailExistAsync(It.IsAny<string>())).Returns(Task.FromResult(true)); + + Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this.UserService.RegisterUser(registerServiceModel)); + + Assert.AreEqual(EXCEPTION_MESSAGE, ex.Message, "Incorect Exception message"); + } + #endregion + + #region GetUserById + [Test] + public async Task GetUserById_ReturnsTheUser_WhenItExists() + { + Guid id = new Guid(); + string name = "Gosho Trapov"; + User user = new() + { + }; + UserServiceModel userServiceModel = new UserServiceModel + { + UserName = name + }; + + this.UserRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(user)); + this.MapperMock.Setup(p => p.Map<UserServiceModel>(It.IsAny<User>())).Returns(userServiceModel); + + UserServiceModel result = await this.UserService.GetUserById(id); + + Assert.AreEqual(name, result.UserName); + } + + [Test] + public void GetTechnologyById_ThrowsException_WhenTechnologyDoesNotExist() + { + const string EXCEPTION_MESSEGE = "User does not exist!"; + Guid id = new Guid(); + this.UserRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult<User>(null)); + + Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this.UserService.GetUserById(id)); + + Assert.AreEqual(EXCEPTION_MESSEGE, ex.Message, "Incorecct exception message"); + } + #endregion + + #region GetUserByUsername + [Test] + public async Task GetUserByUsername_ReturnsTheCorrectUser_IfItExists() + { + string username = "Gosho Trapov"; + User user = new User(); + UserServiceModel userServiceModel = new UserServiceModel + { + UserName = username + }; + + this.UserRepositoryMock.Setup(p => p.GetByUsernameAsync(It.IsAny<string>())).Returns(Task.FromResult(user)); + this.MapperMock.Setup(p => p.Map<UserServiceModel>(It.IsAny<User>())).Returns(userServiceModel); + + UserServiceModel result = await this.UserService.GetUserByUsername(username); + + Assert.AreEqual(username, result.UserName, "GetUserByUsername does not return the correct user"); + } + + [Test] + public async Task GetUserByUsername_ThrowsException_IfUserDoesNotExist() + { + string username = "Gosho Trapov"; + const string EXCEPTION_MESSEGE = "User does not exist!"; + + this.UserRepositoryMock.Setup(p => p.GetByUsernameAsync(It.IsAny<string>())).Returns(Task.FromResult<User>(null)); + + Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this.UserService.GetUserByUsername(username)); + + Assert.AreEqual(EXCEPTION_MESSEGE, ex.Message, "Incorecct exception message"); + } + #endregion + + #region UpdateUser + // [Test] + // [TestCase(true)] + // [TestCase(false)] + // public async Task UpdateUser_ReturnsIfUpdateIsSuccessfull_WhenUserExistsy(bool shouldPass) + // { + // string name = "Gosho Trapov"; + // Guid id = Guid.NewGuid(); + // User user = new User + // { + // UserName = name, + // Id = id, + // }; + // UpdateUserServiceModel updateUserServiceModel = new UpdateUserServiceModel + // { + // UserName = name, + // }; + // UserServiceModel userServiceModel = new UserServiceModel + // { + // UserName = name, + // }; + // Role role = new Role { }; + // + // this.UserRepositoryMock.Setup(p => p.DoesUserExistAsync(It.IsAny<Guid>())).Returns(Task.FromResult(true)); + // this.UserRepositoryMock.Setup(p => p.DoesUsernameExistAsync(It.IsAny<string>())).Returns(Task.FromResult(false)); + // this.UserRepositoryMock.Setup(p => p.DoesUserHaveThisUsername(It.IsAny<Guid>(), It.IsAny<string>())).Returns(true); + // this.UserRepositoryMock.Setup(p => p.EditAsync(It.IsAny<Guid>(), It.IsAny<User>())).Returns(Task.FromResult(shouldPass)); + // this.UserRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(user)); + // this.MapperMock.Setup(p => p.Map<User>(It.IsAny<UpdateUserServiceModel>())).Returns(user); + // this.MapperMock.Setup(p => p.Map<UserServiceModel>(It.IsAny<User>())).Returns(userServiceModel); + // + // if (shouldPass) + // { + // UserServiceModel result = await this.UserService.UpdateUser(updateUserServiceModel); + // + // Assert.AreEqual(updateUserServiceModel.UserName, result.UserName); + // } + // else + // { + // const string EXCEPTION_MESSAGE = "Unable to edit user!"; + // + // Exception ex = Assert.ThrowsAsync<InvalidOperationException>(() => this.UserService.UpdateUser(updateUserServiceModel)); + // + // Assert.AreEqual(EXCEPTION_MESSAGE, ex.Message, "Incorecct exception message"); + // } + // } + + [Test] + public void UpdateUser_ThrowsException_WhenUserDoesNotExist() + { + const string EXCEPTION_MESSAGE = "User does not exist!"; + UpdateUserServiceModel updateUserServiceModel = new UpdateUserServiceModel + { + }; + + this.UserRepositoryMock.Setup(p => p.DoesUserExistAsync(It.IsAny<Guid>())).Returns(Task.FromResult(false)); + + Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this.UserService.UpdateUser(updateUserServiceModel)); + + Assert.AreEqual(EXCEPTION_MESSAGE, ex.Message, "Incorecct exception message"); + } + + [Test] + public void UpdateUser_ThrowsException_WhenUserNameAlreadyExists() + { + const string EXCEPTION_MESSAGE = "Username already exists!"; + UpdateUserServiceModel updateUserServiceModel = new UpdateUserServiceModel + { + }; + + this.UserRepositoryMock.Setup(p => p.DoesUserExistAsync(It.IsAny<Guid>())).Returns(Task.FromResult(true)); + this.UserRepositoryMock.Setup(p => p.DoesUsernameExistAsync(It.IsAny<string>())).Returns(Task.FromResult(true)); + + Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this.UserService.UpdateUser(updateUserServiceModel)); + + Assert.AreEqual(EXCEPTION_MESSAGE, ex.Message, "Incorecct exception message"); + } + #endregion + + #region DeleteUser + //TO DO: compleate once Viko has looked into the return type of UserService.DeleteUser + // [Test] + // [TestCase(true)] + // [TestCase(false)] + // public async Task DeleteUser_ShouldReturnIfDeletionIsSuccessfull_WhenUserExists(bool shouldPass) + // { + // Guid id = new Guid(); + // User user = new User(); + // + // this.UserRepositoryMock.Setup(p => p.DoesUserExistAsync(It.IsAny<Guid>())).Returns(Task.FromResult(true)); + // this.UserRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny<Guid>())).Returns(Task.FromResult(user)); + // this.UserRepositoryMock.Setup(p => p.DeleteAsync(It.IsAny<User>())).Returns(Task.FromResult(shouldPass)); + // + // bool result = await this.UserService.DeleteUser(id); + // + // Assert.AreEqual(shouldPass, result); + // } + // + [Test] + public void DeleteUser_ThrowsException_WhenUserDoesNotExist() + { + string exceptionMessage = "User does not exist!"; + Guid id = new Guid(); + + this.UserRepositoryMock.Setup(p => p.DoesUserExistAsync(It.IsAny<Guid>())).Returns(Task.FromResult(false)); + + Exception ex = Assert.ThrowsAsync<ArgumentException>(() => this.UserService.DeleteUser(id)); + + Assert.AreEqual(exceptionMessage, ex.Message, "Incorecct exception message"); + } + #endregion + + #region HelperMethods + private string WriteJWTSecurityToken(Guid userId, string username, HashSet<Role> roles) + { + byte[] signingKey = Encoding.ASCII.GetBytes(this.JWTOptions.Secret); + HashSet<Claim> claims = new() + { + new Claim("ID", $"{userId}"), + new Claim("Username", username), + }; + + foreach (var role in roles) + { + claims.Add(new Claim(ClaimTypes.Role, role.Name)); + } + + SecurityTokenDescriptor tokenDescriptor = new() + { + Subject = new ClaimsIdentity(claims), + Expires = DateTime.Today.AddDays(7), + SigningCredentials = new SigningCredentials( + new SymmetricSecurityKey(signingKey), + SecurityAlgorithms.HmacSha512Signature) + }; + + JwtSecurityTokenHandler tokenHandler = new(); + SecurityToken token = tokenHandler.CreateToken(tokenDescriptor); + return tokenHandler.WriteToken(token); + } + #endregion + } +} diff --git a/src/DevHive.Tests/DevHive.Web.Tests/CommentController.Tests.cs b/src/DevHive.Tests/DevHive.Web.Tests/CommentController.Tests.cs new file mode 100644 index 0000000..3a03f1a --- /dev/null +++ b/src/DevHive.Tests/DevHive.Web.Tests/CommentController.Tests.cs @@ -0,0 +1,256 @@ +using System; +using System.Linq; +using System.Threading.Tasks; +using AutoMapper; +using DevHive.Services.Interfaces; +using DevHive.Services.Models.Comment; +using DevHive.Web.Controllers; +using DevHive.Web.Models.Comment; +using Microsoft.AspNetCore.Mvc; +using Moq; +using NUnit.Framework; + +namespace DevHive.Web.Tests +{ + [TestFixture] + public class CommentControllerTests + { + const string MESSAGE = "Gosho Trapov"; + private Mock<ICommentService> CommentServiceMock { get; set; } + private Mock<IMapper> MapperMock { get; set; } + private CommentController CommentController { get; set; } + + #region Setup + [SetUp] + public void SetUp() + { + this.CommentServiceMock = new Mock<ICommentService>(); + this.MapperMock = new Mock<IMapper>(); + this.CommentController = new CommentController(this.CommentServiceMock.Object, this.MapperMock.Object); + } + #endregion + + #region Add + [Test] + public void AddComment_ReturnsOkObjectResult_WhenCommentIsSuccessfullyCreated() + { + Guid id = Guid.NewGuid(); + CreateCommentWebModel createCommentWebModel = new CreateCommentWebModel + { + Message = MESSAGE + }; + CreateCommentServiceModel createCommentServiceModel = new CreateCommentServiceModel + { + Message = MESSAGE + }; + + this.MapperMock.Setup(p => p.Map<CreateCommentServiceModel>(It.IsAny<CreateCommentWebModel>())).Returns(createCommentServiceModel); + this.CommentServiceMock.Setup(p => p.AddComment(It.IsAny<CreateCommentServiceModel>())).Returns(Task.FromResult(id)); + this.CommentServiceMock.Setup(p => p.ValidateJwtForCreating(It.IsAny<Guid>(), It.IsAny<string>())).Returns(Task.FromResult(true)); + + IActionResult result = this.CommentController.AddComment(Guid.NewGuid(), createCommentWebModel, null).Result; + + Assert.IsInstanceOf<OkObjectResult>(result); + + var splitted = (result as OkObjectResult).Value + .ToString() + .Split('{', '}', '=', ' ') + .Where(x => !string.IsNullOrEmpty(x)) + .ToArray(); + + Guid resultId = Guid.Parse(splitted[1]); + + Assert.AreEqual(id, resultId); + } + + [Test] + public void AddComment_ReturnsBadRequestObjectResult_WhenCommentIsNotCreatedSuccessfully() + { + Guid id = Guid.NewGuid(); + CreateCommentWebModel createCommentWebModel = new CreateCommentWebModel + { + Message = MESSAGE + }; + CreateCommentServiceModel createCommentServiceModel = new CreateCommentServiceModel + { + Message = MESSAGE + }; + string errorMessage = $"Could not create comment!"; + + + this.MapperMock.Setup(p => p.Map<CreateCommentServiceModel>(It.IsAny<CreateCommentWebModel>())).Returns(createCommentServiceModel); + this.CommentServiceMock.Setup(p => p.AddComment(It.IsAny<CreateCommentServiceModel>())).Returns(Task.FromResult(Guid.Empty)); + this.CommentServiceMock.Setup(p => p.ValidateJwtForCreating(It.IsAny<Guid>(), It.IsAny<string>())).Returns(Task.FromResult(true)); + + IActionResult result = this.CommentController.AddComment(Guid.NewGuid(), createCommentWebModel, null).Result; + + Assert.IsInstanceOf<BadRequestObjectResult>(result); + + BadRequestObjectResult badRequsetObjectResult = result as BadRequestObjectResult; + string resultMessage = badRequsetObjectResult.Value.ToString(); + + Assert.AreEqual(errorMessage, resultMessage); + } + + [Test] + public void AddComment_ReturnsUnauthorizedResult_WhenUserIsNotAuthorized() + { + Guid id = Guid.NewGuid(); + CreateCommentWebModel createCommentWebModel = new CreateCommentWebModel + { + Message = MESSAGE + }; + + this.CommentServiceMock.Setup(p => p.ValidateJwtForCreating(It.IsAny<Guid>(), It.IsAny<string>())).Returns(Task.FromResult(false)); + + IActionResult result = this.CommentController.AddComment(Guid.NewGuid(), createCommentWebModel, null).Result; + + Assert.IsInstanceOf<UnauthorizedResult>(result); + } + #endregion + + #region Read + [Test] + public void GetById_ReturnsTheComment_WhenItExists() + { + Guid id = Guid.NewGuid(); + + ReadCommentServiceModel readCommentServiceModel = new ReadCommentServiceModel + { + Message = MESSAGE + }; + ReadCommentWebModel readCommentWebModel = new ReadCommentWebModel + { + Message = MESSAGE + }; + + this.CommentServiceMock.Setup(p => p.GetCommentById(It.IsAny<Guid>())).Returns(Task.FromResult(readCommentServiceModel)); + this.MapperMock.Setup(p => p.Map<ReadCommentWebModel>(It.IsAny<ReadCommentServiceModel>())).Returns(readCommentWebModel); + + IActionResult result = this.CommentController.GetCommentById(id).Result; + + Assert.IsInstanceOf<OkObjectResult>(result); + + OkObjectResult okObjectResult = result as OkObjectResult; + ReadCommentWebModel resultModel = okObjectResult.Value as Models.Comment.ReadCommentWebModel; + + Assert.AreEqual(MESSAGE, resultModel.Message); + } + #endregion + + #region Update + [Test] + public void Update_ShouldReturnOkResult_WhenCommentIsUpdatedSuccessfully() + { + Guid id = Guid.NewGuid(); + UpdateCommentWebModel updateCommentWebModel = new UpdateCommentWebModel + { + NewMessage = MESSAGE + }; + UpdateCommentServiceModel updateCommentServiceModel = new UpdateCommentServiceModel + { + NewMessage = MESSAGE + }; + + this.CommentServiceMock.Setup(p => p.UpdateComment(It.IsAny<UpdateCommentServiceModel>())).Returns(Task.FromResult(id)); + this.CommentServiceMock.Setup(p => p.ValidateJwtForComment(It.IsAny<Guid>(), It.IsAny<string>())).Returns(Task.FromResult(true)); + this.MapperMock.Setup(p => p.Map<UpdateCommentServiceModel>(It.IsAny<UpdateCommentWebModel>())).Returns(updateCommentServiceModel); + + IActionResult result = this.CommentController.UpdateComment(Guid.Empty, updateCommentWebModel, null).Result; + + Assert.IsInstanceOf<OkObjectResult>(result); + + OkObjectResult okObjectResult = result as OkObjectResult; + object resultModel = okObjectResult.Value; + string[] resultAsString = resultModel.ToString().Split(' ').ToArray(); + + Assert.AreEqual(id.ToString(), resultAsString[3]); + } + + [Test] + public void Update_ShouldReturnBadObjectResult_WhenCommentIsNotUpdatedSuccessfully() + { + string message = "Unable to update comment!"; + UpdateCommentWebModel updateCommentWebModel = new UpdateCommentWebModel + { + NewMessage = MESSAGE + }; + UpdateCommentServiceModel updateCommentServiceModel = new UpdateCommentServiceModel + { + NewMessage = MESSAGE + }; + + this.CommentServiceMock.Setup(p => p.UpdateComment(It.IsAny<UpdateCommentServiceModel>())).Returns(Task.FromResult(Guid.Empty)); + this.CommentServiceMock.Setup(p => p.ValidateJwtForComment(It.IsAny<Guid>(), It.IsAny<string>())).Returns(Task.FromResult(true)); + this.MapperMock.Setup(p => p.Map<UpdateCommentServiceModel>(It.IsAny<UpdateCommentWebModel>())).Returns(updateCommentServiceModel); + + IActionResult result = this.CommentController.UpdateComment(Guid.Empty, updateCommentWebModel, null).Result; + Assert.IsInstanceOf<BadRequestObjectResult>(result); + + BadRequestObjectResult badRequestObjectResult = result as BadRequestObjectResult; + string resultModel = badRequestObjectResult.Value.ToString(); + + Assert.AreEqual(message, resultModel); + } + + [Test] + public void Update_ShouldReturnUnauthorizedResult_WhenUserIsNotAuthorized() + { + UpdateCommentWebModel updateCommentWebModel = new UpdateCommentWebModel + { + NewMessage = MESSAGE + }; + + this.CommentServiceMock.Setup(p => p.ValidateJwtForComment(It.IsAny<Guid>(), It.IsAny<string>())).Returns(Task.FromResult(false)); + + IActionResult result = this.CommentController.UpdateComment(Guid.Empty, updateCommentWebModel, null).Result; + + Assert.IsInstanceOf<UnauthorizedResult>(result); + } + #endregion + + #region Delete + [Test] + public void Delete_ReturnsOkResult_WhenCommentIsDeletedSuccessfully() + { + Guid id = Guid.NewGuid(); + + this.CommentServiceMock.Setup(p => p.DeleteComment(It.IsAny<Guid>())).Returns(Task.FromResult(true)); + this.CommentServiceMock.Setup(p => p.ValidateJwtForComment(It.IsAny<Guid>(), It.IsAny<string>())).Returns(Task.FromResult(true)); + + IActionResult result = this.CommentController.DeleteComment(id, null).Result; + + Assert.IsInstanceOf<OkResult>(result); + } + + [Test] + public void DeletComment_ReturnsBadRequestObjectResult_WhenCommentIsNotDeletedSuccessfully() + { + string message = "Could not delete Comment"; + Guid id = Guid.NewGuid(); + + this.CommentServiceMock.Setup(p => p.DeleteComment(It.IsAny<Guid>())).Returns(Task.FromResult(false)); + this.CommentServiceMock.Setup(p => p.ValidateJwtForComment(It.IsAny<Guid>(), It.IsAny<string>())).Returns(Task.FromResult(true)); + + IActionResult result = this.CommentController.DeleteComment(id, null).Result; + + Assert.IsInstanceOf<BadRequestObjectResult>(result); + + BadRequestObjectResult badRequestObjectResult = result as BadRequestObjectResult; + string resultModel = badRequestObjectResult.Value.ToString(); + + Assert.AreEqual(message, resultModel); + } + + [Test] + public void DeletComment_ReturnsUnauthorizedResult_WhenUserIsNotAuthorized() + { + this.CommentServiceMock.Setup(p => p.ValidateJwtForComment(It.IsAny<Guid>(), It.IsAny<string>())).Returns(Task.FromResult(false)); + + IActionResult result = this.CommentController.DeleteComment(Guid.Empty, null).Result; + + Assert.IsInstanceOf<UnauthorizedResult>(result); + } + #endregion + } +} diff --git a/src/DevHive.Tests/DevHive.Web.Tests/DevHive.Web.Tests.csproj b/src/DevHive.Tests/DevHive.Web.Tests/DevHive.Web.Tests.csproj new file mode 100644 index 0000000..a171e0b --- /dev/null +++ b/src/DevHive.Tests/DevHive.Web.Tests/DevHive.Web.Tests.csproj @@ -0,0 +1,24 @@ +<Project Sdk="Microsoft.NET.Sdk"> + + <PropertyGroup> + <TargetFramework>net5.0</TargetFramework> + + <IsPackable>false</IsPackable> + </PropertyGroup> + + <ItemGroup> + <PackageReference Include="Moq" Version="4.16.0" /> + <PackageReference Include="NUnit" Version="3.13.0" /> + <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" /> + <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.8.3" /> + </ItemGroup> + + <ItemGroup> + <ProjectReference Include="..\..\DevHive.Web\DevHive.Web.csproj" /> + </ItemGroup> + + <PropertyGroup> + <EnableNETAnalyzers>true</EnableNETAnalyzers> + <AnalysisLevel>latest</AnalysisLevel> + </PropertyGroup> +</Project> diff --git a/src/DevHive.Tests/DevHive.Web.Tests/FeedController.Tests.cs b/src/DevHive.Tests/DevHive.Web.Tests/FeedController.Tests.cs new file mode 100644 index 0000000..01f67e5 --- /dev/null +++ b/src/DevHive.Tests/DevHive.Web.Tests/FeedController.Tests.cs @@ -0,0 +1,98 @@ +using System; +using System.Collections.Generic; +using System.Threading.Tasks; +using AutoMapper; +using DevHive.Services.Interfaces; +using DevHive.Services.Models; +using DevHive.Web.Controllers; +using DevHive.Web.Models.Comment; +using DevHive.Web.Models.Feed; +using DevHive.Web.Models.Post; +using Microsoft.AspNetCore.Mvc; +using Moq; +using NUnit.Framework; + +namespace DevHive.Web.Tests +{ + [TestFixture] + public class FeedControllerTests + { + private Mock<IFeedService> FeedServiceMock { get; set; } + private Mock<IMapper> MapperMock { get; set; } + private FeedController FeedController { get; set; } + + #region SetUp + [SetUp] + public void SetUp() + { + this.FeedServiceMock = new Mock<IFeedService>(); + this.MapperMock = new Mock<IMapper>(); + this.FeedController = new FeedController(this.FeedServiceMock.Object, this.MapperMock.Object); + } + #endregion + + #region GetPosts + [Test] + public async Task GetPosts_ReturnsOkObjectResultWithCorrectReadPageWebModel_WhenPostsExist() + { + GetPageWebModel getPageWebModel = new GetPageWebModel { }; + GetPageServiceModel getPageServiceModel = new GetPageServiceModel { }; + ReadPageServiceModel readPageServiceModel = new ReadPageServiceModel { }; + ReadPageWebModel readPageWebModel = new ReadPageWebModel + { + Posts = new List<ReadPostWebModel> + { + new ReadPostWebModel(), + new ReadPostWebModel(), + new ReadPostWebModel() + } + }; + + this.FeedServiceMock.Setup(p => p.GetPage(It.IsAny<GetPageServiceModel>())).Returns(Task.FromResult(readPageServiceModel)); + this.MapperMock.Setup(p => p.Map<GetPageServiceModel>(It.IsAny<GetPageWebModel>())).Returns(getPageServiceModel); + this.MapperMock.Setup(p => p.Map<ReadPageWebModel>(It.IsAny<ReadPageServiceModel>())).Returns(readPageWebModel); + + IActionResult result = await this.FeedController.GetPosts(Guid.Empty, getPageWebModel); + + Assert.IsInstanceOf<OkObjectResult>(result); + + OkObjectResult okObjectResult = result as OkObjectResult; + ReadPageWebModel resultModel = okObjectResult.Value as Models.Comment.ReadPageWebModel; + + Assert.AreEqual(3, resultModel.Posts.Count); + } + #endregion + + #region GetUserPosts + [Test] + public async Task GetUserPosts_GetsPostsOfUser_WhenTheyExist() + { + GetPageWebModel getPageWebModel = new GetPageWebModel { }; + GetPageServiceModel getPageServiceModel = new GetPageServiceModel { }; + ReadPageServiceModel readPageServiceModel = new ReadPageServiceModel { }; + ReadPageWebModel readPageWebModel = new ReadPageWebModel + { + Posts = new List<ReadPostWebModel> + { + new ReadPostWebModel(), + new ReadPostWebModel(), + new ReadPostWebModel() + } + }; + + this.FeedServiceMock.Setup(p => p.GetUserPage(It.IsAny<GetPageServiceModel>())).Returns(Task.FromResult(readPageServiceModel)); + this.MapperMock.Setup(p => p.Map<GetPageServiceModel>(It.IsAny<GetPageWebModel>())).Returns(getPageServiceModel); + this.MapperMock.Setup(p => p.Map<ReadPageWebModel>(It.IsAny<ReadPageServiceModel>())).Returns(readPageWebModel); + + IActionResult result = await this.FeedController.GetUserPosts(null, getPageWebModel); + + Assert.IsInstanceOf<OkObjectResult>(result); + + OkObjectResult okObjectResult = result as OkObjectResult; + ReadPageWebModel resultModel = okObjectResult.Value as Models.Comment.ReadPageWebModel; + + Assert.AreEqual(3, resultModel.Posts.Count); + } + #endregion + } +} diff --git a/src/DevHive.Tests/DevHive.Web.Tests/LanguageController.Tests.cs b/src/DevHive.Tests/DevHive.Web.Tests/LanguageController.Tests.cs new file mode 100644 index 0000000..7c8d64e --- /dev/null +++ b/src/DevHive.Tests/DevHive.Web.Tests/LanguageController.Tests.cs @@ -0,0 +1,201 @@ +using System; +using System.Linq; +using System.Threading.Tasks; +using AutoMapper; +using DevHive.Services.Interfaces; +using DevHive.Services.Models.Language; +using DevHive.Web.Controllers; +using DevHive.Web.Models.Language; +using Microsoft.AspNetCore.Mvc; +using Moq; +using NUnit.Framework; + +namespace DevHive.Web.Tests +{ + [TestFixture] + public class LanguageControllerTests + { + const string NAME = "Gosho Trapov"; + private Mock<ILanguageService> LanguageServiceMock { get; set; } + private Mock<IMapper> MapperMock { get; set; } + private LanguageController LanguageController { get; set; } + + [SetUp] + public void SetUp() + { + this.LanguageServiceMock = new Mock<ILanguageService>(); + this.MapperMock = new Mock<IMapper>(); + this.LanguageController = new LanguageController(this.LanguageServiceMock.Object, this.MapperMock.Object); + } + + #region Create + [Test] + public void CreateLanguage_ReturnsOkObjectResult_WhenLanguageIsSuccessfullyCreated() + { + CreateLanguageWebModel createLanguageWebModel = new CreateLanguageWebModel + { + Name = NAME + }; + CreateLanguageServiceModel createLanguageServiceModel = new CreateLanguageServiceModel + { + Name = NAME + }; + Guid id = Guid.NewGuid(); + + this.MapperMock.Setup(p => p.Map<CreateLanguageServiceModel>(It.IsAny<CreateLanguageWebModel>())).Returns(createLanguageServiceModel); + this.LanguageServiceMock.Setup(p => p.CreateLanguage(It.IsAny<CreateLanguageServiceModel>())).Returns(Task.FromResult(id)); + + IActionResult result = this.LanguageController.Create(createLanguageWebModel).Result; + + Assert.IsInstanceOf<OkObjectResult>(result); + + var splitted = (result as OkObjectResult).Value + .ToString() + .Split('{', '}', '=', ' ') + .Where(x => !string.IsNullOrEmpty(x)) + .ToArray(); + + Guid resultId = Guid.Parse(splitted[1]); + + Assert.AreEqual(id, resultId); + } + + [Test] + public void CreateLanguage_ReturnsBadRequestObjectResult_WhenLanguageIsNotCreatedSuccessfully() + { + CreateLanguageWebModel createTechnologyWebModel = new CreateLanguageWebModel + { + Name = NAME + }; + CreateLanguageServiceModel createTechnologyServiceModel = new CreateLanguageServiceModel + { + Name = NAME + }; + Guid id = Guid.Empty; + string errorMessage = $"Could not create language {NAME}"; + + this.MapperMock.Setup(p => p.Map<CreateLanguageServiceModel>(It.IsAny<CreateLanguageWebModel>())).Returns(createTechnologyServiceModel); + this.LanguageServiceMock.Setup(p => p.CreateLanguage(It.IsAny<CreateLanguageServiceModel>())).Returns(Task.FromResult(id)); + + IActionResult result = this.LanguageController.Create(createTechnologyWebModel).Result; + + Assert.IsInstanceOf<BadRequestObjectResult>(result); + + BadRequestObjectResult badRequsetObjectResult = result as BadRequestObjectResult; + string resultMessage = badRequsetObjectResult.Value.ToString(); + + Assert.AreEqual(errorMessage, resultMessage); + } + #endregion + + #region Read + [Test] + public void GetById_ReturnsTheLanguage_WhenItExists() + { + Guid id = Guid.NewGuid(); + + ReadLanguageServiceModel readLanguageServiceModel = new ReadLanguageServiceModel + { + Name = NAME + }; + ReadLanguageWebModel readLanguageWebModel = new ReadLanguageWebModel + { + Name = NAME + }; + + this.LanguageServiceMock.Setup(p => p.GetLanguageById(It.IsAny<Guid>())).Returns(Task.FromResult(readLanguageServiceModel)); + this.MapperMock.Setup(p => p.Map<ReadLanguageWebModel>(It.IsAny<ReadLanguageServiceModel>())).Returns(readLanguageWebModel); + + IActionResult result = this.LanguageController.GetById(id).Result; + + Assert.IsInstanceOf<OkObjectResult>(result); + + OkObjectResult okObjectResult = result as OkObjectResult; + ReadLanguageWebModel resultModel = okObjectResult.Value as Models.Language.ReadLanguageWebModel; + + Assert.AreEqual(NAME, resultModel.Name); + } + #endregion + + #region Update + [Test] + public void Update_ShouldReturnOkResult_WhenLanguageIsUpdatedSuccessfully() + { + Guid id = Guid.NewGuid(); + UpdateLanguageWebModel updateLanguageWebModel = new UpdateLanguageWebModel + { + Name = NAME + }; + UpdateLanguageServiceModel updateLanguageServiceModel = new UpdateLanguageServiceModel + { + Name = NAME + }; + + this.LanguageServiceMock.Setup(p => p.UpdateLanguage(It.IsAny<UpdateLanguageServiceModel>())).Returns(Task.FromResult(true)); + this.MapperMock.Setup(p => p.Map<UpdateLanguageServiceModel>(It.IsAny<UpdateLanguageWebModel>())).Returns(updateLanguageServiceModel); + + IActionResult result = this.LanguageController.Update(id, updateLanguageWebModel).Result; + + Assert.IsInstanceOf<OkResult>(result); + } + + [Test] + public void Update_ShouldReturnBadObjectResult_WhenLanguageIsNotUpdatedSuccessfully() + { + Guid id = Guid.NewGuid(); + string message = "Could not update Language"; + UpdateLanguageWebModel updateLanguageWebModel = new UpdateLanguageWebModel + { + Name = NAME + }; + UpdateLanguageServiceModel updateLanguageServiceModel = new UpdateLanguageServiceModel + { + Name = NAME + }; + + this.LanguageServiceMock.Setup(p => p.UpdateLanguage(It.IsAny<UpdateLanguageServiceModel>())).Returns(Task.FromResult(false)); + this.MapperMock.Setup(p => p.Map<UpdateLanguageServiceModel>(It.IsAny<UpdateLanguageWebModel>())).Returns(updateLanguageServiceModel); + + IActionResult result = this.LanguageController.Update(id, updateLanguageWebModel).Result; + Assert.IsInstanceOf<BadRequestObjectResult>(result); + + BadRequestObjectResult badRequestObjectResult = result as BadRequestObjectResult; + string resultModel = badRequestObjectResult.Value.ToString(); + + Assert.AreEqual(message, resultModel); + } + #endregion + + #region Delete + [Test] + public void Delete_ReturnsOkResult_WhenLanguageIsDeletedSuccessfully() + { + Guid id = Guid.NewGuid(); + + this.LanguageServiceMock.Setup(p => p.DeleteLanguage(It.IsAny<Guid>())).Returns(Task.FromResult(true)); + + IActionResult result = this.LanguageController.Delete(id).Result; + + Assert.IsInstanceOf<OkResult>(result); + } + + [Test] + public void Delet_ReturnsBadRequestObjectResult_WhenLanguageIsNotDeletedSuccessfully() + { + string message = "Could not delete Language"; + Guid id = Guid.NewGuid(); + + this.LanguageServiceMock.Setup(p => p.DeleteLanguage(It.IsAny<Guid>())).Returns(Task.FromResult(false)); + + IActionResult result = this.LanguageController.Delete(id).Result; + + Assert.IsInstanceOf<BadRequestObjectResult>(result); + + BadRequestObjectResult badRequestObjectResult = result as BadRequestObjectResult; + string resultModel = badRequestObjectResult.Value.ToString(); + + Assert.AreEqual(message, resultModel); + } + #endregion + } +} diff --git a/src/DevHive.Tests/DevHive.Web.Tests/PostController.Tests.cs b/src/DevHive.Tests/DevHive.Web.Tests/PostController.Tests.cs new file mode 100644 index 0000000..3a4e45e --- /dev/null +++ b/src/DevHive.Tests/DevHive.Web.Tests/PostController.Tests.cs @@ -0,0 +1,248 @@ +using System; +using System.Linq; +using System.Threading.Tasks; +using AutoMapper; +using DevHive.Services.Interfaces; +using DevHive.Services.Models.Post; +using DevHive.Web.Controllers; +using DevHive.Web.Models.Post; +using Microsoft.AspNetCore.Mvc; +using Moq; +using NUnit.Framework; + +namespace DevHive.Web.Tests +{ + [TestFixture] + public class PostControllerTests + { + const string MESSAGE = "Gosho Trapov"; + private Mock<IPostService> PostServiceMock { get; set; } + private Mock<IMapper> MapperMock { get; set; } + private PostController PostController { get; set; } + + [SetUp] + public void SetUp() + { + this.PostServiceMock = new Mock<IPostService>(); + this.MapperMock = new Mock<IMapper>(); + this.PostController = new PostController(this.PostServiceMock.Object, this.MapperMock.Object); + } + + #region Create + [Test] + public void CreatePost_ReturnsOkObjectResult_WhenPostIsSuccessfullyCreated() + { + CreatePostWebModel createPostWebModel = new CreatePostWebModel + { + Message = MESSAGE + }; + CreatePostServiceModel createPostServiceModel = new CreatePostServiceModel + { + Message = MESSAGE + }; + Guid id = Guid.NewGuid(); + + this.MapperMock.Setup(p => p.Map<CreatePostServiceModel>(It.IsAny<CreatePostWebModel>())).Returns(createPostServiceModel); + this.PostServiceMock.Setup(p => p.CreatePost(It.IsAny<CreatePostServiceModel>())).Returns(Task.FromResult(id)); + this.PostServiceMock.Setup(p => p.ValidateJwtForCreating(It.IsAny<Guid>(), It.IsAny<string>())).Returns(Task.FromResult(true)); + + IActionResult result = this.PostController.Create(Guid.Empty, createPostWebModel, null).Result; + + Assert.IsInstanceOf<OkObjectResult>(result); + + var splitted = (result as OkObjectResult).Value + .ToString() + .Split('{', '}', '=', ' ') + .Where(x => !string.IsNullOrEmpty(x)) + .ToArray(); + + Guid resultId = Guid.Parse(splitted[1]); + + Assert.AreEqual(id, resultId); + } + + [Test] + public void CreatePost_ReturnsBadRequestObjectResult_WhenPostIsNotCreatedSuccessfully() + { + CreatePostWebModel createTechnologyWebModel = new CreatePostWebModel + { + Message = MESSAGE + }; + CreatePostServiceModel createTechnologyServiceModel = new CreatePostServiceModel + { + Message = MESSAGE + }; + Guid id = Guid.Empty; + string errorMessage = $"Could not create post!"; + + this.MapperMock.Setup(p => p.Map<CreatePostServiceModel>(It.IsAny<CreatePostWebModel>())).Returns(createTechnologyServiceModel); + this.PostServiceMock.Setup(p => p.CreatePost(It.IsAny<CreatePostServiceModel>())).Returns(Task.FromResult(id)); + this.PostServiceMock.Setup(p => p.ValidateJwtForCreating(It.IsAny<Guid>(), It.IsAny<string>())).Returns(Task.FromResult(true)); + + IActionResult result = this.PostController.Create(Guid.Empty, createTechnologyWebModel, null).Result; + + Assert.IsInstanceOf<BadRequestObjectResult>(result); + + BadRequestObjectResult badRequsetObjectResult = result as BadRequestObjectResult; + string resultMessage = badRequsetObjectResult.Value.ToString(); + + Assert.AreEqual(errorMessage, resultMessage); + } + + [Test] + public void CreatePost_ReturnsUnauthorizedResult_WhenUserIsNotAuthorized() + { + Guid id = Guid.NewGuid(); + CreatePostWebModel createPostWebModel = new CreatePostWebModel + { + Message = MESSAGE + }; + + this.PostServiceMock.Setup(p => p.ValidateJwtForCreating(It.IsAny<Guid>(), It.IsAny<string>())).Returns(Task.FromResult(false)); + + IActionResult result = this.PostController.Create(Guid.NewGuid(), createPostWebModel, null).Result; + + Assert.IsInstanceOf<UnauthorizedResult>(result); + } + #endregion + + #region Read + [Test] + public void GetById_ReturnsThePost_WhenItExists() + { + Guid id = Guid.NewGuid(); + + ReadPostServiceModel readPostServiceModel = new ReadPostServiceModel + { + Message = MESSAGE + }; + ReadPostWebModel readPostWebModel = new ReadPostWebModel + { + Message = MESSAGE + }; + + this.PostServiceMock.Setup(p => p.GetPostById(It.IsAny<Guid>())).Returns(Task.FromResult(readPostServiceModel)); + this.MapperMock.Setup(p => p.Map<ReadPostWebModel>(It.IsAny<ReadPostServiceModel>())).Returns(readPostWebModel); + + IActionResult result = this.PostController.GetById(id).Result; + + Assert.IsInstanceOf<OkObjectResult>(result); + + OkObjectResult okObjectResult = result as OkObjectResult; + ReadPostWebModel resultModel = okObjectResult.Value as Models.Post.ReadPostWebModel; + + Assert.AreEqual(MESSAGE, resultModel.Message); + } + #endregion + + #region Update + [Test] + public void Update_ShouldReturnOkResult_WhenPostIsUpdatedSuccessfully() + { + Guid id = Guid.NewGuid(); + UpdatePostWebModel updatePostWebModel = new UpdatePostWebModel + { + NewMessage = MESSAGE + }; + UpdatePostServiceModel updatePostServiceModel = new UpdatePostServiceModel + { + NewMessage = MESSAGE + }; + + this.PostServiceMock.Setup(p => p.UpdatePost(It.IsAny<UpdatePostServiceModel>())).Returns(Task.FromResult(id)); + this.MapperMock.Setup(p => p.Map<UpdatePostServiceModel>(It.IsAny<UpdatePostWebModel>())).Returns(updatePostServiceModel); + this.PostServiceMock.Setup(p => p.ValidateJwtForPost(It.IsAny<Guid>(), It.IsAny<string>())).Returns(Task.FromResult(true)); + + IActionResult result = this.PostController.Update(id, updatePostWebModel, null).Result; + + Assert.IsInstanceOf<OkObjectResult>(result); + } + + [Test] + public void Update_ShouldReturnBadObjectResult_WhenPostIsNotUpdatedSuccessfully() + { + Guid id = Guid.NewGuid(); + string message = "Could not update post!"; + UpdatePostWebModel updatePostWebModel = new UpdatePostWebModel + { + NewMessage = MESSAGE + }; + UpdatePostServiceModel updatePostServiceModel = new UpdatePostServiceModel + { + NewMessage = MESSAGE + }; + + this.PostServiceMock.Setup(p => p.UpdatePost(It.IsAny<UpdatePostServiceModel>())).Returns(Task.FromResult(Guid.Empty)); + this.MapperMock.Setup(p => p.Map<UpdatePostServiceModel>(It.IsAny<UpdatePostWebModel>())).Returns(updatePostServiceModel); + this.PostServiceMock.Setup(p => p.ValidateJwtForPost(It.IsAny<Guid>(), It.IsAny<string>())).Returns(Task.FromResult(true)); + + IActionResult result = this.PostController.Update(id, updatePostWebModel, null).Result; + Assert.IsInstanceOf<BadRequestObjectResult>(result); + + BadRequestObjectResult badRequestObjectResult = result as BadRequestObjectResult; + string resultModel = badRequestObjectResult.Value.ToString(); + + Assert.AreEqual(message, resultModel); + } + + [Test] + public void Update_ShouldReturnUnauthorizedResult_WhenUserIsNotAuthorized() + { + UpdatePostWebModel updatePostWebModel = new UpdatePostWebModel + { + NewMessage = MESSAGE + }; + + this.PostServiceMock.Setup(p => p.ValidateJwtForPost(It.IsAny<Guid>(), It.IsAny<string>())).Returns(Task.FromResult(false)); + + IActionResult result = this.PostController.Update(Guid.Empty, updatePostWebModel, null).Result; + + Assert.IsInstanceOf<UnauthorizedResult>(result); + } + #endregion + + #region Delete + [Test] + public void Delete_ReturnsOkResult_WhenPostIsDeletedSuccessfully() + { + Guid id = Guid.NewGuid(); + + this.PostServiceMock.Setup(p => p.DeletePost(It.IsAny<Guid>())).Returns(Task.FromResult(true)); + this.PostServiceMock.Setup(p => p.ValidateJwtForPost(It.IsAny<Guid>(), It.IsAny<string>())).Returns(Task.FromResult(true)); + + IActionResult result = this.PostController.Delete(id, null).Result; + + Assert.IsInstanceOf<OkResult>(result); + } + + [Test] + public void Delete_ReturnsBadRequestObjectResult_WhenPostIsNotDeletedSuccessfully() + { + string message = "Could not delete Post"; + Guid id = Guid.NewGuid(); + + this.PostServiceMock.Setup(p => p.DeletePost(It.IsAny<Guid>())).Returns(Task.FromResult(false)); + this.PostServiceMock.Setup(p => p.ValidateJwtForPost(It.IsAny<Guid>(), It.IsAny<string>())).Returns(Task.FromResult(true)); + + IActionResult result = this.PostController.Delete(id, null).Result; + + Assert.IsInstanceOf<BadRequestObjectResult>(result); + + BadRequestObjectResult badRequestObjectResult = result as BadRequestObjectResult; + string resultModel = badRequestObjectResult.Value.ToString(); + + Assert.AreEqual(message, resultModel); + } + + [Test] + public void DeletePost_ReturnsUnauthorizedResult_WhenUserIsNotAuthorized() + { + this.PostServiceMock.Setup(p => p.ValidateJwtForPost(It.IsAny<Guid>(), It.IsAny<string>())).Returns(Task.FromResult(false)); + + IActionResult result = this.PostController.Delete(Guid.Empty, null).Result; + + Assert.IsInstanceOf<UnauthorizedResult>(result); + } + #endregion + } +} diff --git a/src/DevHive.Tests/DevHive.Web.Tests/RoleController.Tests.cs b/src/DevHive.Tests/DevHive.Web.Tests/RoleController.Tests.cs new file mode 100644 index 0000000..067b4e4 --- /dev/null +++ b/src/DevHive.Tests/DevHive.Web.Tests/RoleController.Tests.cs @@ -0,0 +1,201 @@ +using System; +using System.Linq; +using System.Threading.Tasks; +using AutoMapper; +using DevHive.Services.Interfaces; +using DevHive.Services.Models.Identity.Role; +using DevHive.Web.Controllers; +using DevHive.Web.Models.Identity.Role; +using Microsoft.AspNetCore.Mvc; +using Moq; +using NUnit.Framework; + +namespace DevHive.Web.Tests +{ + [TestFixture] + public class RoleControllerTests + { + const string NAME = "Gosho Trapov"; + private Mock<IRoleService> RoleServiceMock { get; set; } + private Mock<IMapper> MapperMock { get; set; } + private RoleController RoleController { get; set; } + + [SetUp] + public void SetUp() + { + this.RoleServiceMock = new Mock<IRoleService>(); + this.MapperMock = new Mock<IMapper>(); + this.RoleController = new RoleController(this.RoleServiceMock.Object, this.MapperMock.Object); + } + + #region Create + [Test] + public void CreateRole_ReturnsOkObjectResult_WhenRoleIsSuccessfullyCreated() + { + CreateRoleWebModel createRoleWebModel = new CreateRoleWebModel + { + Name = NAME + }; + CreateRoleServiceModel createRoleServiceModel = new CreateRoleServiceModel + { + Name = NAME + }; + Guid id = Guid.NewGuid(); + + this.MapperMock.Setup(p => p.Map<CreateRoleServiceModel>(It.IsAny<CreateRoleWebModel>())).Returns(createRoleServiceModel); + this.RoleServiceMock.Setup(p => p.CreateRole(It.IsAny<CreateRoleServiceModel>())).Returns(Task.FromResult(id)); + + IActionResult result = this.RoleController.Create(createRoleWebModel).Result; + + Assert.IsInstanceOf<OkObjectResult>(result); + + var splitted = (result as OkObjectResult).Value + .ToString() + .Split('{', '}', '=', ' ') + .Where(x => !string.IsNullOrEmpty(x)) + .ToArray(); + + Guid resultId = Guid.Parse(splitted[1]); + + Assert.AreEqual(id, resultId); + } + + [Test] + public void CreateRole_ReturnsBadRequestObjectResult_WhenRoleIsNotCreatedSuccessfully() + { + CreateRoleWebModel createTechnologyWebModel = new CreateRoleWebModel + { + Name = NAME + }; + CreateRoleServiceModel createTechnologyServiceModel = new CreateRoleServiceModel + { + Name = NAME + }; + Guid id = Guid.Empty; + string errorMessage = $"Could not create role {NAME}"; + + this.MapperMock.Setup(p => p.Map<CreateRoleServiceModel>(It.IsAny<CreateRoleWebModel>())).Returns(createTechnologyServiceModel); + this.RoleServiceMock.Setup(p => p.CreateRole(It.IsAny<CreateRoleServiceModel>())).Returns(Task.FromResult(id)); + + IActionResult result = this.RoleController.Create(createTechnologyWebModel).Result; + + Assert.IsInstanceOf<BadRequestObjectResult>(result); + + BadRequestObjectResult badRequsetObjectResult = result as BadRequestObjectResult; + string resultMessage = badRequsetObjectResult.Value.ToString(); + + Assert.AreEqual(errorMessage, resultMessage); + } + #endregion + + #region Read + [Test] + public void GetById_ReturnsTheRole_WhenItExists() + { + Guid id = Guid.NewGuid(); + + RoleServiceModel roleServiceModel = new RoleServiceModel + { + Name = NAME + }; + RoleWebModel roleWebModel = new RoleWebModel + { + Name = NAME + }; + + this.RoleServiceMock.Setup(p => p.GetRoleById(It.IsAny<Guid>())).Returns(Task.FromResult(roleServiceModel)); + this.MapperMock.Setup(p => p.Map<RoleWebModel>(It.IsAny<RoleServiceModel>())).Returns(roleWebModel); + + IActionResult result = this.RoleController.GetById(id).Result; + + Assert.IsInstanceOf<OkObjectResult>(result); + + OkObjectResult okObjectResult = result as OkObjectResult; + RoleWebModel resultModel = okObjectResult.Value as Models.Identity.Role.RoleWebModel; + + Assert.AreEqual(NAME, resultModel.Name); + } + #endregion + + #region Update + [Test] + public void Update_ShouldReturnOkResult_WhenRoleIsUpdatedSuccessfully() + { + Guid id = Guid.NewGuid(); + UpdateRoleWebModel updateRoleWebModel = new UpdateRoleWebModel + { + Name = NAME + }; + UpdateRoleServiceModel updateRoleServiceModel = new UpdateRoleServiceModel + { + Name = NAME + }; + + this.RoleServiceMock.Setup(p => p.UpdateRole(It.IsAny<UpdateRoleServiceModel>())).Returns(Task.FromResult(true)); + this.MapperMock.Setup(p => p.Map<UpdateRoleServiceModel>(It.IsAny<UpdateRoleWebModel>())).Returns(updateRoleServiceModel); + + IActionResult result = this.RoleController.Update(id, updateRoleWebModel).Result; + + Assert.IsInstanceOf<OkResult>(result); + } + + [Test] + public void Update_ShouldReturnBadObjectResult_WhenRoleIsNotUpdatedSuccessfully() + { + Guid id = Guid.NewGuid(); + string message = "Could not update role!"; + UpdateRoleWebModel updateRoleWebModel = new UpdateRoleWebModel + { + Name = NAME + }; + UpdateRoleServiceModel updateRoleServiceModel = new UpdateRoleServiceModel + { + Name = NAME + }; + + this.RoleServiceMock.Setup(p => p.UpdateRole(It.IsAny<UpdateRoleServiceModel>())).Returns(Task.FromResult(false)); + this.MapperMock.Setup(p => p.Map<UpdateRoleServiceModel>(It.IsAny<UpdateRoleWebModel>())).Returns(updateRoleServiceModel); + + IActionResult result = this.RoleController.Update(id, updateRoleWebModel).Result; + Assert.IsInstanceOf<BadRequestObjectResult>(result); + + BadRequestObjectResult badRequestObjectResult = result as BadRequestObjectResult; + string resultModel = badRequestObjectResult.Value.ToString(); + + Assert.AreEqual(message, resultModel); + } + #endregion + + #region Delete + [Test] + public void Delete_ReturnsOkResult_WhenRoleIsDeletedSuccessfully() + { + Guid id = Guid.NewGuid(); + + this.RoleServiceMock.Setup(p => p.DeleteRole(It.IsAny<Guid>())).Returns(Task.FromResult(true)); + + IActionResult result = this.RoleController.Delete(id).Result; + + Assert.IsInstanceOf<OkResult>(result); + } + + [Test] + public void Delet_ReturnsBadRequestObjectResult_WhenRoleIsNotDeletedSuccessfully() + { + string message = "Could not delete role!"; + Guid id = Guid.NewGuid(); + + this.RoleServiceMock.Setup(p => p.DeleteRole(It.IsAny<Guid>())).Returns(Task.FromResult(false)); + + IActionResult result = this.RoleController.Delete(id).Result; + + Assert.IsInstanceOf<BadRequestObjectResult>(result); + + BadRequestObjectResult badRequestObjectResult = result as BadRequestObjectResult; + string resultModel = badRequestObjectResult.Value.ToString(); + + Assert.AreEqual(message, resultModel); + } + #endregion + } +} diff --git a/src/DevHive.Tests/DevHive.Web.Tests/TechnologyController.Tests.cs b/src/DevHive.Tests/DevHive.Web.Tests/TechnologyController.Tests.cs new file mode 100644 index 0000000..164bcbf --- /dev/null +++ b/src/DevHive.Tests/DevHive.Web.Tests/TechnologyController.Tests.cs @@ -0,0 +1,204 @@ +using AutoMapper; +using DevHive.Common.Models.Misc; +using DevHive.Services.Interfaces; +using DevHive.Services.Models.Technology; +using DevHive.Web.Controllers; +using DevHive.Web.Models.Technology; +using Microsoft.AspNetCore.Mvc; +using Moq; +using NUnit.Framework; +using System; +using System.Linq; +using System.Threading.Tasks; + +namespace DevHive.Web.Tests +{ + [TestFixture] + public class TechnologyControllerTests + { + const string NAME = "Gosho Trapov"; + private Mock<ITechnologyService> TechnologyServiceMock { get; set; } + private Mock<IMapper> MapperMock { get; set; } + private TechnologyController TechnologyController { get; set; } + + #region SetUp + [SetUp] + public void SetUp() + { + this.TechnologyServiceMock = new Mock<ITechnologyService>(); + this.MapperMock = new Mock<IMapper>(); + this.TechnologyController = new TechnologyController(this.TechnologyServiceMock.Object, this.MapperMock.Object); + } + #endregion + + #region Create + [Test] + public void Create_ReturnsOkObjectResult_WhenTechnologyIsSuccessfullyCreated() + { + CreateTechnologyWebModel createTechnologyWebModel = new CreateTechnologyWebModel + { + Name = NAME + }; + CreateTechnologyServiceModel createTechnologyServiceModel = new CreateTechnologyServiceModel + { + Name = NAME + }; + Guid id = Guid.NewGuid(); + + this.MapperMock.Setup(p => p.Map<CreateTechnologyServiceModel>(It.IsAny<CreateTechnologyWebModel>())).Returns(createTechnologyServiceModel); + this.TechnologyServiceMock.Setup(p => p.CreateTechnology(It.IsAny<CreateTechnologyServiceModel>())).Returns(Task.FromResult(id)); + + IActionResult result = this.TechnologyController.Create(createTechnologyWebModel).Result; + + Assert.IsInstanceOf<OkObjectResult>(result); + + var splitted = (result as OkObjectResult).Value + .ToString() + .Split('{', '}', '=', ' ') + .Where(x => !string.IsNullOrEmpty(x)) + .ToArray(); + + Guid resultId = Guid.Parse(splitted[1]); + + Assert.AreEqual(id, resultId); + } + + [Test] + public void Create_ReturnsBadRequestObjectResult_WhenTechnologyIsNotCreatedSuccessfully() + { + CreateTechnologyWebModel createTechnologyWebModel = new CreateTechnologyWebModel + { + Name = NAME + }; + CreateTechnologyServiceModel createTechnologyServiceModel = new CreateTechnologyServiceModel + { + Name = NAME + }; + Guid id = Guid.Empty; + string errorMessage = $"Could not create technology {NAME}"; + + this.MapperMock.Setup(p => p.Map<CreateTechnologyServiceModel>(It.IsAny<CreateTechnologyWebModel>())).Returns(createTechnologyServiceModel); + this.TechnologyServiceMock.Setup(p => p.CreateTechnology(It.IsAny<CreateTechnologyServiceModel>())).Returns(Task.FromResult(id)); + + IActionResult result = this.TechnologyController.Create(createTechnologyWebModel).Result; + + Assert.IsInstanceOf<BadRequestObjectResult>(result); + + BadRequestObjectResult badRequsetObjectResult = result as BadRequestObjectResult; + string resultMessage = badRequsetObjectResult.Value.ToString(); + + Assert.AreEqual(errorMessage, resultMessage); + } + #endregion + + #region Read + [Test] + public void GetById_ReturnsTheThecnology_WhenItExists() + { + Guid id = Guid.NewGuid(); + + ReadTechnologyWebModel readTechnologyWebModel = new ReadTechnologyWebModel + { + Name = NAME + }; + ReadTechnologyServiceModel readTechnologyServiceModel = new ReadTechnologyServiceModel + { + Name = NAME + }; + + this.TechnologyServiceMock.Setup(p => p.GetTechnologyById(It.IsAny<Guid>())).Returns(Task.FromResult(readTechnologyServiceModel)); + this.MapperMock.Setup(p => p.Map<ReadTechnologyWebModel>(It.IsAny<ReadTechnologyServiceModel>())).Returns(readTechnologyWebModel); + + IActionResult result = this.TechnologyController.GetById(id).Result; + + Assert.IsInstanceOf<OkObjectResult>(result); + + OkObjectResult okObjectResult = result as OkObjectResult; + ReadTechnologyWebModel resultModel = okObjectResult.Value as Models.Technology.ReadTechnologyWebModel; + + Assert.AreEqual(NAME, resultModel.Name); + } + #endregion + + #region Update + [Test] + public void Update_ShouldReturnOkResult_WhenTechnologyIsUpdatedSuccessfully() + { + Guid id = Guid.NewGuid(); + UpdateTechnologyWebModel updateTechnologyWebModel = new UpdateTechnologyWebModel + { + Name = NAME + }; + UpdateTechnologyServiceModel updateTechnologyServiceModel = new UpdateTechnologyServiceModel + { + Name = NAME + }; + + this.TechnologyServiceMock.Setup(p => p.UpdateTechnology(It.IsAny<UpdateTechnologyServiceModel>())).Returns(Task.FromResult(true)); + this.MapperMock.Setup(p => p.Map<UpdateTechnologyServiceModel>(It.IsAny<UpdateTechnologyWebModel>())).Returns(updateTechnologyServiceModel); + + IActionResult result = this.TechnologyController.Update(id, updateTechnologyWebModel).Result; + + Assert.IsInstanceOf<OkResult>(result); + } + + [Test] + public void Update_ShouldReturnBadObjectResult_WhenTechnologyIsNotUpdatedSuccessfully() + { + Guid id = Guid.NewGuid(); + string message = "Could not update Technology"; + UpdateTechnologyWebModel updateTechnologyWebModel = new UpdateTechnologyWebModel + { + Name = NAME + }; + UpdateTechnologyServiceModel updateTechnologyServiceModel = new UpdateTechnologyServiceModel + { + Name = NAME + }; + + this.TechnologyServiceMock.Setup(p => p.UpdateTechnology(It.IsAny<UpdateTechnologyServiceModel>())).Returns(Task.FromResult(false)); + this.MapperMock.Setup(p => p.Map<UpdateTechnologyServiceModel>(It.IsAny<UpdateTechnologyWebModel>())).Returns(updateTechnologyServiceModel); + + IActionResult result = this.TechnologyController.Update(id, updateTechnologyWebModel).Result; + Assert.IsInstanceOf<BadRequestObjectResult>(result); + + BadRequestObjectResult badRequestObjectResult = result as BadRequestObjectResult; + string resultModel = badRequestObjectResult.Value.ToString(); + + Assert.AreEqual(message, resultModel); + } + #endregion + + #region Delete + [Test] + public void Delete_ReturnsOkResult_WhenTechnologyIsDeletedSuccessfully() + { + Guid id = Guid.NewGuid(); + + this.TechnologyServiceMock.Setup(p => p.DeleteTechnology(It.IsAny<Guid>())).Returns(Task.FromResult(true)); + + IActionResult result = this.TechnologyController.Delete(id).Result; + + Assert.IsInstanceOf<OkResult>(result); + } + + [Test] + public void Delet_ReturnsBadRequestObjectResult_WhenTechnologyIsNotDeletedSuccessfully() + { + string message = "Could not delete Technology"; + Guid id = Guid.NewGuid(); + + this.TechnologyServiceMock.Setup(p => p.DeleteTechnology(It.IsAny<Guid>())).Returns(Task.FromResult(false)); + + IActionResult result = this.TechnologyController.Delete(id).Result; + + Assert.IsInstanceOf<BadRequestObjectResult>(result); + + BadRequestObjectResult badRequestObjectResult = result as BadRequestObjectResult; + string resultModel = badRequestObjectResult.Value.ToString(); + + Assert.AreEqual(message, resultModel); + } + #endregion + } +} diff --git a/src/DevHive.Tests/DevHive.Web.Tests/UserController.Tests.cs b/src/DevHive.Tests/DevHive.Web.Tests/UserController.Tests.cs new file mode 100644 index 0000000..c1431c8 --- /dev/null +++ b/src/DevHive.Tests/DevHive.Web.Tests/UserController.Tests.cs @@ -0,0 +1,257 @@ +using System; +using System.Threading.Tasks; +using AutoMapper; +using DevHive.Common.Models.Identity; +using DevHive.Services.Interfaces; +using DevHive.Services.Models.Identity.User; +using DevHive.Web.Controllers; +using DevHive.Web.Models.Identity.User; +using Microsoft.AspNetCore.Mvc; +using Moq; +using NUnit.Framework; + +namespace DevHive.Web.Tests +{ + [TestFixture] + public class UserControllerTests + { + const string USERNAME = "Gosho Trapov"; + private Mock<IUserService> UserServiceMock { get; set; } + private Mock<IMapper> MapperMock { get; set; } + private UserController UserController { get; set; } + + [SetUp] + public void SetUp() + { + this.UserServiceMock = new Mock<IUserService>(); + this.MapperMock = new Mock<IMapper>(); + this.UserController = new UserController(this.UserServiceMock.Object, this.MapperMock.Object); + } + + #region Create + [Test] + public void LoginUser_ReturnsOkObjectResult_WhenUserIsSuccessfullyLoggedIn() + { + Guid id = Guid.NewGuid(); + LoginWebModel loginWebModel = new LoginWebModel + { + UserName = USERNAME + }; + LoginServiceModel loginServiceModel = new LoginServiceModel + { + UserName = USERNAME + }; + string token = "goshotrapov"; + TokenModel tokenModel = new TokenModel(token); + TokenWebModel tokenWebModel = new TokenWebModel(token); + + this.MapperMock.Setup(p => p.Map<LoginServiceModel>(It.IsAny<LoginWebModel>())).Returns(loginServiceModel); + this.MapperMock.Setup(p => p.Map<TokenWebModel>(It.IsAny<TokenModel>())).Returns(tokenWebModel); + this.UserServiceMock.Setup(p => p.LoginUser(It.IsAny<LoginServiceModel>())).Returns(Task.FromResult(tokenModel)); + + IActionResult result = this.UserController.Login(loginWebModel).Result; + + Assert.IsInstanceOf<OkObjectResult>(result); + + var resultToken = ((result as OkObjectResult).Value as TokenWebModel).Token; + + Assert.AreEqual(token, resultToken); + } + + [Test] + public void RegisterUser_ReturnsOkObjectResult_WhenUserIsSuccessfullyRegistered() + { + Guid id = Guid.NewGuid(); + RegisterWebModel registerWebModel = new RegisterWebModel + { + UserName = USERNAME + }; + RegisterServiceModel registerServiceModel = new RegisterServiceModel + { + UserName = USERNAME + }; + string token = "goshotrapov"; + TokenModel tokenModel = new TokenModel(token); + TokenWebModel tokenWebModel = new TokenWebModel(token); + + this.MapperMock.Setup(p => p.Map<RegisterServiceModel>(It.IsAny<RegisterWebModel>())).Returns(registerServiceModel); + this.MapperMock.Setup(p => p.Map<TokenWebModel>(It.IsAny<TokenModel>())).Returns(tokenWebModel); + this.UserServiceMock.Setup(p => p.RegisterUser(It.IsAny<RegisterServiceModel>())).Returns(Task.FromResult(tokenModel)); + + IActionResult result = this.UserController.Register(registerWebModel).Result; + + Assert.IsInstanceOf<CreatedResult>(result); + + CreatedResult createdResult = result as CreatedResult; + TokenWebModel resultModel = (createdResult.Value as TokenWebModel); + + Assert.AreEqual(token, resultModel.Token); + } + #endregion + + #region Read + [Test] + public void GetById_ReturnsTheUser_WhenItExists() + { + Guid id = Guid.NewGuid(); + + UserServiceModel userServiceModel = new UserServiceModel + { + UserName = USERNAME + }; + UserWebModel userWebModel = new UserWebModel + { + UserName = USERNAME + }; + + this.UserServiceMock.Setup(p => p.GetUserById(It.IsAny<Guid>())).Returns(Task.FromResult(userServiceModel)); + this.UserServiceMock.Setup(p => p.ValidJWT(It.IsAny<Guid>(), It.IsAny<string>())).Returns(Task.FromResult(true)); + this.MapperMock.Setup(p => p.Map<UserWebModel>(It.IsAny<UserServiceModel>())).Returns(userWebModel); + + IActionResult result = this.UserController.GetById(id, null).Result; + + Assert.IsInstanceOf<OkObjectResult>(result); + + OkObjectResult okObjectResult = result as OkObjectResult; + UserWebModel resultModel = okObjectResult.Value as Models.Identity.User.UserWebModel; + + Assert.AreEqual(USERNAME, resultModel.UserName); + } + + [Test] + public void GetById_ReturnsUnauthorizedResult_WhenUserIsNotAuthorized() + { + Guid id = Guid.NewGuid(); + UserWebModel userWebModel = new UserWebModel + { + UserName = USERNAME + }; + + this.UserServiceMock.Setup(p => p.ValidJWT(It.IsAny<Guid>(), It.IsAny<string>())).Returns(Task.FromResult(false)); + + IActionResult result = this.UserController.GetById(Guid.NewGuid(), null).Result; + + Assert.IsInstanceOf<UnauthorizedResult>(result); + } + + [Test] + public void GetUser_ReturnsTheUser_WhenItExists() + { + Guid id = Guid.NewGuid(); + UserWebModel userWebModel = new UserWebModel + { + UserName = USERNAME + }; + UserServiceModel userServiceModel = new UserServiceModel + { + UserName = USERNAME + }; + + this.UserServiceMock.Setup(p => p.GetUserByUsername(It.IsAny<string>())).Returns(Task.FromResult(userServiceModel)); + this.MapperMock.Setup(p => p.Map<UserWebModel>(It.IsAny<UserServiceModel>())).Returns(userWebModel); + + IActionResult result = this.UserController.GetUser(null).Result; + + Assert.IsInstanceOf<OkObjectResult>(result); + + OkObjectResult okObjectResult = result as OkObjectResult; + UserWebModel resultModel = okObjectResult.Value as Models.Identity.User.UserWebModel; + + Assert.AreEqual(USERNAME, resultModel.UserName); + } + #endregion + + #region Update + [Test] + public void Update_ShouldReturnOkResult_WhenUserIsUpdatedSuccessfully() + { + Guid id = Guid.NewGuid(); + UpdateUserWebModel updateUserWebModel = new UpdateUserWebModel + { + UserName = USERNAME + }; + UpdateUserServiceModel updateUserServiceModel = new UpdateUserServiceModel + { + UserName = USERNAME + }; + UserServiceModel userServiceModel = new UserServiceModel + { + UserName = USERNAME + }; + + this.UserServiceMock.Setup(p => p.UpdateUser(It.IsAny<UpdateUserServiceModel>())).Returns(Task.FromResult(userServiceModel)); + this.UserServiceMock.Setup(p => p.ValidJWT(It.IsAny<Guid>(), It.IsAny<string>())).Returns(Task.FromResult(true)); + this.MapperMock.Setup(p => p.Map<UpdateUserServiceModel>(It.IsAny<UpdateUserWebModel>())).Returns(updateUserServiceModel); + + IActionResult result = this.UserController.Update(id, updateUserWebModel, null).Result; + + Assert.IsInstanceOf<AcceptedResult>(result); + } + + [Test] + public void UpdateProfilePicture_ShouldReturnOkObjectResult_WhenProfilePictureIsUpdatedSuccessfully() + { + string profilePictureURL = "goshotrapov"; + UpdateProfilePictureWebModel updateProfilePictureWebModel = new UpdateProfilePictureWebModel(); + UpdateProfilePictureServiceModel updateProfilePictureServiceModel = new UpdateProfilePictureServiceModel(); + ProfilePictureServiceModel profilePictureServiceModel = new ProfilePictureServiceModel + { + ProfilePictureURL = profilePictureURL + }; + ProfilePictureWebModel profilePictureWebModel = new ProfilePictureWebModel + { + ProfilePictureURL = profilePictureURL + }; + + this.UserServiceMock.Setup(p => p.ValidJWT(It.IsAny<Guid>(), It.IsAny<string>())).Returns(Task.FromResult(true)); + this.MapperMock.Setup(p => p.Map<UpdateProfilePictureServiceModel>(It.IsAny<UpdateProfilePictureWebModel>())).Returns(updateProfilePictureServiceModel); + this.UserServiceMock.Setup(p => p.UpdateProfilePicture(It.IsAny<UpdateProfilePictureServiceModel>())).Returns(Task.FromResult(profilePictureServiceModel)); + this.MapperMock.Setup(p => p.Map<ProfilePictureWebModel>(It.IsAny<ProfilePictureServiceModel>())).Returns(profilePictureWebModel); + + + IActionResult result = this.UserController.UpdateProfilePicture(Guid.Empty, updateProfilePictureWebModel, null).Result; + + Assert.IsInstanceOf<AcceptedResult>(result); + + AcceptedResult acceptedResult = result as AcceptedResult; + ProfilePictureWebModel resultModel = acceptedResult.Value as Models.Identity.User.ProfilePictureWebModel; + + Assert.AreEqual(profilePictureURL, resultModel.ProfilePictureURL); + } + #endregion + + #region Delete + [Test] + public void Delete_ReturnsOkResult_WhenUserIsDeletedSuccessfully() + { + Guid id = Guid.NewGuid(); + + this.UserServiceMock.Setup(p => p.ValidJWT(It.IsAny<Guid>(), It.IsAny<string>())).Returns(Task.FromResult(true)); + this.UserServiceMock.Setup(p => p.DeleteUser(It.IsAny<Guid>())).Returns(Task.FromResult(true)); + + IActionResult result = this.UserController.Delete(id, null).Result; + + Assert.IsInstanceOf<OkResult>(result); + } + + [Test] + public void Delete_ReturnsBadRequestObjectResult_WhenUserIsNotDeletedSuccessfully() + { + string message = "Could not delete User"; + Guid id = Guid.NewGuid(); + + this.UserServiceMock.Setup(p => p.ValidJWT(It.IsAny<Guid>(), It.IsAny<string>())).Returns(Task.FromResult(true)); + this.UserServiceMock.Setup(p => p.DeleteUser(It.IsAny<Guid>())).Returns(Task.FromResult(false)); + + IActionResult result = this.UserController.Delete(id, null).Result; + + Assert.IsInstanceOf<BadRequestObjectResult>(result); + + BadRequestObjectResult badRequestObjectResult = result as BadRequestObjectResult; + string resultModel = badRequestObjectResult.Value.ToString(); + + Assert.AreEqual(message, resultModel); + } + #endregion + } +} |