Adding User Repository 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);