public async Task Post_Register_Should_Return_Ok_TokenModel()
        {
            //Arrange
            var registerUser = new RegisterUserModel
            {
                Login = "******",
                Email = "*****@*****.**",
                Password = "******",
                Id = 0
            };

            var incomingUser = new IncomingUser
            {
                Name = "Cat-Ok",
                Email = "*****@*****.**",
                Password = "******",
                Token = "asdf",
                Id = 1
            };

            var user = new User
            {
                Name = "Roman Hapatyn",
                Email = "*****@*****.**",
                Password = "******",
                HashedToken = "asdf",
                Id = 1
            };

            TokenModel token = new TokenModel();
            token.RolesToken = "Student";

            //Action
            
            GenerateData("1", new[] { "NoRoles" });
            RegisterController registerController = new RegisterController(userService.Object,
                tokenValidation.Object,
                incUserMapper.Object,
                mesService.Object);
            var tokenModel = new TokenModel();
            string locationUrl = "http://location/";

            var message = new IdentityMessage
                {
                    Body = "Please confirm your account at: www.xxx.xxx ",
                    Destination = "*****@*****.**",
                    Subject = "Confirm your registration"
                };

            urlHelper.Setup(x => x.Link(It.IsAny<string>(), It.IsAny<object>()))
                .Returns(locationUrl);
            registerController.Url = urlHelper.Object;

            mesService
                .Setup(x => x.SendAsync(message))
                .Returns(Task.FromResult(0));

            incUserMapper
                .Setup(x => x.ToIncomingUser(registerUser))
                .Returns(incomingUser);

            userMapper
                .Setup(x => x.Map(registerUser))
                .Returns(user);

            userService
                .Setup(x => x.Exists(incomingUser))
                .Returns(false);

            tokenValidation
                .Setup(x => x.GetHashSha256("asdf"))
                .Returns("fdsa");

            var actual = await registerController.Post(registerUser) as OkNegotiatedContentResult<TokenModel>;
            var contentResult = actual as OkNegotiatedContentResult<TokenModel>;
            //Assert
            Assert.IsNotNull(actual);
            Assert.AreEqual(actual.Content.GetType(), tokenModel.GetType());
        }
        public async Task Post_ForgotPassword_Should_Return_Ok_TokenModel()                                               
        {
            //Arrange
            var forgotPasswordUser = new ForgotPasswordUserModel
            {
                Email = "*****@*****.**",
                Id = "1",
                Password = "******"
            };

            var message = new IdentityMessage
            {
                Body = "Reset pasword at test.com",
                Destination = "*****@*****.**",
                Subject = "Password reset"
            };

            //Action
            GenerateData("1", new[] { "NoRoles" });
            RegisterController registerController = new RegisterController(userService.Object,
                tokenValidation.Object,
                incUserMapper.Object,
                mesService.Object);
            var tokenModel = new TokenModel();
            string locationUrl = "http://location/";

            urlHelper.Setup(x => x.Link(It.IsAny<string>(), It.IsAny<object>()))
                .Returns(locationUrl);
            registerController.Url = urlHelper.Object;

            mesService
                .Setup(x => x.SendAsync(message))
                .Returns(Task.FromResult(0));

            userService.Setup(x => x.CheckUserEmail(forgotPasswordUser))
                .Returns(true);
           
            tokenValidation.Setup(x => x.GetHashSha256("asdf"))
                .Returns("fdsa");
                
            var actual = await registerController.ForgotPassword(forgotPasswordUser) as OkNegotiatedContentResult<TokenModel>;
            var contentResult = actual as OkNegotiatedContentResult<TokenModel>;

            //Assert
            Assert.IsNotNull(actual);
            Assert.AreEqual(actual.Content.GetType(), tokenModel.GetType());
        }
        public void Get_ConfirmEmail_Should_Return_BadRequest_ModelState()
        {
            //Action
            GenerateData("1", new[] { "NoRoles" });
            RegisterController registerController = new RegisterController(userService.Object,
                tokenValidation.Object,
                incUserMapper.Object,
                mesService.Object);

            //Arrange
            int userId = 0;
            string code = "";

            Assert.AreEqual(userId, 0);
            Assert.AreEqual(code, "");

            var actual = registerController.ConfirmEmail(userId, code);
            var badRequestResult = new BadRequestResult(registerController);
            InvalidModelStateResult invalidModel = new InvalidModelStateResult(registerController.ModelState, registerController);
            //Assert
            Assert.IsNotNull(actual);
            Assert.AreEqual(actual.GetType(), invalidModel.GetType());
        }
        public void Get_ConfirmEmail_Should_Return_BadRequest()
        {
            //Action
            GenerateData("1", new[] { "NoRoles" });
            RegisterController registerController = new RegisterController(userService.Object,
                tokenValidation.Object,
                incUserMapper.Object,
                mesService.Object);

            //Arrange
            int userId = 1;
            string code = "test";

            var actual = registerController.ConfirmEmail(userId, code);
            var badRequestResult = new BadRequestErrorMessageResult("Invalid data", registerController);
            //Assert
            Assert.IsNotNull(actual);
            Assert.AreEqual(actual.GetType(), badRequestResult.GetType());
        }
        public void Get_ConfirmEmail_Should_Return_Ok()
        {
            //Action
            GenerateData("1", new[] { "NoRoles" });
            RegisterController registerController = new RegisterController(userService.Object,
                tokenValidation.Object,
                incUserMapper.Object,
                mesService.Object);

            int userId = 1;
            string code = "test";

            userService.Setup(x => x.ConfirmUserRegistration(userId, code))
                .Returns(true);

            var actual = registerController.ConfirmEmail(userId, code);

            //Assert
            Assert.IsNotNull(actual);
            Assert.IsInstanceOf(typeof(OkResult), actual);
        }