Merge pull request #64 from Standaard-boos/MergeSprint2

Merge sprint2 into main

Author: RillJ

Gateway.Test/Gateway.Test.csproj

@@ -17,4 +17,13 @@
     <ProjectReference Include="..\Gateway\Gateway.csproj" />
   </ItemGroup>
 
+  <ItemGroup>
+    <None Update="ReSharperTestRunner.dll.config">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+    <None Update="testhost.dll.config">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
+
 </Project>

Gateway.Test/Gateway_AccountDataAccess_CheckIfAccountExists.cs

@@ -0,0 +1,33 @@
+using NUnit.Framework;
+
+namespace Gateway.Test
+{
+    public class Gateway_AccountDataAccess_CheckIfAccountExists
+    {
+        [Test]
+        public void CheckIfAccountExists_ExistingAccount_ReturnsTrue()
+        {
+            // Arrange
+            const string email = "ThisAccountDoesExist@wafoe.nl";
+
+            // Act
+            bool result = AccountDataAccess.CheckIfAccountExists(email);
+
+            // Assert
+            Assert.IsTrue(result);
+        }
+
+        [Test]
+        public void CheckIfAccountExists_NonExistingAccount_ReturnsFalse()
+        {
+            // Arrange
+            const string email = "ThisAccountDoesNotExist";
+
+            // Act
+            bool result = AccountDataAccess.CheckIfAccountExists(email);
+
+            // Assert
+            Assert.IsFalse(result);
+        }
+    }
+}

Gateway.Test/Gateway_AccountDataAccess_CheckIfAccountIsVerified.cs

@@ -0,0 +1,33 @@
+using NUnit.Framework;
+
+namespace Gateway.Test
+{
+    public class Gateway_AccountDataAccess_CheckIfAccountIsVerified
+    {
+        [Test]
+        public void CheckIfAccountIsVerified_AccountVerified_ReturnsTrue()
+        {
+            // Arrange
+            const string email = "ThisAccountDoesExist@wafoe.nl";
+
+            // Act
+            bool result = AccountDataAccess.CheckIfAccountIsVerified(email);
+
+            // Assert
+            Assert.IsTrue(result);
+        }
+
+        [Test]
+        public void CheckIfAccountIsVerified_AccountNotVerified_ReturnsFalse()
+        {
+            // Arrange
+            const string email = "ThisUnverifiedAccountDoesExist@wafoe.nl";
+
+            // Act
+            bool result = AccountDataAccess.CheckIfAccountIsVerified(email);
+
+            // Assert
+            Assert.IsFalse(result);
+        }
+    }
+}

Gateway.Test/Gateway_AccountDataAccess_CheckIfVerificationCodeMatches.cs

@@ -0,0 +1,35 @@
+using NUnit.Framework;
+
+namespace Gateway.Test
+{
+    public class Gateway_AccountDataAccess_CheckIfVerificationCodeMatches
+    {
+        [Test]
+        public void CheckIfVerificationCodeMatches_ValidVerificationCode_ReturnsTrue()
+        {
+            // Arrange
+            const string email = "ThisAccountDoesExist@wafoe.nl";
+            const string verificationCode = "123456";
+
+            // Act
+            bool result = AccountDataAccess.CheckIfVerificationCodeMatches(verificationCode, email);
+
+            // Assert
+            Assert.IsTrue(result);
+        }
+
+        [Test]
+        public void CheckIfVerificationCodeMatches_InvalidVerificationCode_ReturnsFalse()
+        {
+            // Arrange
+            const string email = "ThisAccountDoesExist@wafoe.nl";
+            const string verificationCode = "000000";
+
+            // Act
+            bool result = AccountDataAccess.CheckIfVerificationCodeMatches(verificationCode, email);
+
+            // Assert
+            Assert.IsFalse(result);
+        }
+    }
+}

Gateway.Test/Gateway_AccountDataAccess_CreateAccount.cs

@@ -0,0 +1,36 @@
+using NUnit.Framework;
+using System;
+
+namespace Gateway.Test
+{
+    public class Gateway_AccountDataAccess_CreateAccount
+    {
+        [Test]
+        public void CreateAccount_NonExistingAccount_ThrowsNoException()
+        {
+            // Arrange
+            Random random = new Random((int)DateTime.UtcNow.Ticks); // Generate random email and password to basically ensure it does not exist already in the database
+
+            string email = random.Next().ToString() + random.Next().ToString();
+            string password = random.Next().ToString() + random.Next().ToString();
+            const string verificationCode = "123456";
+
+            // Act
+            static void HasSuccessfullyRegistered(string email, string password)
+            {
+                try
+                {
+                    AccountDataAccess.CreateAccount(email, password, verificationCode);
+                    AccountDataAccess.DeleteAccount(email); // Also tests the delete method to clean up garbage data from the database
+                }
+                catch (Exception)
+                {
+                    throw;
+                }
+            }
+
+            // Assert
+            Assert.DoesNotThrow(() => HasSuccessfullyRegistered(email, password));
+        }
+    }
+}

Gateway.Test/Gateway_AccountDataAccess_GetHashedPassswordFromAccount.cs

@@ -0,0 +1,24 @@
+using NUnit.Framework;
+
+namespace Gateway.Test
+{
+    public class Gateway_AccountDataAccess_GetHashedPassswordFromAccount
+    {
+        /// <summary>
+        /// This test should return a value starting with a dollar sign, because that is the first char in a hashed and salted string.
+        /// </summary>
+        [Test]
+        public void GetHashedPassswordFromAccount_ExistingAccount_ReturnsValueStartingWithDollarSign()
+        {
+            // Arrange
+            const string email = "ThisAccountDoesExist@wafoe.nl";
+
+            // Act
+            string hashedPassword = AccountDataAccess.GetHashedPassswordFromAccount(email);
+            bool startsWithDollarSign = hashedPassword[0] == '$';
+
+            // Assert
+            Assert.IsTrue(startsWithDollarSign);
+        }
+    }
+}

Gateway.Test/Gateway_AccountDataAccess_GetUserIDFromAccount.cs

@@ -0,0 +1,21 @@
+using NUnit.Framework;
+using System;
+
+namespace Gateway.Test
+{
+    public class Gateway_AccountDataAccess_GetUserIDFromAccount
+    {
+        [Test]
+        public void GetUserIDFromAccount_ExistingUserID_ReturnsCorrectID()
+        {
+            // Arrange
+            const string email = "ThisAccountDoesExist@wafoe.nl";
+
+            // Act
+            int userID = AccountDataAccess.GetUserIDFromAccount(email);
+
+            // Assert
+            Assert.AreEqual(1, userID);
+        }
+    }
+}

Gateway.Test/Gateway_FiddleHelper_GetConnectionStringSql.cs

@@ -0,0 +1,20 @@
+using NUnit.Framework;
+
+namespace Gateway.Test
+{
+    public class Gateway_FiddleHelper_GetConnectionStringSql
+    {
+        [Test]
+        public void GetConnectionStringSql_ValidString_ReturnsValue()
+        {
+            // Arrange
+            const string connectionString = "StudentMatcherDB";
+
+            // Act
+            string result = FiddleHelper.GetConnectionStringSql(connectionString);
+
+            // Assert
+            Assert.IsNotEmpty(result);
+        }
+    }
+}

Gateway.Test/Gateway_MatchDataAccess_AddLikeToUserIDs.cs

@@ -0,0 +1,67 @@
+using System;
+using NUnit.Framework;
+using System.Collections.Generic;
+
+namespace Gateway.Test
+{
+    public class Gateway_MatchDataAccess_AddLikeToUserIDs
+    {
+        static void CleanUp(int id1, int id2)
+        {
+            MatchDataAccess.RemoveMatchFromUser(id1, id2);
+        }
+
+        [Test]
+        public void AddLikeToUserIDs_NonExistingMatch_ThrowsNoError()
+        {
+            // Arrange
+            const int userID1 = 1; // ThisAccountDoesExist@wafoe.nl
+            const int userID2 = 12; // ThisUnverifiedAccountDoesExist@wafoe.nl
+
+            // Act
+            void AddLike()
+            {
+                try
+                {
+                    MatchDataAccess.AddLikeToUserIDs(userID1, userID2, 1); // Relation ship can be a random value - I chose 1
+                }
+                catch (Exception)
+                {
+                    throw;
+                }
+                
+            }
+
+            // Assert
+            Assert.DoesNotThrow(() => AddLike(), "AddLikeToUserIDs");
+            Assert.DoesNotThrow(() => CleanUp(userID1, userID2), "RemoveMatchFromUser");
+        }
+
+        [Test]
+        public void AddLikeToUserIDs_ExistingMatch_ThrowsError()
+        {
+            // Arrange
+            const int userID1 = 1; // ThisAccountDoesExist@wafoe.nl
+            const int userID2 = 12; // ThisUnverifiedAccountDoesExist@wafoe.nl
+
+            // Act
+            void AddLike()
+            {
+                try
+                {
+                    MatchDataAccess.AddLikeToUserIDs(userID1, userID2, 1); // Relation ship can be a random value - I chose 1
+                }
+                catch (Exception)
+                {
+                    throw;
+                }
+
+            }
+
+            // Assert
+            Assert.DoesNotThrow(() => AddLike(), "Should not throw exception");
+            Assert.Throws<System.Data.SqlClient.SqlException>(() => AddLike(), "Should throw exception");
+            Assert.DoesNotThrow(() => CleanUp(userID1, userID2), "RemoveMatchFromUser");
+        }
+    }
+}

Gateway.Test/Gateway_MatchDataAccess_CheckIfUserLiked.cs

@@ -0,0 +1,74 @@
+using System;
+using NUnit.Framework;
+using System.Collections.Generic;
+using Model;
+using System.Linq;
+
+namespace Gateway.Test
+{
+    public class Gateway_MatchDataAccess_CheckIfUserLiked
+    {
+        [Test]
+        public void CheckIfUserLiked_DidLike_ReturnsTrue()
+        {
+            // Arrange
+            const int userID1 = 1; // ThisAccountDoesExist@wafoe.nl
+            const int userID2 = 12; // ThisUnverifiedAccountDoesExist@wafoe.nl
+            bool? result = null;
+
+            // Act
+            List<int> listOfMatches = MatchDataAccess.GetAllMatchesFromUser(userID1, MatchOrLike.Matched);
+
+            void CheckLike()
+            {
+                try
+                {
+                    MatchDataAccess.AddLikeToUserIDs(userID1, userID2, 1); // First add the match to the database
+                    result = MatchDataAccess.CheckIfUserLiked(userID2, userID1); // Turn them around just to test
+                }
+                catch (Exception)
+                {
+                    throw;
+                }
+            }
+
+            void CleanUp()
+            {
+                MatchDataAccess.RemoveMatchFromUser(userID1, userID2); // Clean up the match
+            }
+
+            // Assert
+            Assert.DoesNotThrow(() => CheckLike(), "CheckIfUserLiked");
+            Assert.IsTrue(result, "Liked?");
+            Assert.DoesNotThrow(() => CleanUp(), "Clean up");
+        }
+
+        [Test]
+        public void CheckIfUserLiked_DidNotLike_ReturnsFalse()
+        {
+            // Arrange
+            const int userID1 = 1; // ThisAccountDoesExist@wafoe.nl
+            const int userID2 = 12; // ThisUnverifiedAccountDoesExist@wafoe.nl
+            bool? result = null;
+
+            // Act
+            List<int> listOfMatches = MatchDataAccess.GetAllMatchesFromUser(userID1, MatchOrLike.Matched);
+
+            void CheckLike()
+            {
+                try
+                {
+                    result = MatchDataAccess.CheckIfUserLiked(userID1, userID2);
+                }
+                catch (Exception)
+                {
+                    throw;
+                }
+            }
+
+            // Assert
+            Assert.DoesNotThrow(() => CheckLike(), "CheckIfUserLiked");
+            Assert.IsFalse(result, "Liked?");
+        }
+    }
+}