public async Task Handle_UserDoesExist_CreateLogin(
            Mock <UserManager <ApplicationUser> > userManagerMock,
            CreateLoginCommandHandler sut,
            CreateLoginCommand command
            )
        {
            //Arrange

            //Act
            await sut.Handle(command, CancellationToken.None);

            //Assert
            userManagerMock.Verify(_ => _.CreateAsync(
                                       It.IsAny <ApplicationUser>(),
                                       It.IsAny <string>()
                                       ),
                                   Times.Never()
                                   );

            userManagerMock.Verify(_ => _.AddClaimsAsync(
                                       It.IsAny <ApplicationUser>(),
                                       It.IsAny <IEnumerable <Claim> >()
                                       ),
                                   Times.Never()
                                   );
        }
        public async Task Handle_UserDoesNotExist_CreateUserSucceeds_CreateLoginAndClaims(
            [Frozen] Mock <UserManager <ApplicationUser> > userManagerMock,
            Mock <ILogger <CreateLoginCommandHandler> > loggerMock,
            Mock <IConfiguration> configurationMock,
            CreateLoginCommand command,
            ApplicationUser?applicationUser
            )
        {
            //Arrange
            applicationUser = null;
            userManagerMock.Setup(_ => _.FindByNameAsync(
                                      It.IsAny <string>()
                                      )
                                  )
            .ReturnsAsync(applicationUser !);

            userManagerMock.Setup(_ => _.CreateAsync(
                                      It.IsAny <ApplicationUser>(),
                                      It.IsAny <string>()
                                      )
                                  )
            .ReturnsAsync(IdentityResult.Success);

            userManagerMock.Setup(_ => _.AddClaimsAsync(
                                      It.IsAny <ApplicationUser>(),
                                      It.IsAny <IEnumerable <Claim> >()
                                      )
                                  )
            .ReturnsAsync(IdentityResult.Success);

            var sut = new CreateLoginCommandHandler(
                loggerMock.Object,
                userManagerMock.Object,
                configurationMock.Object
                );

            //Act
            await sut.Handle(command, CancellationToken.None);

            //Assert

            userManagerMock.Verify(_ => _.CreateAsync(
                                       It.IsAny <ApplicationUser>(),
                                       It.IsAny <string>()
                                       ),
                                   Times.Once()
                                   );

            userManagerMock.Verify(_ => _.AddClaimsAsync(
                                       It.IsAny <ApplicationUser>(),
                                       It.IsAny <IEnumerable <Claim> >()
                                       ),
                                   Times.Once()
                                   );
        }
예제 #3
0
        public RetornoGlobal <UsuariosModel> postLogin(CreateLoginCommand login)
        {
            RetornoGlobal <UsuariosModel> retorno = new RetornoGlobal <UsuariosModel>();

            try
            {
                CreateLoginValidator validator = new CreateLoginValidator(contexto);

                ValidationResult result = validator.Validate(login);
                if (result.IsValid)
                {
                    UsuariosModel model = new UsuariosModel();
                    model.Login           = login.Login;
                    model.Senha           = login.Senha;
                    model.UsuarioAcessoId = login.UsuarioAcessoId;

                    contexto.TabelaUsuarios.Add(model);
                    contexto.SaveChanges();

                    retorno.status        = true;
                    retorno.RetornoObjeto = model;
                }
                else
                {
                    retorno.status = false;
                    result.Errors.ToList().ForEach(r =>
                                                   retorno.errors.Add(r.ToString())
                                                   );
                }
            }
            catch (Exception e)
            {
                retorno.errors.Append(e.Message);
                retorno.errors.Append(e.InnerException.ToString());
                retorno.status = false;
            }
            return(retorno);
        }