diff options
Diffstat (limited to 'src/DevHive.Tests')
6 files changed, 450 insertions, 105 deletions
diff --git a/src/DevHive.Tests/DevHive.Data.Tests/LenguageRepository.Tests.cs b/src/DevHive.Tests/DevHive.Data.Tests/LenguageRepository.Tests.cs index aefeddd..f02a1e4 100644 --- a/src/DevHive.Tests/DevHive.Data.Tests/LenguageRepository.Tests.cs +++ b/src/DevHive.Tests/DevHive.Data.Tests/LenguageRepository.Tests.cs @@ -1,4 +1,9 @@ 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 @@ -6,6 +11,106 @@ namespace DevHive.Data.Tests [TestFixture] public class LenguageRepositoryTests { - // pending repo refactoring + 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/TechnologyRepository.Tests.cs b/src/DevHive.Tests/DevHive.Data.Tests/TechnologyRepository.Tests.cs index 289d846..5201af2 100644 --- a/src/DevHive.Tests/DevHive.Data.Tests/TechnologyRepository.Tests.cs +++ b/src/DevHive.Tests/DevHive.Data.Tests/TechnologyRepository.Tests.cs @@ -17,6 +17,7 @@ namespace DevHive.Data.Tests protected TechnologyRepository TechnologyRepository { get; set; } + #region Setups [SetUp] public void Setup() { @@ -33,40 +34,27 @@ namespace DevHive.Data.Tests { this.Context.Database.EnsureDeleted(); } - - #region AddAsync - [Test] - public async Task AddAsync_AddsTheGivenTechnologyToTheDatabase() - { - await AddEntity(); - - int numberOfTechnologies = Context.Technologies.Count(); - - Assert.True(numberOfTechnologies > 0, "Technologies repo does not store Technologies correctly"); - } #endregion - #region GetByIdAsync + #region GetByNameAsync [Test] - public async Task GetByIdAsync_ReturnsTheCorrectTechnology_IfIdExists() + public async Task GetByNameAsync_ReturnsTheCorrectTechnology_IfItExists() { await AddEntity(); + Technology technology = this.Context.Technologies.Where(x => x.Name == TECHNOLOGY_NAME).ToList().FirstOrDefault(); - Guid id = technology.Id; - Technology technologyReturned = await this.TechnologyRepository.GetByIdAsync(id); + Technology resultTechnology = await this.TechnologyRepository.GetByNameAsync(TECHNOLOGY_NAME); - Assert.AreEqual(TECHNOLOGY_NAME, technologyReturned.Name, "GetByIdAsync does not return the correct Technology when id is valid"); + Assert.AreEqual(technology.Id, resultTechnology.Id); } [Test] - public async Task GetByIdAsync_ReturnsNull_IfIdDoesNotExists() + public async Task GetByNameAsync_ReturnsNull_IfTechnologyDoesNotExists() { - Guid id = Guid.NewGuid(); - - Technology technologyReturned = await this.TechnologyRepository.GetByIdAsync(id); + Technology resultTechnology = await this.TechnologyRepository.GetByNameAsync(TECHNOLOGY_NAME); - Assert.IsNull(technologyReturned, "GetByIdAsync returns Technology when it should be null"); + Assert.IsNull(resultTechnology); } #endregion @@ -114,41 +102,6 @@ namespace DevHive.Data.Tests } #endregion - #region EditAsync - //TO DO fix: check UserRepo - [Test] - public async Task EditAsync_UpdatesEntity() - { - string newName = "New name"; - Technology technology = new Technology - { - Name = TECHNOLOGY_NAME - }; Technology newTechnology = new Technology - { - Name = newName - }; - - await this.TechnologyRepository.AddAsync(technology); - - bool result = await this.TechnologyRepository.EditAsync(newTechnology); - - Assert.IsTrue(result); - } - #endregion - - #region DeleteAsync - [Test] - public async Task DeleteAsync_ReturnsTrue_IfDeletionIsSuccesfull() - { - await AddEntity(); - Technology technology = this.Context.Technologies.Where(x => x.Name == TECHNOLOGY_NAME).ToList().FirstOrDefault(); - - bool result = await this.TechnologyRepository.DeleteAsync(technology); - - Assert.IsTrue(result, "DeleteAsync returns false when deletion is successfull"); - } - #endregion - #region HelperMethods private async Task AddEntity(string name = TECHNOLOGY_NAME) { diff --git a/src/DevHive.Tests/DevHive.Data.Tests/UserRepositoryTests.cs b/src/DevHive.Tests/DevHive.Data.Tests/UserRepositoryTests.cs index d4daae5..832cccd 100644 --- a/src/DevHive.Tests/DevHive.Data.Tests/UserRepositoryTests.cs +++ b/src/DevHive.Tests/DevHive.Data.Tests/UserRepositoryTests.cs @@ -14,21 +14,16 @@ namespace DevHive.Data.Tests { private DevHiveContext _context; private UserRepository _userRepository; - private LanguageRepository _languageRepository; - private TechnologyRepository _technologyRepository; #region Setups [SetUp] public void Setup() { - //Naming convention: MethodName_ExpectedBehavior_StateUnderTest var options = new DbContextOptionsBuilder<DevHiveContext>() .UseInMemoryDatabase("DevHive_UserRepository_Database"); this._context = new DevHiveContext(options.Options); this._userRepository = new UserRepository(_context); - this._languageRepository = new LanguageRepository(_context); - this._technologyRepository = new TechnologyRepository(_context); } [TearDown] @@ -38,101 +33,341 @@ namespace DevHive.Data.Tests } #endregion - #region Create + #region QueryAll [Test] - public async Task AddAsync_ShouldAddUserToDatabase() + public async Task QueryAll_ShouldReturnAllUsersFromDatabase_WhenTheyExist() { //Arrange - User dummyUser = CreateDummyUser(); + User dummyUserOne = CreateDummyUser(); + User dummyUserTwo = CreateAnotherDummyUser(); + + await this._userRepository.AddAsync(dummyUserOne); + await this._userRepository.AddAsync(dummyUserTwo); //Act - bool result = await _userRepository.AddAsync(dummyUser); + IEnumerable<User> users = this._userRepository.QueryAll(); //Assert - Assert.True(result, "User int' inserted properly into the database"); + 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 Read + #region GetByIdAsync [Test] - public async Task QueryAll_ShouldReturnAllUsersFromDatabase() + public async Task GetByIdAsync_ReturnsTheUse_WhenItExists() { - //Arrange User dummyUserOne = CreateDummyUser(); - User dummyUserTwo = CreateAnotherDummyUser(); - await this._userRepository.AddAsync(dummyUserOne); - await this._userRepository.AddAsync(dummyUserTwo); - //Act - IEnumerable<User> users = this._userRepository.QueryAll(); - foreach (var item in users) - System.Console.WriteLine(item); + User resultUser = await this._userRepository.GetByIdAsync(dummyUserOne.Id); - //Assert - Assert.GreaterOrEqual(users.Count(), 1, "Method doesn't return all instances of user"); + 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 GetById_ShouldReturnUserFromDatabase() + public async Task GetByUsernameAsync_ReturnsUserFromDatabase_WhenItExists() { //Arrange User dummyUser = CreateDummyUser(); await this._userRepository.AddAsync(dummyUser); - Guid id = dummyUser.Id; + string username = dummyUser.UserName; //Act - User user = await this._userRepository.GetByIdAsync(id); + User user = await this._userRepository.GetByUsernameAsync(username); //Assert - Assert.AreEqual(dummyUser, user, "Method doesn't get the proper user from database"); + Assert.AreEqual(dummyUser.Id, user.Id, "Method doesn't get the proper user from database"); } [Test] - public async Task GetByUsernameAsync_ShouldReturnUserFromDatabase() + 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 GetUserLanguages + [Test] + public async Task GetUserLanguages_ReturnsAllSavedUserLanguages_WhenTheyExist() { //Arrange User dummyUser = CreateDummyUser(); await this._userRepository.AddAsync(dummyUser); - string username = dummyUser.UserName; + HashSet<Language> dummyUserLanguages = dummyUser.Languages; //Act - User user = await this._userRepository.GetByUsernameAsync(username); + HashSet<Language> languages = this._userRepository.GetUserLanguages(dummyUser); //Assert - Assert.AreEqual(dummyUser, user, "Method doesn't get the proper user from database"); + Assert.AreEqual(dummyUserLanguages, languages, "Method doesn't query languages properly"); } [Test] - public async Task GetUserLanguages_ShouldReturnAllSavedUserLanguages() + public async Task GetUserLanguages_EmptyList_WhenNoLanguagesExist() { //Arrange User dummyUser = CreateDummyUser(); + dummyUser.Languages.RemoveWhere(x => x.Name == "csharp"); await this._userRepository.AddAsync(dummyUser); - HashSet<Language> dummyUserLanguages = dummyUser.Languages; //Act HashSet<Language> languages = this._userRepository.GetUserLanguages(dummyUser); //Assert - Assert.AreEqual(dummyUserLanguages, languages, "Method doesn't query languages properly"); + Assert.IsEmpty(languages, "Method doesn't query languages properly"); + } + #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>(); + friends.Add(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 DoesUserHaveFriends + [Test] + public async Task DoesUserHaveFriends_ReturnsTrue_WhenUserHasFriends() + { + User dummyUser = this.CreateDummyUser(); + User anotherDummyUser = this.CreateAnotherDummyUser(); + HashSet<User> friends = new HashSet<User>(); + friends.Add(anotherDummyUser); + dummyUser.Friends = friends; + + this._context.Users.Add(dummyUser); + this._context.Users.Add(anotherDummyUser); + await this._context.SaveChangesAsync(); + + bool result = this._userRepository.DoesUserHaveFriends(dummyUser); + + Assert.IsTrue(result, "DoesUserHaveFriends does not return true when user has friends"); + } + + [Test] + public async Task DoesUserHaveFriends_ReturnsFalse_WhenUserDoesNotHaveTheGivenFriend() + { + User dummyUser = this.CreateDummyUser(); + + this._context.Users.Add(dummyUser); + await this._context.SaveChangesAsync(); + + bool result = this._userRepository.DoesUserHaveFriends(dummyUser); + + Assert.IsFalse(result, "DoesUserHaveFriends does not return false when user des not have friends"); + } + #endregion + + #region DoesUserHaveThisLanguage + [Test] + public async Task DoesUserHaveThisLanguage_ReturnsTrue_WhenUserHasTheGivenLanguage() + { + User dummyUser = this.CreateDummyUser(); + + this._context.Users.Add(dummyUser); + await this._context.SaveChangesAsync(); + + Language language = dummyUser.Languages.FirstOrDefault(); + + bool result = this._userRepository.DoesUserHaveThisLanguage(dummyUser, language); + + Assert.IsTrue(result, "DoesUserHaveThisLanguage does not return true when user has the given language"); + } + + [Test] + public async Task DoesUserHaveThisLanguage_ReturnsFalse_WhenUserDoesNotHaveTheGivenLanguage() + { + User dummyUser = this.CreateDummyUser(); + this._context.Users.Add(dummyUser); + await this._context.SaveChangesAsync(); + + Language language = new Language(); + + bool result = this._userRepository.DoesUserHaveThisLanguage(dummyUser, language); + + Assert.IsFalse(result, "DoesUserHaveThisLanguage does not return false when user does not have the given language"); } + #endregion + #region DoesUserHaveThisTechnology [Test] - [TestCase] - public async Task GetUserLanguage_ShouldReturnAllSavedUserLanguages() + public async Task DoesUserHaveThisTechnology_ReturnsTrue_WhenUserHasTheGivenTechnology() { - Assert.Pass(); - // //Arrange - // User dummyUser = CreateDummyUser(); - // await this._userRepository.AddAsync(dummyUser); - // Language dummyLang = await this._languageRepository.GetByNameAsync("csharp"); + User dummyUser = this.CreateDummyUser(); + + this._context.Users.Add(dummyUser); + await this._context.SaveChangesAsync(); + + Technology technology = dummyUser.Technologies.FirstOrDefault(); + + bool result = this._userRepository.DoesUserHaveThisTechnology(dummyUser, technology); + + Assert.IsTrue(result, "DoesUserHaveThisLanguage does not return true when user has the given technology"); + } + + [Test] + public async Task DoesUserHaveThisTechnology_ReturnsFalse_WhenUserDoesNotHaveTheGivenTechnology() + { + User dummyUser = this.CreateDummyUser(); + this._context.Users.Add(dummyUser); + await this._context.SaveChangesAsync(); + + Technology technology = new Technology(); - // //Act - // HashSet<Language> languages = this._userRepository.GetUserLanguage(dummyUser, dummyLang); + bool result = this._userRepository.DoesUserHaveThisTechnology(dummyUser, technology); - // //Assert - // Assert.AreEqual(dummyUserLanguages, languages, "Method doesn't query languages properly"); + Assert.IsFalse(result, "DoesUserHaveThisLanguage does not return false when user does not have the given technology"); } #endregion diff --git a/src/DevHive.Tests/DevHive.Services.Tests/LanguageService.Tests.cs b/src/DevHive.Tests/DevHive.Services.Tests/LanguageService.Tests.cs index fd4a828..392dc88 100644 --- a/src/DevHive.Tests/DevHive.Services.Tests/LanguageService.Tests.cs +++ b/src/DevHive.Tests/DevHive.Services.Tests/LanguageService.Tests.cs @@ -141,9 +141,11 @@ namespace DevHive.Services.Tests public async Task UpdateLanguage_ReturnsIfUpdateIsSuccessfull_WhenLanguageExistsy(bool shouldPass) { string name = "Gosho Trapov"; + Guid id = Guid.NewGuid(); Language language = new Language { - Name = name + Name = name, + Id = id }; UpdateLanguageServiceModel updateLanguageServiceModel = new UpdateLanguageServiceModel { @@ -152,7 +154,7 @@ namespace DevHive.Services.Tests 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<Language>())).Returns(Task.FromResult(shouldPass)); + 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); diff --git a/src/DevHive.Tests/DevHive.Services.Tests/PostService.Tests.cs b/src/DevHive.Tests/DevHive.Services.Tests/PostService.Tests.cs index bf6817b..9864c5b 100644 --- a/src/DevHive.Tests/DevHive.Services.Tests/PostService.Tests.cs +++ b/src/DevHive.Tests/DevHive.Services.Tests/PostService.Tests.cs @@ -4,6 +4,7 @@ using AutoMapper; using DevHive.Data.Interfaces.Repositories; using DevHive.Data.Models; using DevHive.Services.Models.Post.Comment; +using DevHive.Services.Models.Post.Post; using DevHive.Services.Services; using Moq; using NUnit.Framework; @@ -185,5 +186,52 @@ namespace DevHive.Services.Tests //TO DO: Implement #endregion #endregion + + #region Posts + #region Create + [Test] + public async Task CreatePost_ReturnsIdOfThePost_WhenItIsSuccessfullyCreated() + { + Guid id = Guid.NewGuid(); + CreatePostServiceModel createPostServiceModel = new CreatePostServiceModel + { + }; + Post post = new Post + { + Message = MESSAGE, + Id = id + }; + + this.PostRepositoryMock.Setup(p => p.AddAsync(It.IsAny<Post>())).Returns(Task.FromResult(true)); + this.PostRepositoryMock.Setup(p => p.GetPostByIssuerAndTimeCreatedAsync(It.IsAny<Guid>(), It.IsAny<DateTime>())).Returns(Task.FromResult(post)); + this.MapperMock.Setup(p => p.Map<Post>(It.IsAny<CreatePostServiceModel>())).Returns(post); + + Guid result = await this.PostService.CreatePost(createPostServiceModel); + + Assert.AreEqual(id, result, "CreatePost does not return the correct id"); + } + + [Test] + public async Task CreatePost_ReturnsEmptyGuid_WhenItIsNotSuccessfullyCreated() + { + CreatePostServiceModel createPostServiceModel = new CreatePostServiceModel + { + }; + Post post = new Post + { + Message = MESSAGE, + }; + + this.PostRepositoryMock.Setup(p => p.AddAsync(It.IsAny<Post>())).Returns(Task.FromResult(false)); + 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"); + } + #endregion + + + #endregion } } diff --git a/src/DevHive.Tests/DevHive.Services.Tests/TechnologyServices.Tests.cs b/src/DevHive.Tests/DevHive.Services.Tests/TechnologyServices.Tests.cs index abd43ed..51f63ba 100644 --- a/src/DevHive.Tests/DevHive.Services.Tests/TechnologyServices.Tests.cs +++ b/src/DevHive.Tests/DevHive.Services.Tests/TechnologyServices.Tests.cs @@ -140,9 +140,11 @@ namespace DevHive.Services.Tests public async Task UpdateTechnology_ReturnsIfUpdateIsSuccessfull_WhenTechnologyExistsy(bool shouldPass) { string name = "Gosho Trapov"; + Guid id = Guid.NewGuid(); Technology technology = new Technology { - Name = name + Name = name, + Id = id }; UpdateTechnologyServiceModel updatetechnologyServiceModel = new UpdateTechnologyServiceModel { @@ -151,7 +153,7 @@ namespace DevHive.Services.Tests 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<Technology>())).Returns(Task.FromResult(shouldPass)); + 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); |