Merge pull request #18 from Team-Kaleidoscope/devv0.1

First stage: Complete. Awaiting further progress...

1 files changed, 350 insertions, 0 deletions

diff --git a/src/DevHive.Tests/DevHive.Data.Tests/UserRepositoryTests.cs b/src/DevHive.Tests/DevHive.Data.Tests/UserRepositoryTests.cs
new file mode 100644
index 0000000..43e9a36
--- /dev/null
+++ b/src/DevHive.Tests/DevHive.Data.Tests/UserRepositoryTests.cs
@@ -0,0 +1,350 @@
+using System;
+using System.Collections.Generic;
+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
+{
+	[TestFixture]
+	public class UserRepositoryTests
+	{
+		private DevHiveContext _context;
+		private UserRepository _userRepository;
+
+		#region Setups
+		[SetUp]
+		public void Setup()
+		{
+			var options = new DbContextOptionsBuilder<DevHiveContext>()
+				.UseInMemoryDatabase("DevHive_UserRepository_Database");
+
+			this._context = new DevHiveContext(options.Options);
+			this._userRepository = new UserRepository(_context);
+		}
+
+		[TearDown]
+		public async Task Teardown()
+		{
+			await this._context.Database.EnsureDeletedAsync();
+		}
+		#endregion
+
+		#region QueryAll
+		// [Test]
+		// public async Task QueryAll_ShouldReturnAllUsersFromDatabase_WhenTheyExist()
+		// {
+		// 	//Arrange
+		// 	User dummyUserOne = CreateDummyUser();
+		// 	User dummyUserTwo = CreateAnotherDummyUser();
+        //
+		// 	await this._userRepository.AddAsync(dummyUserOne);
+		// 	await this._userRepository.AddAsync(dummyUserTwo);
+        //
+		// 	//Act
+		// 	IEnumerable<User> users = this._userRepository.QueryAll();
+        //
+		// 	//Assert
+		// 	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 EditAsync
+		[Test]
+		public async Task EditAsync_ReturnsTrue_WhenUserIsUpdatedSuccessfully()
+		{
+			User oldUser = this.CreateDummyUser();
+			this._context.Users.Add(oldUser);
+			await this._context.SaveChangesAsync();
+
+			oldUser.UserName = "SuperSecretUserName";
+			bool result = await this._userRepository.EditAsync(oldUser.Id, oldUser);
+
+			Assert.IsTrue(result, "EditAsync does not return true when User is updated successfully");
+		}
+		#endregion
+
+		#region GetByIdAsync
+		[Test]
+		public async Task GetByIdAsync_ReturnsTheUse_WhenItExists()
+		{
+			User dummyUserOne = CreateDummyUser();
+			await this._userRepository.AddAsync(dummyUserOne);
+
+			User resultUser = await this._userRepository.GetByIdAsync(dummyUserOne.Id);
+
+			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 GetByUsernameAsync_ReturnsUserFromDatabase_WhenItExists()
+		{
+			//Arrange
+			User dummyUser = CreateDummyUser();
+			await this._userRepository.AddAsync(dummyUser);
+			string username = dummyUser.UserName;
+
+			//Act
+			User user = await this._userRepository.GetByUsernameAsync(username);
+
+			//Assert
+			Assert.AreEqual(dummyUser.Id, user.Id, "Method doesn't get the proper user from database");
+		}
+
+		[Test]
+		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 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>
+		//	{
+		//		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 HelperMethods
+		private User CreateDummyUser()
+		{
+			HashSet<Language> languages = new()
+			{
+				new Language()
+				{
+					Id = Guid.NewGuid(),
+					Name = "csharp"
+				},
+			};
+
+			HashSet<Technology> technologies = new()
+			{
+				new Technology()
+				{
+					Id = Guid.NewGuid(),
+					Name = "ASP.NET Core"
+				},
+			};
+
+			HashSet<Role> roles = new()
+			{
+				new Role()
+				{
+					Id = Guid.NewGuid(),
+					Name = Role.DefaultRole
+				},
+			};
+
+			return new()
+			{
+				Id = Guid.NewGuid(),
+				UserName = "dummyUser",
+				FirstName = "Spas",
+				LastName = "Spasov",
+				Email = "abv@abv.bg",
+				Languages = languages,
+				Technologies = technologies,
+				Roles = roles
+			};
+		}
+
+		private User CreateAnotherDummyUser()
+		{
+			HashSet<Language> languages = new()
+			{
+				new Language()
+				{
+					Id = Guid.NewGuid(),
+					Name = "typescript"
+				},
+			};
+
+			HashSet<Technology> technologies = new()
+			{
+				new Technology()
+				{
+					Id = Guid.NewGuid(),
+					Name = "Angular"
+				},
+			};
+
+			HashSet<Role> roles = new()
+			{
+				new Role()
+				{
+					Id = Guid.NewGuid(),
+					Name = Role.DefaultRole
+				},
+			};
+
+			return new()
+			{
+				Id = Guid.NewGuid(),
+				UserName = "anotherDummyUser",
+				FirstName = "Alex",
+				LastName = "Spiridonov",
+				Email = "a_spiridonov@abv.bg",
+				Languages = languages,
+				Technologies = technologies,
+				Roles = roles
+			};
+		}
+		#endregion
+	}
+}