From 1001c3d5c6f979c56daf98e7ed82cee2ff09ab7f Mon Sep 17 00:00:00 2001 From: Danail Dimitrov Date: Thu, 21 Jan 2021 17:28:42 +0200 Subject: Fixed TechnologyService.Tests after refactoring of TechnologyService --- .../DevHive.Data.Tests/LenguageRepository.Tests.cs | 10 ++++++++++ 1 file changed, 10 insertions(+) create mode 100644 src/DevHive.Tests/DevHive.Data.Tests/LenguageRepository.Tests.cs (limited to 'src/DevHive.Tests/DevHive.Data.Tests/LenguageRepository.Tests.cs') 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..0a99bf1 --- /dev/null +++ b/src/DevHive.Tests/DevHive.Data.Tests/LenguageRepository.Tests.cs @@ -0,0 +1,10 @@ +using System; +using NUnit.Framework; + +namespace DevHive.Data.Tests +{ + [TestFixture] + public class LenguageRepositoryTests + { + } +} -- cgit v1.2.3 From 5e5e2eb2edef88840edbb072597f81f8da3ae929 Mon Sep 17 00:00:00 2001 From: Danail Dimitrov Date: Thu, 21 Jan 2021 20:51:11 +0200 Subject: Made all Technology Layer Tests not asymc again --- .../Repositories/LanguageRepository.cs | 10 +- .../DevHive.Data.Tests/LenguageRepository.Tests.cs | 1 + .../TechnologyRepository.Tests.cs | 134 +++++++++------- .../LanguageService.Tests.cs | 100 ++++++++++++ .../TechnologyServices.Tests.cs | 176 ++++++++++++--------- 5 files changed, 286 insertions(+), 135 deletions(-) create mode 100644 src/DevHive.Tests/DevHive.Services.Tests/LanguageService.Tests.cs (limited to 'src/DevHive.Tests/DevHive.Data.Tests/LenguageRepository.Tests.cs') diff --git a/src/DevHive.Data/Repositories/LanguageRepository.cs b/src/DevHive.Data/Repositories/LanguageRepository.cs index 4c51cf3..808fa9a 100644 --- a/src/DevHive.Data/Repositories/LanguageRepository.cs +++ b/src/DevHive.Data/Repositories/LanguageRepository.cs @@ -45,11 +45,13 @@ namespace DevHive.Data.Repositories #region Update - public async Task EditAsync(Language newEntity) + public async Task EditAsync(Language entity) { - this._context - .Set() - .Update(newEntity); + Language language = await this._context.Languages + .FirstOrDefaultAsync(x => x.Id == entity.Id); + + this._context.Update(language); + this._context.Entry(entity).CurrentValues.SetValues(entity); return await this.SaveChangesAsync(this._context); } diff --git a/src/DevHive.Tests/DevHive.Data.Tests/LenguageRepository.Tests.cs b/src/DevHive.Tests/DevHive.Data.Tests/LenguageRepository.Tests.cs index 0a99bf1..aefeddd 100644 --- a/src/DevHive.Tests/DevHive.Data.Tests/LenguageRepository.Tests.cs +++ b/src/DevHive.Tests/DevHive.Data.Tests/LenguageRepository.Tests.cs @@ -6,5 +6,6 @@ namespace DevHive.Data.Tests [TestFixture] public class LenguageRepositoryTests { + // pending repo refactoring } } diff --git a/src/DevHive.Tests/DevHive.Data.Tests/TechnologyRepository.Tests.cs b/src/DevHive.Tests/DevHive.Data.Tests/TechnologyRepository.Tests.cs index 9c95c6d..c0aaa93 100644 --- a/src/DevHive.Tests/DevHive.Data.Tests/TechnologyRepository.Tests.cs +++ b/src/DevHive.Tests/DevHive.Data.Tests/TechnologyRepository.Tests.cs @@ -4,6 +4,7 @@ using Microsoft.EntityFrameworkCore; using NUnit.Framework; using System; using System.Linq; +using System.Threading.Tasks; namespace DevHive.Data.Tests { @@ -46,124 +47,151 @@ namespace DevHive.Data.Tests #endregion #region GetByIdAsync - [Test] - public async void GetByIdAsync_ReturnsTheCorrectTechnology_IfIdExists() + public void GetByIdAsync_ReturnsTheCorrectTechnology_IfIdExists() { - AddEntity(); - Technology technology = this.Context.Technologies.Where(x => x.Name == TECHNOLOGY_NAME).ToList().FirstOrDefault(); - Guid id = technology.Id; + Task.Run(async () => + { + 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 technologyReturned = await this.TechnologyRepository.GetByIdAsync(id); - Assert.AreEqual(TECHNOLOGY_NAME, technologyReturned.Name, "GetByIdAsync does not return the correct Technology when id is valid"); + Assert.AreEqual(TECHNOLOGY_NAME, technologyReturned.Name, "GetByIdAsync does not return the correct Technology when id is valid"); + }).GetAwaiter().GetResult(); } [Test] - public async void GetByIdAsync_ReturnsNull_IfIdDoesNotExists() + public void GetByIdAsync_ReturnsNull_IfIdDoesNotExists() { + Task.Run(async () => + { + Guid id = Guid.NewGuid(); - Guid id = Guid.NewGuid(); - - Technology technologyReturned = await this.TechnologyRepository.GetByIdAsync(id); + Technology technologyReturned = await this.TechnologyRepository.GetByIdAsync(id); - Assert.IsNull(technologyReturned, "GetByIdAsync returns Technology when it should be null"); + Assert.IsNull(technologyReturned, "GetByIdAsync returns Technology when it should be null"); + }).GetAwaiter().GetResult(); } #endregion #region DoesTechnologyExistAsync [Test] - public async void DoesTechnologyExist_ReturnsTrue_IfIdExists() + public void DoesTechnologyExist_ReturnsTrue_IfIdExists() { - AddEntity(); - Technology technology = this.Context.Technologies.Where(x => x.Name == TECHNOLOGY_NAME).ToList().FirstOrDefault(); - Guid id = technology.Id; + Task.Run(async () => + { + 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); + bool result = await this.TechnologyRepository.DoesTechnologyExistAsync(id); - Assert.IsTrue(result, "DoesTechnologyExistAsync returns flase hwen technology exists"); + Assert.IsTrue(result, "DoesTechnologyExistAsync returns flase hwen technology exists"); + }).GetAwaiter().GetResult(); } [Test] - public async void DoesTechnologyExist_ReturnsFalse_IfIdDoesNotExists() + public void DoesTechnologyExist_ReturnsFalse_IfIdDoesNotExists() { - Guid id = Guid.NewGuid(); + Task.Run(async () => + { + Guid id = Guid.NewGuid(); - bool result = await this.TechnologyRepository.DoesTechnologyExistAsync(id); + bool result = await this.TechnologyRepository.DoesTechnologyExistAsync(id); - Assert.IsFalse(result, "DoesTechnologyExistAsync returns true when technology does not exist"); + Assert.IsFalse(result, "DoesTechnologyExistAsync returns true when technology does not exist"); + }).GetAwaiter().GetResult(); } #endregion #region DoesTechnologyNameExistAsync [Test] - public async void DoesTechnologyNameExist_ReturnsTrue_IfTechnologyExists() + public void DoesTechnologyNameExist_ReturnsTrue_IfTechnologyExists() { - AddEntity(); + Task.Run(async () => + { + AddEntity(); - bool result = await this.TechnologyRepository.DoesTechnologyNameExistAsync(TECHNOLOGY_NAME); + bool result = await this.TechnologyRepository.DoesTechnologyNameExistAsync(TECHNOLOGY_NAME); - Assert.IsTrue(result, "DoesTechnologyNameExists returns true when technology name does not exist"); + Assert.IsTrue(result, "DoesTechnologyNameExists returns true when technology name does not exist"); + }).GetAwaiter().GetResult(); } [Test] - public async void DoesTechnologyNameExist_ReturnsFalse_IfTechnologyDoesNotExists() + public void DoesTechnologyNameExist_ReturnsFalse_IfTechnologyDoesNotExists() { - bool result = await this.TechnologyRepository.DoesTechnologyNameExistAsync(TECHNOLOGY_NAME); + Task.Run(async () => + { + bool result = await this.TechnologyRepository.DoesTechnologyNameExistAsync(TECHNOLOGY_NAME); - Assert.False(result, "DoesTechnologyNameExistAsync returns true when technology name does not exist"); + Assert.False(result, "DoesTechnologyNameExistAsync returns true when technology name does not exist"); + }).GetAwaiter().GetResult(); } #endregion #region EditAsync //TO DO fix: check UserRepo [Test] - public async void EditAsync_UpdatesEntity() + public void EditAsync_UpdatesEntity() { - string newName = "New name"; - Guid id = Guid.NewGuid(); - Technology technology = new Technology - { - Name = TECHNOLOGY_NAME, - Id = id - }; Technology newTechnology = new Technology + Task.Run(async () => { - Name = newName, - Id = id - }; + string newName = "New name"; + Technology technology = new Technology + { + Name = TECHNOLOGY_NAME + }; Technology newTechnology = new Technology + { + Name = newName + }; - await this.TechnologyRepository.AddAsync(technology); + await this.TechnologyRepository.AddAsync(technology); - bool result = await this.TechnologyRepository.EditAsync(newTechnology); + bool result = await this.TechnologyRepository.EditAsync(newTechnology); - Assert.IsTrue(result); + Assert.IsTrue(result); + }).GetAwaiter().GetResult(); } #endregion #region DeleteAsync [Test] - public async void DeleteAsync_ReturnsTrue_IfDeletionIsSuccesfull() + public void DeleteAsync_ReturnsTrue_IfDeletionIsSuccesfull() { - AddEntity(); - Technology technology = this.Context.Technologies.Where(x => x.Name == TECHNOLOGY_NAME).ToList().FirstOrDefault(); + Task.Run(async () => + { + AddEntity(); + Technology technology = this.Context.Technologies.Where(x => x.Name == TECHNOLOGY_NAME).ToList().FirstOrDefault(); - bool result = await this.TechnologyRepository.DeleteAsync(technology); + bool result = await this.TechnologyRepository.DeleteAsync(technology); - Assert.IsTrue(result, "DeleteAsync returns false when deletion is successfull"); + Assert.IsTrue(result, "DeleteAsync returns false when deletion is successfull"); + }).GetAwaiter().GetResult(); } #endregion #region HelperMethods - private async void AddEntity(string name = TECHNOLOGY_NAME) + private void AddEntity(string name = TECHNOLOGY_NAME) { - Technology technology = new Technology + Task.Run(async () => { - Name = name - }; + Technology technology = new Technology + { + Name = name + }; - await this.TechnologyRepository.AddAsync(technology); + await this.TechnologyRepository.AddAsync(technology); + }).GetAwaiter().GetResult(); } #endregion + + //Task.Run(async () => + //{ + + //}).GetAwaiter().GetResult(); } } 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..2ebff58 --- /dev/null +++ b/src/DevHive.Tests/DevHive.Services.Tests/LanguageService.Tests.cs @@ -0,0 +1,100 @@ +using System; +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 LanguageRepositoryMock { get; set; } + private Mock MapperMock { get; set; } + private LanguageService LanguageService { get; set; } + + [SetUp] + public void SetUp() + { + this.LanguageRepositoryMock = new Mock(); + this.MapperMock = new Mock(); + this.LanguageService = new LanguageService(this.LanguageRepositoryMock.Object, this.MapperMock.Object); + } + + #region Create + [Test] + public async void Create_ReturnsNonEmptyGuid_WhenEntityIsAddedSuccessfully() + { + string technologyName = "Gosho Trapov"; + Guid id = Guid.NewGuid(); + CreateLanguageServiceModel createLanguageServiceModel = new() + { + Name = technologyName + }; + Language language = new() + { + Name = technologyName, + Id = id + }; + + this.LanguageRepositoryMock.Setup(p => p.DoesLanguageNameExistAsync(It.IsAny())).Returns(Task.FromResult(false)); + this.LanguageRepositoryMock.Setup(p => p.AddAsync(It.IsAny())).Returns(Task.FromResult(true)); + this.LanguageRepositoryMock.Setup(p => p.GetByNameAsync(It.IsAny())).Returns(Task.FromResult(language)); + this.MapperMock.Setup(p => p.Map(It.IsAny())).Returns(language); + + Guid result = await this.LanguageService.CreateLanguage(createLanguageServiceModel); + + Assert.AreEqual(id, result); + } + + [Test] + public async void Create_ReturnsEmptyGuid_WhenEntityIsNotAddedSuccessfully() + { + string languageName = "Gosho Trapov"; + + CreateLanguageServiceModel createLanguageServiceModel = new() + { + Name = languageName + }; + Language language = new() + { + Name = languageName + }; + + this.LanguageRepositoryMock.Setup(p => p.DoesLanguageNameExistAsync(It.IsAny())).Returns(Task.FromResult(false)); + this.LanguageRepositoryMock.Setup(p => p.AddAsync(It.IsAny())).Returns(Task.FromResult(false)); + this.MapperMock.Setup(p => p.Map(It.IsAny())).Returns(language); + + Guid result = await this.LanguageService.CreateLanguage(createLanguageServiceModel); + + Assert.IsTrue(result == Guid.Empty); + } + + [Test] + public void Create_ThrowsArgumentException_WhenEntityAlreadyExists() + { + string exceptionMessage = "Technology already exists!"; + string languageName = "Gosho Trapov"; + + CreateLanguageServiceModel createLanguageServiceModel = new() + { + Name = languageName + }; + Language language = new() + { + Name = languageName + }; + + this.LanguageRepositoryMock.Setup(p => p.DoesLanguageNameExistAsync(It.IsAny())).Returns(Task.FromResult(true)); + + Exception ex = Assert.ThrowsAsync(() => this.LanguageService.CreateLanguage(createLanguageServiceModel)); + + 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 index 20aceb5..b04e213 100644 --- a/src/DevHive.Tests/DevHive.Services.Tests/TechnologyServices.Tests.cs +++ b/src/DevHive.Tests/DevHive.Services.Tests/TechnologyServices.Tests.cs @@ -27,51 +27,57 @@ namespace DevHive.Services.Tests #region Create [Test] - public async void Create_ReturnsNonEmptyGuid_WhenEntityIsAddedSuccessfully() + public void Create_ReturnsNonEmptyGuid_WhenEntityIsAddedSuccessfully() { - string technologyName = "Gosho Trapov"; - Guid id = Guid.NewGuid(); - CreateTechnologyServiceModel createTechnologyServiceModel = new() - { - Name = technologyName - }; - Technology technology = new() + Task.Run(async () => { - Name = technologyName, - Id = id - }; - - this.TechnologyRepositoryMock.Setup(p => p.DoesTechnologyNameExistAsync(It.IsAny())).Returns(Task.FromResult(false)); - this.TechnologyRepositoryMock.Setup(p => p.AddAsync(It.IsAny())).Returns(Task.FromResult(true)); - this.TechnologyRepositoryMock.Setup(p => p.GetByNameAsync(It.IsAny())).Returns(Task.FromResult(technology)); - this.MapperMock.Setup(p => p.Map(It.IsAny())).Returns(technology); - - Guid result = await this.TechnologyService.Create(createTechnologyServiceModel); - - Assert.AreEqual(id, result); + 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())).Returns(Task.FromResult(false)); + this.TechnologyRepositoryMock.Setup(p => p.AddAsync(It.IsAny())).Returns(Task.FromResult(true)); + this.TechnologyRepositoryMock.Setup(p => p.GetByNameAsync(It.IsAny())).Returns(Task.FromResult(technology)); + this.MapperMock.Setup(p => p.Map(It.IsAny())).Returns(technology); + + Guid result = await this.TechnologyService.Create(createTechnologyServiceModel); + + Assert.AreEqual(id, result); + }).GetAwaiter().GetResult(); } [Test] - public async void Create_ReturnsEmptyGuid_WhenEntityIsNotAddedSuccessfully() + public void Create_ReturnsEmptyGuid_WhenEntityIsNotAddedSuccessfully() { - string technologyName = "Gosho Trapov"; - - CreateTechnologyServiceModel createTechnologyServiceModel = new() - { - Name = technologyName - }; - Technology technology = new() + Task.Run(async () => { - Name = technologyName - }; + string technologyName = "Gosho Trapov"; - this.TechnologyRepositoryMock.Setup(p => p.DoesTechnologyNameExistAsync(It.IsAny())).Returns(Task.FromResult(false)); - this.TechnologyRepositoryMock.Setup(p => p.AddAsync(It.IsAny())).Returns(Task.FromResult(false)); - this.MapperMock.Setup(p => p.Map(It.IsAny())).Returns(technology); + CreateTechnologyServiceModel createTechnologyServiceModel = new() + { + Name = technologyName + }; + Technology technology = new() + { + Name = technologyName + }; - Guid result = await this.TechnologyService.Create(createTechnologyServiceModel); + this.TechnologyRepositoryMock.Setup(p => p.DoesTechnologyNameExistAsync(It.IsAny())).Returns(Task.FromResult(false)); + this.TechnologyRepositoryMock.Setup(p => p.AddAsync(It.IsAny())).Returns(Task.FromResult(false)); + this.MapperMock.Setup(p => p.Map(It.IsAny())).Returns(technology); - Assert.IsTrue(result == Guid.Empty); + Guid result = await this.TechnologyService.Create(createTechnologyServiceModel); + + Assert.IsTrue(result == Guid.Empty); + }).GetAwaiter().GetResult(); } [Test] @@ -99,25 +105,28 @@ namespace DevHive.Services.Tests #region Read [Test] - public async void GetTechnologyById_ReturnsTheTechnology_WhenItExists() + public void GetTechnologyById_ReturnsTheTechnology_WhenItExists() { - Guid id = new Guid(); - string name = "Gosho Trapov"; - Technology technology = new() + Task.Run(async () => { - Name = name - }; - CreateTechnologyServiceModel createTechnologyServiceModel = new() - { - Name = name - }; - - this.TechnologyRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny())).Returns(Task.FromResult(technology)); - this.MapperMock.Setup(p => p.Map(It.IsAny())).Returns(createTechnologyServiceModel); - - CreateTechnologyServiceModel result = await this.TechnologyService.GetTechnologyById(id); - - Assert.AreEqual(name, result.Name); + Guid id = new Guid(); + string name = "Gosho Trapov"; + Technology technology = new() + { + Name = name + }; + CreateTechnologyServiceModel createTechnologyServiceModel = new() + { + Name = name + }; + + this.TechnologyRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny())).Returns(Task.FromResult(technology)); + this.MapperMock.Setup(p => p.Map(It.IsAny())).Returns(createTechnologyServiceModel); + + CreateTechnologyServiceModel result = await this.TechnologyService.GetTechnologyById(id); + + Assert.AreEqual(name, result.Name); + }).GetAwaiter().GetResult(); } [Test] @@ -137,26 +146,29 @@ namespace DevHive.Services.Tests [Test] [TestCase(true)] [TestCase(false)] - public async void UpdateTechnology_ReturnsIfUpdateIsSuccessfull_WhenTechnologyExistsy(bool shouldPass) + public void UpdateTechnology_ReturnsIfUpdateIsSuccessfull_WhenTechnologyExistsy(bool shouldPass) { - string name = "Gosho Trapov"; - Technology technology = new Technology - { - Name = name - }; - UpdateTechnologyServiceModel updatetechnologyServiceModel = new UpdateTechnologyServiceModel + Task.Run(async () => { - Name = name, - }; - - this.TechnologyRepositoryMock.Setup(p => p.DoesTechnologyExistAsync(It.IsAny())).Returns(Task.FromResult(true)); - this.TechnologyRepositoryMock.Setup(p => p.DoesTechnologyNameExistAsync(It.IsAny())).Returns(Task.FromResult(false)); - this.TechnologyRepositoryMock.Setup(p => p.EditAsync(It.IsAny())).Returns(Task.FromResult(shouldPass)); - this.MapperMock.Setup(p => p.Map(It.IsAny())).Returns(technology); - - bool result = await this.TechnologyService.UpdateTechnology(updatetechnologyServiceModel); - - Assert.AreEqual(shouldPass, result); + string name = "Gosho Trapov"; + Technology technology = new Technology + { + Name = name + }; + UpdateTechnologyServiceModel updatetechnologyServiceModel = new UpdateTechnologyServiceModel + { + Name = name, + }; + + this.TechnologyRepositoryMock.Setup(p => p.DoesTechnologyExistAsync(It.IsAny())).Returns(Task.FromResult(true)); + this.TechnologyRepositoryMock.Setup(p => p.DoesTechnologyNameExistAsync(It.IsAny())).Returns(Task.FromResult(false)); + this.TechnologyRepositoryMock.Setup(p => p.EditAsync(It.IsAny())).Returns(Task.FromResult(shouldPass)); + this.MapperMock.Setup(p => p.Map(It.IsAny())).Returns(technology); + + bool result = await this.TechnologyService.UpdateTechnology(updatetechnologyServiceModel); + + Assert.AreEqual(shouldPass, result); + }).GetAwaiter().GetResult(); } [Test] @@ -196,18 +208,21 @@ namespace DevHive.Services.Tests [Test] [TestCase(true)] [TestCase(false)] - public async void DeleteTechnology_ShouldReturnIfDeletionIsSuccessfull_WhenTechnologyExists(bool shouldPass) + public void DeleteTechnology_ShouldReturnIfDeletionIsSuccessfull_WhenTechnologyExists(bool shouldPass) { - Guid id = new Guid(); - Technology technology = new Technology(); + Task.Run(async () => + { + Guid id = new Guid(); + Technology technology = new Technology(); - this.TechnologyRepositoryMock.Setup(p => p.DoesTechnologyExistAsync(It.IsAny())).Returns(Task.FromResult(true)); - this.TechnologyRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny())).Returns(Task.FromResult(technology)); - this.TechnologyRepositoryMock.Setup(p => p.DeleteAsync(It.IsAny())).Returns(Task.FromResult(shouldPass)); + this.TechnologyRepositoryMock.Setup(p => p.DoesTechnologyExistAsync(It.IsAny())).Returns(Task.FromResult(true)); + this.TechnologyRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny())).Returns(Task.FromResult(technology)); + this.TechnologyRepositoryMock.Setup(p => p.DeleteAsync(It.IsAny())).Returns(Task.FromResult(shouldPass)); - bool result = await this.TechnologyService.DeleteTechnology(id); + bool result = await this.TechnologyService.DeleteTechnology(id); - Assert.AreEqual(shouldPass, result); + Assert.AreEqual(shouldPass, result); + }).GetAwaiter().GetResult(); } [Test] @@ -223,5 +238,10 @@ namespace DevHive.Services.Tests Assert.AreEqual(exceptionMessage, ex.Message, "Incorecct exception message"); } #endregion + + //Task.Run(async () => + //{ + + //}).GetAwaiter().GetResult(); } } -- cgit v1.2.3 From f61da9c07ff37cb350528e255539b4ec11181bde Mon Sep 17 00:00:00 2001 From: Danail Dimitrov Date: Tue, 26 Jan 2021 15:49:38 +0200 Subject: Adding User Repository Tests --- src/DevHive.Data/Repositories/UserRepository.cs | 2 - .../DevHive.Data.Tests/LenguageRepository.Tests.cs | 107 ++++++- .../TechnologyRepository.Tests.cs | 65 +---- .../DevHive.Data.Tests/UserRepositoryTests.cs | 323 ++++++++++++++++++--- .../LanguageService.Tests.cs | 6 +- .../DevHive.Services.Tests/PostService.Tests.cs | 48 +++ .../TechnologyServices.Tests.cs | 6 +- 7 files changed, 450 insertions(+), 107 deletions(-) (limited to 'src/DevHive.Tests/DevHive.Data.Tests/LenguageRepository.Tests.cs') diff --git a/src/DevHive.Data/Repositories/UserRepository.cs b/src/DevHive.Data/Repositories/UserRepository.cs index a2298db..34b222e 100644 --- a/src/DevHive.Data/Repositories/UserRepository.cs +++ b/src/DevHive.Data/Repositories/UserRepository.cs @@ -19,7 +19,6 @@ namespace DevHive.Data.Repositories } #region Read - public IEnumerable QueryAll() { return this._context.Users @@ -73,7 +72,6 @@ namespace DevHive.Data.Repositories #endregion #region Validations - public async Task DoesUserExistAsync(Guid id) { return await this._context.Users 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() + .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() .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 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 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 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 dummyUserLanguages = dummyUser.Languages; //Act - User user = await this._userRepository.GetByUsernameAsync(username); + HashSet 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 dummyUserLanguages = dummyUser.Languages; //Act HashSet 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 friends = new HashSet(); + 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 friends = new HashSet(); + 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 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())).Returns(Task.FromResult(true)); this.LanguageRepositoryMock.Setup(p => p.DoesLanguageNameExistAsync(It.IsAny())).Returns(Task.FromResult(false)); - this.LanguageRepositoryMock.Setup(p => p.EditAsync(It.IsAny())).Returns(Task.FromResult(shouldPass)); + this.LanguageRepositoryMock.Setup(p => p.EditAsync(It.IsAny(), It.IsAny())).Returns(Task.FromResult(shouldPass)); this.MapperMock.Setup(p => p.Map(It.IsAny())).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())).Returns(Task.FromResult(true)); + this.PostRepositoryMock.Setup(p => p.GetPostByIssuerAndTimeCreatedAsync(It.IsAny(), It.IsAny())).Returns(Task.FromResult(post)); + this.MapperMock.Setup(p => p.Map(It.IsAny())).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())).Returns(Task.FromResult(false)); + this.MapperMock.Setup(p => p.Map(It.IsAny())).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())).Returns(Task.FromResult(true)); this.TechnologyRepositoryMock.Setup(p => p.DoesTechnologyNameExistAsync(It.IsAny())).Returns(Task.FromResult(false)); - this.TechnologyRepositoryMock.Setup(p => p.EditAsync(It.IsAny())).Returns(Task.FromResult(shouldPass)); + this.TechnologyRepositoryMock.Setup(p => p.EditAsync(It.IsAny(), It.IsAny())).Returns(Task.FromResult(shouldPass)); this.MapperMock.Setup(p => p.Map(It.IsAny())).Returns(technology); bool result = await this.TechnologyService.UpdateTechnology(updatetechnologyServiceModel); -- cgit v1.2.3