Esempio n. 1
0
        public void TestCriarVendaComItem()
        {
            var vendaModel = new VendaModel
            {
                Cliente          = new ClienteModel(int.MinValue, "Cliente"),
                FormaDePagamento = DINHEIRO,
                Itens            = new List <VendaItemModel> {
                    new VendaItemModel {
                        Descricao                = "Produto1",
                        QuantidadeComprada       = 10,
                        QuantidadePromocional    = 10,
                        ValorUnitario            = 10,
                        ValorUnitarioPromocional = 10
                    },
                    new VendaItemModel {
                        Descricao                = "Produto2",
                        QuantidadeComprada       = 20,
                        QuantidadePromocional    = 20,
                        ValorUnitario            = 20,
                        ValorUnitarioPromocional = 20
                    }
                }
            };
            IMapper             mapper             = PegarMapper();
            IVendaEntityFactory vendaEntityFactory = new VendaEntityFactory(mapper);

            VendaEntity venda = vendaEntityFactory.Criar(vendaModel);

            Assert.Equal(2, venda.Itens.Count());
        }
Esempio n. 2
0
 private void AdicionarItens(VendaEntity venda, VendaDTO vendaDTO)
 {
     if (vendaDTO.Itens == null)
     {
         return;
     }
     foreach (var item in vendaDTO.Itens)
     {
         var vendaItem = new VendaItemEntity(item, new CalculadoraPrecoVendaItem());
         venda.AdicionarVendaItem(vendaItem);
     }
 }
Esempio n. 3
0
        public void TestConversaoFormaPagamento()
        {
            IVendaEntityFactory vendaEntityFactory = PegarVendaEntityFactory();
            var vendaModel = new VendaModel();

            vendaModel.Cliente          = new ClienteModel(int.MinValue, string.Empty);
            vendaModel.FormaDePagamento = DINHEIRO;

            VendaEntity venda = vendaEntityFactory.Criar(vendaModel);

            Assert.Equal(FormaDePagamento.Dinheiro, venda.FormaDePagamento);
        }
Esempio n. 4
0
        public bool ProcessarVenda(VendaModel vendaModel)
        {
            VendaEntity venda = _vendaFactory.Criar(vendaModel);

            var executouComSucesso = _salvarVendaService.Executar(venda);

            if (!executouComSucesso)
            {
                CarregarErrosDe(_salvarVendaService);
            }

            return(executouComSucesso);
        }
Esempio n. 5
0
        public void TestCriarFabrica()
        {
            IMapper             mapper             = PegarMapper();
            IVendaEntityFactory vendaEntityFactory = new VendaEntityFactory(mapper);
            var vendaModel = new VendaModel();

            vendaModel.Cliente = new ClienteModel(int.MinValue, string.Empty);

            VendaEntity venda = vendaEntityFactory.Criar(vendaModel);

            Assert.NotNull(venda);
            Assert.IsAssignableFrom <VendaEntity>(venda);
        }
Esempio n. 6
0
        public void TestVendaNaoEhValidaSemProdutos()
        {
            VendaDTO vendaDTO = new VendaDTO
            {
                Cliente          = new ClienteDTO("Cliente"),
                FormaDePagamento = FormaDePagamento.Dinheiro
            };

            VendaEntity venda = VendaFactory(vendaDTO);

            bool vendaEhValida = venda.Validar();

            Assert.False(vendaEhValida);
        }
Esempio n. 7
0
        private VendaEntity VendaFactory(VendaDTO vendaDTO)
        {
            var venda = new VendaEntity(vendaDTO.Cliente, vendaDTO.FormaDePagamento);

            if (vendaDTO.Itens == null)
            {
                return(venda);
            }
            foreach (var item in vendaDTO.Itens)
            {
                var vendaItem = new VendaItemEntity(item, new CalculadoraPrecoVendaItem());
                venda.AdicionarVendaItem(vendaItem);
            }
            return(venda);
        }
Esempio n. 8
0
        public static bool MergeFrom(this VendaEntity vendaEntity, VendaEntity vendaNew, out string msg)
        {
            msg = String.Empty;

            if (vendaEntity != null && TryValidStatus(vendaNew.Status, vendaEntity.Status))
            {
                vendaEntity.Status = vendaEntity.Status;
                return(true);
            }
            else
            {
                msg = "Venda com status inválida ou nula";
                return(false);
            }
        }
Esempio n. 9
0
        public void TestVendaNaoEhValidaComFormaDePagamentoIndefinida()
        {
            VendaDTO vendaDTO = new VendaDTO
            {
                Cliente          = new ClienteDTO("Cliente"),
                FormaDePagamento = FormaDePagamento.None,
                Itens            = new List <VendaItemDTO> {
                    VendaItemDTOFactory("Descricao", 1, 1)
                }
            };
            VendaEntity venda = VendaFactory(vendaDTO);

            var vendaEhValida = venda.Validar();

            Assert.False(vendaEhValida);
        }
Esempio n. 10
0
        public void TestVendaEhValidaComUmProdutoAoMenos()
        {
            var vendaDTO = new VendaDTO
            {
                Cliente          = new ClienteDTO("Cliente"),
                FormaDePagamento = FormaDePagamento.Dinheiro,
                Itens            = new List <VendaItemDTO> {
                    VendaItemDTOFactory("Produto1", 1, 1)
                }
            };
            VendaEntity venda = VendaFactory(vendaDTO);

            bool vendaEhValida = venda.Validar();

            Assert.True(vendaEhValida);
        }
Esempio n. 11
0
        public void TestExecutarServicoComSucesso()
        {
            var vendaMock = new Mock <VendaEntity>();

            vendaMock.SetReturnsDefault <bool>(true);
            VendaEntity venda = vendaMock.Object;

            var vendaRepositoryMock = new Mock <IVendaRepository>();

            vendaRepositoryMock.SetReturnsDefault <bool>(true);
            IVendaRepository vendaRepository = vendaRepositoryMock.Object;

            ISalvarVendaService salvarVendaService = new SalvarVendaService(vendaRepository);
            bool executadoComSucesso = salvarVendaService.Executar(venda);

            Assert.True(executadoComSucesso);
        }
Esempio n. 12
0
        public void TestExecutaComSucessoQuandoRepositorioNaoGrava()
        {
            var mockVenda = new Mock <VendaEntity>();

            mockVenda.SetReturnsDefault <bool>(true);
            VendaEntity venda = mockVenda.Object;

            var vendaRepositoryMock = new Mock <IVendaRepository>();

            vendaRepositoryMock.SetReturnsDefault <bool>(false);
            IVendaRepository vendaRepository = vendaRepositoryMock.Object;

            ISalvarVendaService salvarVendaService = new SalvarVendaService(vendaRepository);
            bool executadoComSucesso = salvarVendaService.Executar(venda);

            Assert.False(executadoComSucesso);
        }
Esempio n. 13
0
        public bool Executar(VendaEntity venda)
        {
            if (!venda.Validar())
            {
                RegistrarErro(new MensagemErro("A venda está invalida!"));
                return(false);
            }

            bool salvouVenda = _vendaRepository.Salvar(venda);

            if (!salvouVenda)
            {
                RegistrarErro(new MensagemErro("Não foi possível salvar a venda"));
            }

            return(salvouVenda);
        }
Esempio n. 14
0
        public void TestVendaNaoEhValidaComTotalMenorIgualZero()
        {
            VendaDTO vendaDTO = new VendaDTO
            {
                Cliente          = new ClienteDTO("Cliente"),
                FormaDePagamento = FormaDePagamento.Dinheiro,
                Itens            = new List <VendaItemDTO> {
                    VendaItemDTOFactory("Produto", 0, 1)
                }
            };
            VendaEntity venda = VendaFactory(vendaDTO);

            bool    vendaEhValida = venda.Validar();
            decimal totalVendido  = venda.TotalVenda();

            Assert.False(vendaEhValida);
            Assert.Equal(0, totalVendido);
        }
Esempio n. 15
0
        public void TestServicoPossuiMensagemDeErroAoTentarSalvarVendaInvalida()
        {
            var mensagemDeRetornoEsperada = "A venda está invalida!";

            var vendaMock = new Mock <VendaEntity>();

            vendaMock.SetReturnsDefault <bool>(false);
            VendaEntity venda = vendaMock.Object;

            var vendaRepositoryMock = new Mock <IVendaRepository>();

            vendaRepositoryMock.SetReturnsDefault <bool>(true);
            IVendaRepository vendaRepository = vendaRepositoryMock.Object;

            ISalvarVendaService salvarVendaService = new SalvarVendaService(vendaRepository);

            salvarVendaService.Executar(venda);
            var mensagemErro = salvarVendaService.PegarMensagensErro().First();

            Assert.Equal(mensagemDeRetornoEsperada, mensagemErro.Mensagem);
        }
Esempio n. 16
0
        public void TestCapturaErrosDeVendaItem()
        {
            var vendaItemErros = new List <ValidationResult> {
                new ValidationResult("Erro no Item de venda")
            };
            var vendaItemMock = new Mock <VendaItemEntity>(MockBehavior.Strict);

            vendaItemMock
            .Setup(vi => vi.Validate())
            .Returns(vendaItemErros);
            vendaItemMock
            .Setup(vi => vi.ValorTotal(It.IsAny <FormaDePagamento>()))
            .Returns(10);
            VendaEntity venda = new VendaEntity(new ClienteDTO("Cliente"), FormaDePagamento.Dinheiro);

            venda.AdicionarVendaItem(vendaItemMock.Object);

            var listaErrosEncontrados = venda.Validate();

            Assert.Equal(vendaItemErros, listaErrosEncontrados);
        }
Esempio n. 17
0
        public void TestServicoPossuiMensagemDeErroQuandoRepositorioNaoSalva()
        {
            var mensagemDeRetornoEsperada = "Não foi possível salvar a venda";

            var vendaMock = new Mock <VendaEntity>();

            vendaMock.SetReturnsDefault <bool>(true);
            VendaEntity venda = vendaMock.Object;

            var vendaRepositoryMock = new Mock <IVendaRepository>();

            vendaRepositoryMock.SetReturnsDefault <bool>(false);
            IVendaRepository vendaRepository = vendaRepositoryMock.Object;

            ISalvarVendaService salvarVendaService = new SalvarVendaService(vendaRepository);

            salvarVendaService.Executar(venda);
            var mensagemErro = salvarVendaService.PegarMensagensErro().First();

            Assert.Equal(mensagemDeRetornoEsperada, mensagemErro.Mensagem);
        }
Esempio n. 18
0
        public void TestCriarVendaComFormaDePagamento(FormaDePagamento formaDePagamento)
        {
            var cliente  = new ClienteDTO("Cliente");
            var vendaDTO = new VendaDTO()
            {
                Cliente          = cliente,
                FormaDePagamento = formaDePagamento,
                Itens            = new List <VendaItemDTO>()
            };

            VendaEntity venda = new VendaEntity(vendaDTO.Cliente, vendaDTO.FormaDePagamento);

            foreach (var item in vendaDTO.Itens)
            {
                var vendaItem = new VendaItemEntity(item, new CalculadoraPrecoVendaItem());
                venda.AdicionarVendaItem(vendaItem);
            }

            ClienteDTO clienteRetornado = venda.Cliente;

            Assert.Equal(formaDePagamento, venda.FormaDePagamento);
            Assert.Equal(cliente, clienteRetornado);
        }
Esempio n. 19
0
 public bool Salvar(VendaEntity venda)
 {
     return(true);
 }