From 6deaa6edcd8e347d5ed28ee3389cb8712cc64ea3 Mon Sep 17 00:00:00 2001 From: transtrike Date: Wed, 13 Jan 2021 11:05:26 +0200 Subject: The return of the interfaces --- .../TechnologyServices.Tests.cs | 270 +++++++++++++++++++++ 1 file changed, 270 insertions(+) create mode 100644 src/DevHive.Tests/DevHive.Services.Tests/TechnologyServices.Tests.cs (limited to 'src/DevHive.Tests/DevHive.Services.Tests/TechnologyServices.Tests.cs') 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..f335aba --- /dev/null +++ b/src/DevHive.Tests/DevHive.Services.Tests/TechnologyServices.Tests.cs @@ -0,0 +1,270 @@ +using AutoMapper; +using DevHive.Data.Interfaces; +using DevHive.Data.Models; +using DevHive.Services.Models.Technology; +using DevHive.Services.Services; +using Moq; +using NUnit.Framework; +using System; +using System.Threading.Tasks; + +namespace DevHive.Services.Tests +{ + [TestFixture] + public class TechnologyServicesTests + { + private Mock TechnologyRepositoryMock { get; set; } + private Mock MapperMock { get; set; } + private TechnologyService TechnologyService { get; set; } + + [SetUp] + public void Setup() + { + this.TechnologyRepositoryMock = new Mock(); + this.MapperMock = new Mock(); + this.TechnologyService = new TechnologyService(this.TechnologyRepositoryMock.Object, this.MapperMock.Object); + } + + #region Create + [Test] + [TestCase(true)] + [TestCase(false)] + public void Create_ReturnsTrue_WhenEntityIsAddedSuccessfully(bool shouldFail) + { + Task.Run(async () => + { + string technologyName = "Gosho Trapov"; + + CreateTechnologyServiceModel createTechnologyServiceModel = new() + { + Name = technologyName + }; + Technology technology = new() + { + Name = technologyName + }; + + this.TechnologyRepositoryMock.Setup(p => p.DoesTechnologyNameExist(It.IsAny())).Returns(Task.FromResult(false)); + this.TechnologyRepositoryMock.Setup(p => p.AddAsync(It.IsAny())).Returns(Task.FromResult(shouldFail)); + this.MapperMock.Setup(p => p.Map(It.IsAny())).Returns(technology); + + bool result = await this.TechnologyService.Create(createTechnologyServiceModel); + + Assert.AreEqual(shouldFail, result); + }).GetAwaiter().GetResult(); + } + + [Test] + public void Create_ThrowsArgumentException_WhenEntityAlreadyExists() + { + Task.Run(async () => + { + string expectedExceptionMessage = "Technology already exists!"; + string technologyName = "Gosho Trapov"; + + CreateTechnologyServiceModel createTechnologyServiceModel = new() + { + Name = technologyName + }; + Technology technology = new() + { + Name = technologyName + }; + + this.TechnologyRepositoryMock.Setup(p => p.DoesTechnologyNameExist(It.IsAny())).Returns(Task.FromResult(true)); + + try + { + await this.TechnologyService.Create(createTechnologyServiceModel); + Assert.Fail("Create does not throw exception when technology already exists"); + } + catch (ArgumentException ex) + { + Assert.AreEqual(expectedExceptionMessage, ex.Message); + } + }).GetAwaiter().GetResult(); + } + #endregion + + // #region GetById + // [Test] + // public void GetTechnologyById_ReturnsTheTechnology_WhenItExists() + // { + // Task.Run(async () => + // { + // Guid id = new Guid(); + // string name = "Gosho Trapov"; + // Technology technology = new() + // { + // Name = name + // }; + // TechnologyServiceModel technologyServiceModel = new()) + // { + // Name = name + // }; + + // this.TechnologyRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny())).Returns(Task.FromResult(technology)); + // this.MapperMock.Setup(p => p.Map(It.IsAny())).Returns(technologyServiceModel); + + // TechnologyServiceModel result = await this.TechnologyService.GetTechnologyById(id); + + // Assert.AreEqual(name, result.Name); + // }).GetAwaiter().GetResult(); + // } + + // [Test] + // public void GetTechnologyById_ThrowsException_WhenTechnologyDoesNotExist() + // { + // Task.Run(async () => + // { + // string exceptionMessage = "The technology does not exist"; + // Guid id = new Guid(); + // this.TechnologyRepositoryMock.Setup(p => p.GetByIdAsync(It.IsAny())).Returns(Task.FromResult(null)); + + // try + // { + // await this.TechnologyService.GetTechnologyById(id); + // Assert.Fail("GetTechnologyById does not throw exception when technology does not exist"); + // } + // catch (ArgumentException ex) + // { + // Assert.AreEqual(exceptionMessage, ex.Message, "Exception messege is nto correct"); + // } + // }).GetAwaiter().GetResult(); + // } + // #endregion + + // #region Update + // [Test] + // [TestCase(true)] + // [TestCase(false)] + // public void UpdateTechnology_ReturnsIfUpdateIsSuccessfull_WhenTechnologyExistsy(bool shouldPass) + // { + // Task.Run(async () => + // { + // Guid id = new Guid(); + // string name = "Gosho Trapov"; + // Technology technology = new Technology + // { + // Name = name + // }; + // UpdateTechnologyServiceModel updatetechnologyServiceModel = new UpdateTechnologyServiceModel + // { + // Name = name, + // Id = id + // }; + + // this.TechnologyRepositoryMock.Setup(p => p.DoesTechnologyExistAsync(It.IsAny())).Returns(Task.FromResult(true)); + // this.TechnologyRepositoryMock.Setup(p => p.DoesTechnologyNameExist(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] + // public void UpdateTechnology_ThrowsException_WhenTechnologyDoesNotExist() + // { + // Task.Run(async () => + // { + // string exceptionMessage = "Technology does not exist!"; + // Guid id = new Guid(); + // UpdateTechnologyServiceModel updateTechnologyServiceModel = new UpdateTechnologyServiceModel + // { + // Id = id + // }; + + // this.TechnologyRepositoryMock.Setup(p => p.DoesTechnologyExistAsync(It.IsAny())).Returns(Task.FromResult(false)); + + // try + // { + // await this.TechnologyService.UpdateTechnology(updateTechnologyServiceModel); + // Assert.Fail("UpdateTechnology does not throw exception when technology does not exist"); + // } + // catch (ArgumentException ex) + // { + // Assert.AreEqual(exceptionMessage, ex.Message, "Exception Message is not correct"); + // } + // }).GetAwaiter().GetResult(); + // } + + // [Test] + // public void UpdateTechnology_ThrowsException_WhenTechnologyNameAlreadyExists() + // { + // Task.Run(async () => + // { + // string exceptionMessage = "Technology name already exists!"; + // Guid id = new Guid(); + // UpdateTechnologyServiceModel updateTechnologyServiceModel = new UpdateTechnologyServiceModel + // { + // Id = id + // }; + + // this.TechnologyRepositoryMock.Setup(p => p.DoesTechnologyExistAsync(It.IsAny())).Returns(Task.FromResult(true)); + // this.TechnologyRepositoryMock.Setup(p => p.DoesTechnologyNameExist(It.IsAny())).Returns(Task.FromResult(true)); + + // try + // { + // await this.TechnologyService.UpdateTechnology(updateTechnologyServiceModel); + // Assert.Fail("UpdateTechnology does not throw exception when technology name already exist"); + // } + // catch (ArgumentException ex) + // { + // Assert.AreEqual(exceptionMessage, ex.Message, "Exception Message is not correct"); + // } + // }).GetAwaiter().GetResult(); + // } + // #endregion + + // #region Delete + // [Test] + // [TestCase(true)] + // [TestCase(false)] + // public void DeleteTechnology_ShouldReturnIfDeletionIsSuccessfull_WhenTechnologyExists(bool shouldPass) + // { + // 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)); + + // bool result = await this.TechnologyService.DeleteTechnology(id); + + // Assert.AreEqual(shouldPass, result); + // }).GetAwaiter().GetResult(); + // } + + // [Test] + // public void DeleteTechnology_ThrowsException_WhenTechnologyDoesNotExist() + // { + // Task.Run(async () => + // { + // string exceptionMessage = "Technology does not exist!"; + // Guid id = new Guid(); + + // this.TechnologyRepositoryMock.Setup(p => p.DoesTechnologyExistAsync(It.IsAny())).Returns(Task.FromResult(false)); + + // try + // { + // await this.TechnologyService.DeleteTechnology(id); + // Assert.Fail("DeleteTechnology does not throw exception when technology does not exist"); + // } + // catch (ArgumentException ex) + // { + // Assert.AreEqual(exceptionMessage, ex.Message, "Incorecct exception message"); + // } + // }).GetAwaiter().GetResult(); + // } + // #endregion + // //Task.Run(async () => + // //{ + // // + // //}).GetAwaiter().GetResult(); + } +} -- cgit v1.2.3