示例#1
0
        public async Task ShouldThrowExceptionWhenPasswordIsInvalid()
        {
            //Arrange
            Mock <SignInManager <User> > signInManager = SignInManagerMoq.Get();
            SchoolManagementContext      context       = new ContextBuilder().BuildClean();

            signInManager.Setup(x => x.CheckPasswordSignInAsync(It.IsAny <User>(), It.IsAny <string>(), It.IsAny <bool>()))
            .ReturnsAsync(SignInResult.Failed);
            User user = new User()
            {
            };

            signInManager.Setup(x => x.SignInAsync(It.IsAny <User>(), It.IsAny <bool>(), It.IsAny <string>())).Returns(Task.FromResult(user));
            Mock <UserManager <User> > userManger = UserManagerMoq.Get();

            userManger.Setup(x => x.FindByEmailAsync(It.IsAny <string>())).ReturnsAsync(user);
            signInManager.Object.UserManager = userManger.Object;

            Command cmd = new Command
            {
                Password = "******",
                Email    = "*****@*****.**"
            };
            //Act
            var result = await new Handler(signInManager.Object, context).Handle(cmd, CancellationToken.None);

            //Assert
            userManger.Verify(x => x.FindByEmailAsync(It.IsAny <string>()), Times.Once);
            signInManager.Verify(x => x.CheckPasswordSignInAsync(It.IsAny <User>(), It.IsAny <string>(), It.IsAny <bool>()), Times.Once);
            signInManager.Verify(x => x.SignInAsync(It.IsAny <User>(), It.IsAny <bool>(), It.IsAny <string>()), Times.Never);
            result.Status.Should().Be(DataResult.ResultStatus.Error);
            Assert.Equal("Błędny login lub hasło.", result.Message);
        }
        public async Task ShouldReturnErrorWhenUserHasActivatedAccount()
        {
            //Arrange
            Mock <UserManager <User> > userManagerMock = UserManagerMoq.Get();

            User user = new User()
            {
                EmailConfirmed = true
            };

            userManagerMock.Setup(x => x.FindByEmailAsync(It.IsAny <string>())).ReturnsAsync(user);
            string  tokenEncoded = HttpUtility.HtmlEncode("przykaldoweasdadsa@#+==32323232");
            Command command      = new Command
            {
                Email = "*****@*****.**",
                Token = tokenEncoded
            };


            string tokenDecoded = HttpUtility.HtmlDecode(command.Token);

            userManagerMock.Setup(x => x.ConfirmEmailAsync(user, tokenDecoded))
            .ReturnsAsync(IdentityResult.Success);
            //Act
            var result = await new Handler(userManagerMock.Object).Handle(command, CancellationToken.None);

            //Assert
            Assert.Equal(PolishReadableMessage.Account.UserHasActivatedAccountAlready, result.Message);
            result.Status.Should().Be(DataResult.ResultStatus.Error);
            userManagerMock.Verify(x => x.FindByEmailAsync(It.IsAny <String>()), Times.Once);
            userManagerMock.Verify(x => x.ConfirmEmailAsync(user, tokenDecoded), Times.Never);
        }
示例#3
0
        public async Task ShouldThrowExceptionWhenUserHasNotEmailConfirmedAccountIsNotActivated()
        {
            //Arrange
            Mock <SignInManager <User> > signInManager = SignInManagerMoq.Get();
            SchoolManagementContext      context       = new ContextBuilder().BuildClean();

            signInManager.Setup(x => x.CheckPasswordSignInAsync(It.IsAny <Model.Domain.User>(), It.IsAny <string>(), It.IsAny <bool>()))
            .ReturnsAsync(SignInResult.Success);
            Model.Domain.User user = new Model.Domain.User()
            {
                EmailConfirmed = false
            };
            signInManager.Setup(x => x.SignInAsync(It.IsAny <Model.Domain.User>(), It.IsAny <bool>(), It.IsAny <string>())).Returns(Task.FromResult(user));
            Mock <UserManager <User> > userManger = UserManagerMoq.Get();

            userManger.Setup(x => x.FindByEmailAsync(It.IsAny <string>())).ReturnsAsync(user);
            signInManager.Object.UserManager = userManger.Object;

            Command cmd = new Command
            {
                Password = "******",
                Email    = "*****@*****.**"
            };
            //Act
            var result = await new Handler(signInManager.Object, context).Handle(cmd, CancellationToken.None);

            //Assert
            userManger.Verify(x => x.FindByEmailAsync(It.IsAny <string>()), Times.Once);
            signInManager.Verify(x => x.CheckPasswordSignInAsync(It.IsAny <User>(), It.IsAny <string>(), It.IsAny <bool>()), Times.Once);
            signInManager.Verify(x => x.SignInAsync(It.IsAny <User>(), It.IsAny <bool>(), It.IsAny <string>()), Times.Never);
            result.Status.Should().Be(DataResult.ResultStatus.Error);
            Assert.Equal("Konto jest nieaktywne.", result.Message);
        }
示例#4
0
        public async Task ExecuteShouldReturnFailurePasswordMismatch()
        {
            //Arrange
            Mock <UserManager <AppUser> > userManagerMoq = UserManagerMoq.Get();
            AppUser user     = new AppUser("das");
            var     AppUsers = new List <AppUser>()
            {
                user
            }.AsQueryable().BuildMock();

            userManagerMoq.SetupGet(x => x.Users).Returns(AppUsers.Object);
            userManagerMoq.Setup(x => x.CheckPasswordAsync(It.IsAny <AppUser>(), It.IsAny <string>()))
            .ReturnsAsync(false);
            AuthenticationModel registerModel = new AuthenticationModel
            {
                UserName = "******",
                Password = "******",
            };
            //Act
            var result = await new LoginHandler(userManagerMoq.Object).Handle(registerModel, default);

            //Assert
            result.IsSuccess.Should().BeFalse("User not exist");
            result.Message.Should().NotBeNullOrEmpty().And.Be("Username or password is invalid");
            userManagerMoq.Verify(x => x.CheckPasswordAsync(It.IsAny <AppUser>(), It.IsAny <string>()), Times.Once);
            userManagerMoq.Verify(x => x.GetClaimsAsync(user), Times.Never);
        }
示例#5
0
        public async Task ExecuteShouldReturnSuccessAndClaims()
        {
            //Arrange
            Mock <UserManager <AppUser> > userManagerMoq = UserManagerMoq.Get();
            AppUser user     = new AppUser("das");
            var     AppUsers = new List <AppUser>()
            {
                user
            }.AsQueryable().BuildMock();

            userManagerMoq.SetupGet(x => x.Users).Returns(AppUsers.Object);
            userManagerMoq.Setup(x => x.CheckPasswordAsync(It.IsAny <AppUser>(), It.IsAny <string>()))
            .ReturnsAsync(true);
            userManagerMoq.Setup(x => x.GetClaimsAsync(user)).ReturnsAsync(new List <Claim>()
            {
                new Claim(ClaimTypes.Name, "Name")
            });
            AuthenticationModel registerModel = new AuthenticationModel
            {
                UserName = "******",
                Password = "******",
            };
            //Act
            var result = await new LoginHandler(userManagerMoq.Object).Handle(registerModel, default);

            //Assert
            result.IsSuccess.Should().BeTrue();
            result.Message.Should().BeNullOrEmpty();
            userManagerMoq.Verify(x => x.CheckPasswordAsync(It.IsAny <AppUser>(), It.IsAny <string>()), Times.Once);
            userManagerMoq.Verify(x => x.GetClaimsAsync(user), Times.Once);
        }
示例#6
0
        public async Task ExecuteShouldReturnFailureUserManagerFailure()
        {
            //Arrange
            Mock <UserManager <AppUser> > userManagerMoq = UserManagerMoq.Get();
            var message = "Username is taken";

            userManagerMoq.Setup(x => x.CreateAsync(It.IsAny <AppUser>(), It.IsAny <string>())).ReturnsAsync(IdentityResult.Failed(new[]
            {
                new IdentityError()
                {
                    Description = message
                }
            }));
            RegisterModel registerModel = new RegisterModel
            {
                Email      = "dsa",
                UserName   = "******",
                Password   = "******",
                RePassword = "******"
            };
            //Act
            var result = await new RegisterHandler(userManagerMoq.Object).Handle(registerModel, default);

            //Assert
            result.IsSuccess.Should().BeFalse("User is taken");
            result.Message.Should().NotBeNullOrEmpty().And.Be(message);

            userManagerMoq.Verify(x => x.CreateAsync(It.IsAny <AppUser>(), It.IsAny <string>()), Times.Once);
        }
示例#7
0
        public async Task WhenUserNotFoundShouldThrowException()
        {
            //Arrange
            Mock <UserManager <User> > userManagerMock = UserManagerMoq.Get();
            var cmd = new Command()
            {
                UserId = Guid.NewGuid().ToString()
            };
            //Act
            AssignToRoleException exception = await Assert.ThrowsAsync <AssignToRoleException>(async() =>
                                                                                               await new Handler(userManagerMock.Object).Handle(cmd, CancellationToken.None));

            //Assert
            Assert.Equal(PolishReadableMessage.Assign.UserNotFound, exception.Message);
            userManagerMock.Verify(x => x.FindByIdAsync(cmd.UserId), Times.Once);
            userManagerMock.Verify(x => x.IsInRoleAsync(It.IsAny <User>(), It.IsAny <string>()), Times.Never);
            userManagerMock.Verify(x => x.AddToRoleAsync(It.IsAny <User>(), It.IsAny <string>()), Times.Never);
        }
示例#8
0
        public async Task ShouldThrowExceptionMissingPermission(string roleName)
        {
            Mock <UserManager <User> > userManagerMock = UserManagerMoq.Get();
            ClaimsPrincipal            claimsPrincipal = new ClaimsPrincipalBuilder().Build();

            Command cmd = new Command
            {
                RoleName        = roleName,
                UserId          = Guid.NewGuid().ToString(),
                ClaimsPrincipal = claimsPrincipal
            };

            UnassignRoleException unassignRoleException = await Assert.ThrowsAsync <UnassignRoleException>(async() => await new Handler(userManagerMock.Object).Handle(cmd, CancellationToken.None));

            Assert.Equal(PolishReadableMessage.Assign.DontHavePermissionForUnassignThisRole, unassignRoleException.Message);
            userManagerMock.Verify(x => x.FindByIdAsync(It.IsAny <string>()), Times.Never);
            userManagerMock.Verify(x => x.RemoveFromRoleAsync(It.IsAny <User>(), It.IsAny <string>()), Times.Never);
        }
示例#9
0
        public async Task ShouldThrowExceptionUserNotFound()
        {
            Mock <UserManager <User> > userManagerMock = UserManagerMoq.Get();
            ClaimsPrincipal            claimsPrincipal = new ClaimsPrincipalBuilder().AddPermissionClaim(Permissions.Anchors.Remove).Build();

            userManagerMock.Setup(x => x.FindByIdAsync(It.IsAny <string>())).ReturnsAsync((User)null);
            Command cmd = new Command
            {
                RoleName        = Roles.Anchor,
                UserId          = Guid.NewGuid().ToString(),
                ClaimsPrincipal = claimsPrincipal
            };

            UnassignRoleException unassignRoleException = await Assert.ThrowsAsync <UnassignRoleException>(async() => await new Handler(userManagerMock.Object).Handle(cmd, CancellationToken.None));

            Assert.Equal(PolishReadableMessage.UserNotFound, unassignRoleException.Message);
            userManagerMock.Verify(x => x.FindByIdAsync(It.IsAny <string>()), Times.Once);
            userManagerMock.Verify(x => x.RemoveFromRoleAsync(It.IsAny <User>(), It.IsAny <string>()), Times.Never);
        }
示例#10
0
        public async Task ExecuteShouldReturnFailurePasswordMismatch()
        {
            //Arrange
            Mock <UserManager <AppUser> > userManagerMoq = UserManagerMoq.Get();
            RegisterModel registerModel = new RegisterModel
            {
                Email      = "dsa",
                UserName   = "******",
                Password   = "******",
                RePassword = "******"
            };
            //Act
            var result = await new RegisterHandler(userManagerMoq.Object).Handle(registerModel, default);

            //Assert
            result.IsSuccess.Should().BeFalse("Passwords are invalid");
            result.Message.Should().NotBeNullOrEmpty();
            userManagerMoq.Verify(x => x.CreateAsync(It.IsAny <AppUser>(), It.IsAny <string>()), Times.Never);
        }
示例#11
0
        public async Task ShouldRemoveRoleFromUser()
        {
            SchoolManagementContext    context         = new ContextBuilder().BuildClean();
            Mock <UserManager <User> > userManagerMock = UserManagerMoq.Get();
            ClaimsPrincipal            claimsPrincipal = new ClaimsPrincipalBuilder().AddPermissionClaim(Permissions.Anchors.Remove).Build();
            var user = new UserBuilder(context).WithEmail("*****@*****.**").BuildAndSave();

            userManagerMock.Setup(x => x.FindByIdAsync(It.IsAny <string>())).ReturnsAsync(user);
            Command cmd = new Command
            {
                RoleName        = Roles.Anchor,
                UserId          = Guid.NewGuid().ToString(),
                ClaimsPrincipal = claimsPrincipal
            };

            await new Handler(userManagerMock.Object).Handle(cmd, CancellationToken.None);

            userManagerMock.Verify(x => x.FindByIdAsync(It.IsAny <string>()), Times.Once);
            userManagerMock.Verify(x => x.RemoveFromRoleAsync(It.IsAny <User>(), It.IsAny <string>()), Times.Once);
        }
示例#12
0
        public async Task ShouldAssignToRole()
        {
            //Arrange
            var context = new ContextBuilder().BuildClean();
            Mock <UserManager <User> > userManagerMock = UserManagerMoq.Get();
            User user = new UserBuilder(context).WithEmail("*****@*****.**").BuildAndSave();
            var  cmd  = new Command()
            {
                UserId   = user.Id,
                RoleName = Roles.Admin
            };

            userManagerMock.Setup(x => x.FindByIdAsync(cmd.UserId)).ReturnsAsync(user);
            userManagerMock.Setup(x => x.IsInRoleAsync(user, cmd.RoleName)).ReturnsAsync(false);
            //Act
            await new Handler(userManagerMock.Object).Handle(cmd, CancellationToken.None);
            //Assert
            userManagerMock.Verify(x => x.FindByIdAsync(cmd.UserId), Times.Once);
            userManagerMock.Verify(x => x.IsInRoleAsync(It.IsAny <User>(), It.IsAny <string>()), Times.Once);
            userManagerMock.Verify(x => x.AddToRoleAsync(It.IsAny <User>(), It.IsAny <string>()), Times.Once);
        }
示例#13
0
        public async Task ExecuteShouldReturnSuccess()
        {
            //Arrange
            Mock <UserManager <AppUser> > userManagerMoq = UserManagerMoq.Get();

            userManagerMoq.Setup(x => x.CreateAsync(It.IsAny <AppUser>(), It.IsAny <string>())).ReturnsAsync(IdentityResult.Success);
            RegisterModel registerModel = new RegisterModel
            {
                Email      = "dsa",
                UserName   = "******",
                Password   = "******",
                RePassword = "******"
            };
            //Act
            var result = await new RegisterHandler(userManagerMoq.Object).Handle(registerModel, default);

            //Assert
            result.IsSuccess.Should().BeTrue();
            result.Message.Should().BeNullOrEmpty();

            userManagerMoq.Verify(x => x.CreateAsync(It.IsAny <AppUser>(), It.IsAny <string>()), Times.Once);
        }
示例#14
0
        public async Task ShouldInvoqueSigninManager()
        {
            //Arrange
            Mock <SignInManager <User> > signInManager = SignInManagerMoq.Get();
            SchoolManagementContext      context       = new ContextBuilder().BuildClean();

            signInManager.Setup(x => x.CheckPasswordSignInAsync(It.IsAny <Model.Domain.User>(), It.IsAny <string>(), It.IsAny <bool>()))
            .ReturnsAsync(SignInResult.Success);
            Model.Domain.User user = new Model.Domain.User()
            {
                EmailConfirmed = true
            };
            signInManager.Setup(x => x.SignInAsync(It.IsAny <Model.Domain.User>(), It.IsAny <bool>(), It.IsAny <string>())).Returns(Task.FromResult(user));
            signInManager.Setup(x => x.CreateUserPrincipalAsync(It.IsAny <User>())).ReturnsAsync(new ClaimsPrincipal());
            Mock <UserManager <User> > userManger = UserManagerMoq.Get();

            userManger.Setup(x => x.FindByEmailAsync(It.IsAny <string>())).ReturnsAsync(user);

            Claim adminClaim = new Claim(CustomClaimTypes.Permission, Permissions.Users.SeeAllUser);

            signInManager.Object.UserManager = userManger.Object;

            Command cmd = new Command
            {
                Password = "******",
                Email    = "*****@*****.**"
            };
            //Act
            var result = await new Handler(signInManager.Object, context).Handle(cmd, CancellationToken.None);

            //Assert
            userManger.Verify(x => x.FindByEmailAsync(It.IsAny <string>()), Times.Once);
            signInManager.Verify(x => x.CheckPasswordSignInAsync(It.IsAny <User>(), It.IsAny <string>(), It.IsAny <bool>()), Times.Once);
            signInManager.Verify(x => x.SignInAsync(It.IsAny <User>(), It.IsAny <bool>(), It.IsAny <string>()), Times.Once);
            result.Status.Should().Be(DataResult.ResultStatus.Success);
            result.Data.Should().NotBeNull();
        }
        public async Task ShouldReturnErrorWhenTokenIsInvalid()
        {
            //Arrange
            Mock <UserManager <User> > userManagerMock = UserManagerMoq.Get();

            User user = new User()
            {
                EmailConfirmed = false
            };

            userManagerMock.Setup(x => x.FindByEmailAsync(It.IsAny <string>())).ReturnsAsync(user);
            string  tokenEncoded = HttpUtility.HtmlEncode("przykaldoweasdadsa@#+==32323232");
            Command command      = new Command
            {
                Email = "*****@*****.**",
                Token = tokenEncoded
            };


            string tokenDecoded      = HttpUtility.HtmlDecode(command.Token);
            string invalidTokenError = new PolishIdentityErrorDescriber().InvalidToken().Description;

            userManagerMock.Setup(x => x.ConfirmEmailAsync(user, tokenDecoded))
            .ReturnsAsync(IdentityResult.Failed(new IdentityError()
            {
                Description = invalidTokenError
            }));
            //Act
            var result = await new Handler(userManagerMock.Object).Handle(command, CancellationToken.None);

            //Assert
            result.Status.Should().Be(DataResult.ResultStatus.Error);
            Assert.Equal(invalidTokenError, result.Message);
            userManagerMock.Verify(x => x.FindByEmailAsync(It.IsAny <String>()), Times.Once);
            userManagerMock.Verify(x => x.ConfirmEmailAsync(user, tokenDecoded), Times.Once);
        }
示例#16
0
        public async Task WhenUserIsAssignedToRoleAlreadyShouldThrowException()
        {
            //Arrange
            var context = new ContextBuilder().BuildClean();
            Mock <UserManager <User> > userManagerMock = UserManagerMoq.Get();
            User user = new UserBuilder(context).WithEmail("*****@*****.**").BuildAndSave();
            var  cmd  = new Command()
            {
                UserId   = user.Id,
                RoleName = Roles.Admin
            };

            userManagerMock.Setup(x => x.FindByIdAsync(cmd.UserId)).ReturnsAsync(user);
            userManagerMock.Setup(x => x.IsInRoleAsync(user, cmd.RoleName)).ReturnsAsync(true);
            //Act
            AssignToRoleException exception = await Assert.ThrowsAsync <AssignToRoleException>(async() =>
                                                                                               await new Handler(userManagerMock.Object).Handle(cmd, CancellationToken.None));

            //Assert
            Assert.Equal(PolishReadableMessage.Assign.UserIsAssignedToRoleAlready, exception.Message);
            userManagerMock.Verify(x => x.FindByIdAsync(cmd.UserId), Times.Once);
            userManagerMock.Verify(x => x.IsInRoleAsync(It.IsAny <User>(), It.IsAny <string>()), Times.Once);
            userManagerMock.Verify(x => x.AddToRoleAsync(It.IsAny <User>(), It.IsAny <string>()), Times.Never);
        }