aswi20220x00-gitlab/Backend/BackendTesting/UserManagementTesting.cs @ ff61085f

using Microsoft.VisualStudio.TestTools.UnitTesting;
using Models.Enums;
using Core.Entities;
using Serilog;

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using AutoMapper;
using Core.MapperProfiles;
using Core.Contexts;
using Microsoft.Extensions.Configuration;
using Models.Users;

namespace Core.Services
{
    //class responsible for testing user and backend autentication on login
    [TestClass]
    public class UserManagementTesting      //testing of Core/Services/UserService
    {
        //necessary items for new database with my data for teting
        private static readonly IConfiguration configuration = new ConfigurationBuilder().Build();
        public DatabaseContext ctx;
        public Core.Services.IUserService US;
        
        //constructor for creating database and filling it with dummy data
        public UserManagementTesting()
        {
            //creating new database
            this.ctx = new DatabaseContext(configuration);
            this.US = new UserServiceEF(this.ctx, TestingLogger.GetLogger(), TestingMapper.GetMapper());

            //ensure the database is fresh without unwanted users from previous testings
            ctx.Database.EnsureDeleted();
            ctx.Database.EnsureCreated();

            //data for testing creation
            var userList = new List<User>();
            userList.Add(new User() { Username = "aaa", Name = "aaa", Surname = "aaa", Password = "aaa", Role = Models.Enums.ERole.ANNOTATOR });
            userList.Add(new User() { Username = "bbb", Name = "bbb", Surname = "bbb", Password = "bbb", Role = Models.Enums.ERole.ANNOTATOR });
            userList.Add(new User() { Username = "ccc", Name = "ccc", Surname = "ccc", Password = "ccc", Role = Models.Enums.ERole.ADMINISTRATOR });
            userList.Add(new User() { Username = "ddd", Name = "ddd", Surname = "ddd", Password = "ddd", Role = Models.Enums.ERole.ANNOTATOR });
            userList.Add(new User() { Username = "eee", Name = "eee", Surname = "eee", Password = "eee", Role = Models.Enums.ERole.ANNOTATOR });
            userList.Add(new User() { Username = "fff", Name = "fff", Surname = "fff", Password = "fff", Role = Models.Enums.ERole.ANNOTATOR });
            userList.Add(new User() { Username = "ggg", Name = "ggg", Surname = "ggg", Password = "ggg", Role = Models.Enums.ERole.ANNOTATOR });
            userList.Add(new User() { Username = "hhh", Name = "hhh", Surname = "hhh", Password = "hhh", Role = Models.Enums.ERole.ADMINISTRATOR });
            userList.Add(new User() { Username = "iii", Name = "iii", Surname = "iii", Password = "iii", Role = Models.Enums.ERole.ADMINISTRATOR });
            userList.Add(new User() { Username = "jjj", Name = "jjj", Surname = "jjj", Password = "jjj", Role = Models.Enums.ERole.ADMINISTRATOR });

            //filling up the database
            foreach (var user in userList)
            {
                US.CreateUser(user.Username, user.Name, user.Surname, user.Password, user.Role);
            }
            ctx.SaveChanges();
        }

        [TestMethod]
        [DataRow("kkk", "kkk", "kkk", "kkk", ERole.ANNOTATOR, true)]
        [DataRow("lll", "lll", "lll", "", ERole.ANNOTATOR, true)]
        [DataRow("mmm", "mmm", "", "mmm", ERole.ANNOTATOR, true)]
        [DataRow("nnn", "", "nnn", "nnn", ERole.ANNOTATOR, true)]
        [DataRow("", "ooo", "ooo", "ooo", ERole.ADMINISTRATOR, false)]
        //method tests saving user into database, retrieving all users checking if the one saved is between them
        public void CreateUser_Test(string username, string name, string surname, string password, ERole role, bool shouldBeRigh)
        {
            //creation of new user
            var output = US.CreateUser(username, name, surname, password, role);
            ctx.SaveChanges();
            if (output == null && !shouldBeRigh)
            {
                //trying to insert user with taken username resolves with refusing 
                return;
            }

            //check for empty atributes
            if((username == null || username == "")&& output!=null)
            {
                Assert.Fail("user with no username created");
                return;
            }
            if ((name == null || name == "") && output != null)
            {
                Assert.Fail("user with no name created");
                return;
            }
            if ((surname == null || surname == "") && output != null)
            {
                Assert.Fail("user with no surname created");
                return;
            }
            if ((password == null || password == "") && output != null)
            {
                Assert.Fail("user with no password created");
                return;
            }

            //retrieving all users checking via username
            foreach (var user in ctx.Users)
            {
                if (user.Username == username)
                {
                    //checking, that user with wanted username was not changed and he is present in database
                    //if there were some data changed (not username) - these tests will fail
                    Assert.AreEqual(name, user.Name, "names are not same");
                    Assert.AreEqual(surname, user.Surname, "surnames are not same");
                    Assert.AreNotEqual(password, user.Password, "passwords are same - it should have been hashed");
                    Assert.AreEqual(role, user.Role, "roles are not same");
                    return;
                }
            }
            //if there was username not found, inserted users username must have been changed or wasnt saved into database at all - test fails
            Assert.Fail("supposedly created user was not found in database");
        }

        [TestMethod]
        [DataRow("aaa", "aaa", "aaa", "aaa", "aaa", ERole.ANNOTATOR)]
        [DataRow("bbb", "bbb", "bbb", "bbb", "bbb", ERole.ANNOTATOR)]
        [DataRow("ccc", "ccc", "ccc", "ccc", "ccc", ERole.ADMINISTRATOR)]
        //method testing, that user searched by username is the one wanted - data are inserted in constructor
        public void GetUserByUsername_Test(string insertedUsername, string username, string name, string surname, string password, ERole role)
        {
            User? actual = US.GetUserByUsername(insertedUsername);
            Assert.AreEqual(username, actual.Username, "wrong username");
            Assert.AreEqual(name, actual.Name, "wrong name");
            Assert.AreEqual(surname, actual.Surname, "wrong surname");
            Assert.AreNotEqual(password, actual.Password, "same password");
            Assert.AreEqual(role, actual.Role, "wrong role");
        }

        [TestMethod]
        [DataRow("aaa", "aaa", "aaa", "aaa", ERole.ANNOTATOR)]
        [DataRow("bbb", "bbb", "bbb", "bbb", ERole.ANNOTATOR)]
        [DataRow("ccc", "ccc", "ccc", "ccc", ERole.ADMINISTRATOR)]
        //testing method to get user via his ID, using another tested method - GetUserByUsername
        public void GetUserById_Test(string username, string name, string surname, string password, ERole role)
        {
            User? expected = US.GetUserByUsername(username);
            if (expected == null)
            {
                Assert.Fail("There is mistake in test data or in GetUserByUsername method");
                return;
            }
            User? actual = US.GetUserById(expected.Id);

            //testing whole users
            Assert.AreEqual(expected, actual, "Users are not same");

            //testing all parameters
            Assert.AreEqual(actual.Username, username, "usernames are not same");
            Assert.AreEqual(actual.Name, name, "names are not same");
            Assert.AreEqual(actual.Surname, surname, "surnames are not same");
            Assert.AreNotEqual(actual.Password, password, "passwords ARE same (the one from database should have been hashed)");
            Assert.AreEqual(actual.Role, role, "roles are not same");
        }




        [TestMethod]
        [DataRow("xxx", "xxx", "xxx", "xxx", ERole.ANNOTATOR, "uuu", "xxx", "xxx", ERole.ANNOTATOR)]
        [DataRow("xxx", "xxx", "xxx", "xxx", ERole.ANNOTATOR, "xxx", "uuu", "xxx", ERole.ANNOTATOR)]
        [DataRow("xxx", "xxx", "xxx", "xxx", ERole.ANNOTATOR, "xxx", "xxx", "uuu", ERole.ANNOTATOR)]
        [DataRow("xxx", "xxx", "xxx", "xxx", ERole.ANNOTATOR, "aaa", "bbb", "ccc", ERole.ANNOTATOR)]
        [DataRow("xxx", "xxx", "xxx", "xxx", ERole.ANNOTATOR, "xxx", "bbb", "ccc", ERole.ANNOTATOR)]
        [DataRow("xxx", "xxx", "xxx", "xxx", ERole.ANNOTATOR, "xxx", "xxx", "xxx", ERole.ADMINISTRATOR)]
        [DataRow("xxx", "xxx", "xxx", "xxx", ERole.ANNOTATOR, "xxx", "bbb", "ccc", ERole.ADMINISTRATOR)]
        //creating new user and updating him
        public void UpdateUser_Test(string oldUsername, string oldName, string oldSurname, string password, ERole oldRole, string? username = null, string? name = null, string? surname = null, ERole? role = null)
        {
            //new user creation
            User? newUser = US.CreateUser(oldUsername, oldName, oldSurname, password, oldRole);
            if(newUser == null)
            {
                Assert.Fail("user not created (maybe already user username?)");
            }
            User? actual = US.UpdateUser(newUser, username, name, surname, role);

            Assert.IsNotNull(actual, "user wasnt updated, null was returned");
            Assert.AreEqual(username, actual.Username, "wrong username");
            Assert.AreEqual(name, actual.Name, "wrong name");
            Assert.AreEqual(surname, actual.Surname, "wrong surname");
            Assert.AreEqual(role, actual.Role, "wrong role");
            Assert.AreNotEqual(password, actual.Password, "same password");

        }
        [TestMethod]
        [DataRow("aaa", "bbb")]//anotator
        [DataRow("ccc", "aaa")]//admin
        [DataRow("bbb", "")]//set to none password
        [DataRow("eee", "eee")]//keep old password
        //test of changing password
        public void ChangePassword_Test(string username, string newPassword) 
        {
            //get user using GetUserByUsername
            User? changingUser = US.GetUserByUsername(username);
            if(changingUser == null)
            {
                Assert.Fail("user not found");
                return;
            }
            //get old password hash
            var oldPassword = changingUser.Password;

            //change password
            User? changed = US.ChangePassword(changingUser, newPassword);
            //new password is not empty and database returned null for user (user had to be there)
            if(changed == null && (newPassword!="" || newPassword != null))
            {
                Assert.Fail("user not returned");
                return;
            }
            //new password is empty
            if((newPassword == "" || newPassword == null) && changed != null)
            {
                Assert.Fail("empty password was accepted");
                return;
            }
            //no user was returned back after ChangePassword
            if(changed == null)
            {
                Assert.Fail("user not returned or found or there was mistake in password change");
                return;
            }

            //get new password hash
            var renewedPassword = changed.Password;

            Assert.AreNotEqual(oldPassword, renewedPassword, "password was not changed or it was changed on same value");

        }
        [TestMethod]
        [DataRow("aaa", "aaa")]//anotator
        [DataRow("fff", "fff")]//anotator
        [DataRow("iii", "iii")]//admin
        //testing login autentication CheckUsernamePassword
        public void CheckUsernamePassword_Correct(string username, string password)
        {
            User? checkedUser = US.CheckUsernamePassword(username, password);
            if(checkedUser == null)
            {
                //there are just correct users - this should have returned user
                Assert.Fail("there are just correct users - this should have returned user");
                return;
            }
            User? expected = US.GetUserByUsername(username);
            if(expected == null)
            {
                Assert.Fail("There is mistake in tested data");
                return;
            }
            Assert.AreEqual(expected, checkedUser, "Users are not same (maybe wrong password)");
        }


        [TestMethod]
        [DataRow("aaa", "bbb")]//changedPassword?
        [DataRow("fff", "fgh")]//anotator
        [DataRow("iii", "123")]//admin
        public void CheckUsernamePassword_Incorrect(string username, string password)
        {
            User? checkedUser = US.CheckUsernamePassword(username, password);
            if (checkedUser != null)
            {
                //there are just incorrect users - this should not have returned user
                Assert.Fail("there are just incorrect users-passwords - this should not return user");
                return;
            }
        }

        [TestMethod]
        [DataRow("fff", "fff", "123")]//anotator
        [DataRow("iii", "iii", "456")]//admin
        //more complex test of the same as the above
        //passwords are changed and then there is login
        public void CheckUsernamePassword_ChangedPassword(string username, string oldPassword, string newPassword)
        {
            //get user from database
            User? oldUser = US.CheckUsernamePassword(username, oldPassword);
            if (oldUser == null) 
            {
                Assert.Fail("This should have returned user - there are wrong input data or CheckUsernamePassword isnt working properly");
                return;
            }
            //change users password
            User? changedUser = US.ChangePassword(oldUser, newPassword);
            //update database so changes are recognisable
            ctx.SaveChanges();
            if (changedUser == null)
            {
                Assert.Fail("There is mistake in another method \"ChangePassword\" test it!");
            }
            //check if new password is in place
            User? newUser = US.CheckUsernamePassword(username, newPassword);
            if(newUser == null)
            {
                Assert.Fail("No user was returned - password probably wasnt changed");
            }
            Assert.AreEqual(oldUser.Username, newUser.Username, "returned users usernames are not same");
            Assert.AreEqual(oldUser.Name, newUser.Name, "returned users names are not same");
            Assert.AreEqual(oldUser.Surname, newUser.Surname, "returned users surnames are not same");
            Assert.AreEqual(oldUser.Role, newUser.Role, "returned users roles are not same");

            //check if there is no way to login with old password
            User? oldPasswordTester = US.CheckUsernamePassword(username, oldPassword);
            if(oldPasswordTester != null)
            {
                Assert.Fail("old password is still viable after password change");
            }
        }
        [TestMethod]
        //I dont really know how to test this
        public void GetUsers_Test()
        {
            var userList = US.GetUsers();
            Assert.AreEqual(ctx.Users.Count(), userList.Users.Count, "I dont know if this is even test");
        }



        [TestMethod]
        //login from AuthService testing with correct username-password
        [DataRow("aaa", "aaa", ERole.ANNOTATOR)]//anotator
        [DataRow("fff", "fff", ERole.ANNOTATOR)]//anotator
        [DataRow("iii", "iii", ERole.ADMINISTRATOR)]//admin
        public void AuthService_Login_Correct(string username, string password, ERole role)
        {
            //creating new instance of AuthService
            var jwt = TestingJwtUtils.GetJwtUtils();
            var AS = new AuthService(US, jwt);
            //try login
            var loginResults = AS.Login(username, password);
            //check results
            Assert.IsNotNull(loginResults);
            Assert.IsTrue(loginResults.Ok);
            Assert.IsNotNull(loginResults.Token);
            DateTime exp = loginResults.Expiration;
            //expiration is in the future
            var now = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, DateTime.Now.Hour, DateTime.Now.Minute, DateTime.Now.Second);
            Assert.IsTrue(exp.CompareTo(now) > 0);//if compare is >0 -> exp is in the future
            Assert.AreEqual(role, loginResults.Role);
        }

        //login from AuthService testing with incorrect username-password
        [TestMethod]
        [DataRow("aaa", "bbb")]//changedPassword?
        [DataRow("fff", "fgh")]//anotator
        [DataRow("iii", "123")]//admin
        public void AuthService_Login_Incorrect(string username, string password)
        {
            //creating new instance of AuthService
            var jwt = TestingJwtUtils.GetJwtUtils();
            var AS = new AuthService(US, jwt);
            var loginResults = AS.Login(username, password);
            //checking if login results are null or there is false in OK and there is none obtained token
            if (loginResults != null)
            {
                Assert.IsFalse(loginResults.Ok);
                Assert.IsNull(loginResults.Token);
            }
            else
            {
                Assert.IsNull(loginResults);
            }
        }
    }
}