Ejemplo n.º 1
0
        public async Task HandleAsync_FalhaValidationProxy()
        {
            var mockUnitOfWork         = DemarcacaoUnitOfWorkMock.GetMock();
            var mockEmpreendimentoRepo = EmpreendimentoRepositoryMock.GetMock();

            mockUnitOfWork.Setup(o => o.SaveChangesAsync(It.IsAny <CancellationToken>()))
            .ReturnsAsync(1);

            mockEmpreendimentoRepo.Setup(o => o.AddAsync(It.IsAny <Empreendimento>(), It.IsAny <CancellationToken>()));

            IList <ValidationFailure> validationFailures = new List <ValidationFailure>();

            var strategy = (IStrategy <CadastraEmpreendimentoRequest, DefaultResponse>)
                           new ProxyFake().CreateProxyValidatorFake <CadastraEmpreendimentoRequest, DefaultResponse>(
                new CadastraEmpreendimentoStrategy(AutomapperMock.GetProfilesMapper(),
                                                   mockUnitOfWork.Object,
                                                   mockEmpreendimentoRepo.Object), validationFailures);

            var request = new EmpreendimentoRequestFake().GetCadastraEmpreendimentoRequest_Valido();

            request.Descricao = "";
            var response = await strategy.HandleAsync(request, CancellationToken.None);

            Assert.False(response.IsNotDefault);
            Assert.Contains(validationFailures, o => o.ErrorMessage == "Os seguintes campos obrigatórios não foram informados: Descricao");
        }
Ejemplo n.º 2
0
        public async Task HandleAsync_Sucesso()
        {
            var mockUnitOfWork         = DemarcacaoUnitOfWorkMock.GetMock();
            var mockEmpreendimentoRepo = EmpreendimentoRepositoryMock.GetMock();

            mockUnitOfWork.Setup(o => o.SaveChangesAsync(It.IsAny <CancellationToken>()))
            .ReturnsAsync(1);

            mockEmpreendimentoRepo.Setup(o => o.Any(It.IsAny <Expression <Func <Empreendimento, bool> > >()))
            .Returns(true);

            mockEmpreendimentoRepo.Setup(o => o.Update(It.IsAny <Empreendimento>()));

            var strategy = new AtualizaEmpreendimentoStrategy(AutomapperMock.GetProfilesMapper(),
                                                              mockUnitOfWork.Object,
                                                              mockEmpreendimentoRepo.Object);

            var request = new EmpreendimentoRequestFake().GetAtualizaEmpreendimentoRequest_Valido();

            var response = await strategy.HandleAsync(request,
                                                      CancellationToken.None);

            Assert.IsType <DefaultResponse>(response);
            Assert.True(response.IsNotDefault);
        }
        public void AtualizaEmpreendimentoRequestValidator_Valido()
        {
            var validator = new AtualizaEmpreendimentoRequestValidator();
            var request   = new EmpreendimentoRequestFake().GetAtualizaEmpreendimentoRequest_Valido();
            var validate  = validator.Validate(request);

            Assert.True(validate.IsValid);
            Assert.False(validator.CamposObrigatorios.Any());
        }
        public void AtualizaEmpreendimentoRequestValidator_InvalidoIdEmpreendimento()
        {
            var validator = new AtualizaEmpreendimentoRequestValidator();
            var request   = new EmpreendimentoRequestFake().GetAtualizaEmpreendimentoRequest_Valido();

            request.IdEmpreendimento = 0;
            var validate = validator.Validate(request);

            Assert.False(validate.IsValid);
            Assert.Contains(validator.CamposObrigatorios, o => o == "IdEmpreendimento");
        }
        public void AtualizaEmpreendimentoRequestValidator_InvalidoEnderecoLogradouro()
        {
            var validator = new AtualizaEmpreendimentoRequestValidator();
            var request   = new EmpreendimentoRequestFake().GetAtualizaEmpreendimentoRequest_Valido();

            request.Endereco.Logradouro = "";
            var validate = validator.Validate(request);

            Assert.False(validate.IsValid);
            Assert.Contains(validator.CamposObrigatorios, o => o == "Endereco.Logradouro");
        }
        public void CadastraEmpreendimentoRequestValidator_InvalidoDescricao()
        {
            var validator = new EmpreendimentoRequestValidator <CadastraEmpreendimentoRequest>();
            var request   = new EmpreendimentoRequestFake().GetCadastraEmpreendimentoRequest_Valido();

            request.Descricao = "";
            var validate = validator.Validate(request);

            Assert.False(validate.IsValid);
            Assert.Contains(validator.CamposObrigatorios, o => o == "Descricao");
        }
        public async Task HandleAsync_FalhaValidationProxy()
        {
            var mockEmpreendimentoRepo = EmpreendimentoRepositoryMock.GetMock();

            IList <ValidationFailure> validationFailures = new List <ValidationFailure>();

            var strategy = (IStrategy <RetornaEmpreendimentoQuery, RetornarEmpreendimentoQueryResponse>)
                           new ProxyFake().CreateProxyValidatorFake <RetornaEmpreendimentoQuery, RetornarEmpreendimentoQueryResponse>(
                new RetornaEmpreendimentoStrategy(AutomapperMock.GetProfilesMapper(),
                                                  mockEmpreendimentoRepo.Object), validationFailures);

            var request = new EmpreendimentoRequestFake().GetRetornaEmpreendimentoQuery_Invalido();
            await strategy.HandleAsync(request, CancellationToken.None);

            Assert.Contains(validationFailures, o => o.ErrorMessage == "O campo \"idEmpreendimento\" não foi informado.");
        }
        public async Task HandleAsync_SucessoVazio()
        {
            var mockEmpreendimentoRepo = EmpreendimentoRepositoryMock.GetMock();

            mockEmpreendimentoRepo.Setup(o => o.GetAsync(It.IsAny <long>(), It.IsAny <CancellationToken>()))
            .ReturnsAsync(default(Empreendimento));

            var strategy = new RetornaEmpreendimentoStrategy(AutomapperMock.GetProfilesMapper(),
                                                             mockEmpreendimentoRepo.Object);

            var query = new EmpreendimentoRequestFake().GetRetornaEmpreendimentoQuery_Valido();

            var response = await strategy.HandleAsync(query, CancellationToken.None);

            Assert.Null(response);
        }