Refactored Technology service tests

1 files changed, 166 insertions, 169 deletions

diff --git a/src/DevHive.Tests/DevHive.Services.Tests/TechnologyServices.Tests.cs b/src/DevHive.Tests/DevHive.Services.Tests/TechnologyServices.Tests.cs
index e56c508..9e0876d 100644
--- a/src/DevHive.Tests/DevHive.Services.Tests/TechnologyServices.Tests.cs
+++ b/src/DevHive.Tests/DevHive.Services.Tests/TechnologyServices.Tests.cs
@@ -1,4 +1,4 @@
-using AutoMapper;
+using AutoMapper;
 using DevHive.Data.Interfaces;
 using DevHive.Data.Models;
 using DevHive.Services.Models.Technology;
@@ -89,182 +89,179 @@ namespace DevHive.Services.Tests
 
 		#region Read
 
-		// [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<Guid>())).Returns(Task.FromResult(technology));
-		// 		this.MapperMock.Setup(p => p.Map<TechnologyServiceModel>(It.IsAny<Technology>())).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<Guid>())).Returns(Task.FromResult<Technology>(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();
-		// }
+		[Test]
+		public void GetTechnologyById_ReturnsTheTechnology_WhenItExists()
+		{
+			Task.Run(async () =>
+			{
+				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<Guid>())).Returns(Task.FromResult(technology));
+				this.MapperMock.Setup(p => p.Map<CreateTechnologyServiceModel>(It.IsAny<Technology>())).Returns(createTechnologyServiceModel);
+
+				CreateTechnologyServiceModel 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<Guid>())).Returns(Task.FromResult<Technology>(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<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.MapperMock.Setup(p => p.Map<Technology>(It.IsAny<UpdateTechnologyServiceModel>())).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<Guid>())).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<Guid>())).Returns(Task.FromResult(true));
-		// 		this.TechnologyRepositoryMock.Setup(p => p.DoesTechnologyNameExistAsync(It.IsAny<string>())).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();
-		// }
+		[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,
+				};
+
+				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.MapperMock.Setup(p => p.Map<Technology>(It.IsAny<UpdateTechnologyServiceModel>())).Returns(technology);
+
+				bool result = await this.TechnologyService.UpdateTechnology(id, 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
+				{
+				};
+
+				this.TechnologyRepositoryMock.Setup(p => p.DoesTechnologyExistAsync(It.IsAny<Guid>())).Returns(Task.FromResult(false));
+
+				try
+				{
+					await this.TechnologyService.UpdateTechnology(id, 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
+				{
+				};
+
+				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));
+
+				try
+				{
+					await this.TechnologyService.UpdateTechnology(id, 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<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);
-		// 	}).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<Guid>())).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();
-		// }
+		[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<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);
+			}).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<Guid>())).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 () =>
 		//{