Exemplo n.º 1
0
        public void Devo_Conseguir_Remover_Um_Item()
        {
            Servico servico1 = ServicoStub.GetInstance(1, "serviço 1", 1);
            Servico servico2 = ServicoStub.GetInstance(2, "serviço 2", 2);

            Atendimento atendimento = new Atendimento(DateTime.Now, this._empresaValida, this._clienteValido, this._fpagtoValida);

            atendimento.AdicionarItem(servico1, 1m, 1);
            atendimento.AdicionarItem(servico2, 2m, 2);

            // Primeiro verifico se foram adicionados mesmo os dois itens
            Assert.AreEqual(2, atendimento.Itens.Count());

            atendimento.RemoverItem(servico1);

            // Depois verifico se ficou apenas um item
            Assert.AreEqual(1, atendimento.Itens.Count());

            // Verifico se item é o serviço dois, pois eu tirei o serviço 1
            foreach (ItemAtendimento i in atendimento.Itens)
            {
                Assert.AreEqual(2, i.Servico.Id);
                Assert.AreEqual(2m, i.ValorUnitario);
                Assert.AreEqual(2, i.Quantidade);
            }

            // Removo o serviço e verifico se não ficou nenhum item
            atendimento.RemoverItem(servico2);

            Assert.AreEqual(0, atendimento.Itens.Count());
        }
Exemplo n.º 2
0
        public void Devo_Conseguir_Validar_Um_Servico_Em_Alteracao_Caso_Nao_Seja_Encontrado_Nenhum_Servico_Com_A_Mesma_Descricao_Que_Ele()
        {
            Servico servicoEmAlteracao = ServicoStub.GetInstance(1, "escova", 1m);

            ValidadorServico validador = new ValidadorServico(null);

            validador.ValidarServicoEmAlteracao(servicoEmAlteracao);
        }
Exemplo n.º 3
0
        public void Nao_Devo_Conseguir_Validar_Um_Atendimento_Com_Valor_Zerado()
        {
            Atendimento atendimento = new Atendimento(DateTime.Now, this._empresaValida, this._clienteValido, this._fpagtoValida);

            atendimento.AdicionarItem(ServicoStub.GetInstance(1, "TESTE", 1), 1, 1);
            atendimento.Desconto = 15;
            atendimento.Validar();
        }
Exemplo n.º 4
0
        public void Devo_Conseguir_Validar_Um_Servico_Em_Alteracao_Que_Tenha_A_Mesma_Descricao_Que_Tinha_Antes_Da_Alteracao()
        {
            Servico servicoEmAlteracao = ServicoStub.GetInstance(1, "escova", 1m);
            Servico servicoCadastrado  = ServicoStub.GetInstance(1, "ESCOVA", 2m);

            ValidadorServico validador = new ValidadorServico(servicoCadastrado);

            validador.ValidarServicoEmAlteracao(servicoEmAlteracao);
        }
Exemplo n.º 5
0
        public void Nao_Devo_Conseguir_Validador_Um_Servico_Em_Alteracao_Com_Descricao_Igual_De_Outro_Servico_Cadastrado()
        {
            Servico          servicoEmAlteracao = ServicoStub.GetInstance(1, "escova", 1m);
            Servico          servicoCadastrado  = ServicoStub.GetInstance(2, "ESCOVA", 2m);
            ValidadorServico validador;

            try
            {
                validador = new ValidadorServico(servicoCadastrado);
                validador.ValidarServicoEmAlteracao(servicoEmAlteracao);
            }
            catch (ExcecaoDescricaoServicoJaCadastrada)
            {
                servicoEmAlteracao.Descricao = "  ESCoVA";
                validador = new ValidadorServico(servicoCadastrado);
                validador.ValidarServicoEmAlteracao(servicoEmAlteracao);
            }
        }
Exemplo n.º 6
0
        public void Nao_Devo_Validar_Um_Novo_Servico_Com_Descricao_De_Outro_Servico_Cadastrado()
        {
            Servico          novoServico       = new Servico("ESCOVA", 1m);
            Servico          servicoCadastrado = ServicoStub.GetInstance(1, "escova", 2m);
            ValidadorServico validador;

            try
            {
                validador = new ValidadorServico(servicoCadastrado);
                validador.ValidarNovoServico(novoServico);
            }
            catch (ExcecaoDescricaoServicoJaCadastrada)
            {
                novoServico = new Servico("escOvA  ", 1m);
                validador   = new ValidadorServico(servicoCadastrado);
                validador.ValidarNovoServico(novoServico);
            }
        }
Exemplo n.º 7
0
        public void Ao_Adicionar_Um_Item_Ja_Adicionado_Deve_Substituir_O_Existente()
        {
            Servico servico1 = ServicoStub.GetInstance(1, "serviço 1", 1);
            Servico servico2 = ServicoStub.GetInstance(2, "serviço 2", 2);

            Atendimento atendimento = new Atendimento(DateTime.Now, this._empresaValida, this._clienteValido, this._fpagtoValida);

            atendimento.AdicionarItem(servico1, 10.50m, 3);
            atendimento.AdicionarItem(servico2, 22m, 7);
            atendimento.AdicionarItem(servico1, 11m, 4);

            foreach (ItemAtendimento i in atendimento.Itens)
            {
                Assert.AreEqual(11m, i.ValorUnitario);
                Assert.AreEqual(4, i.Quantidade);
                break;
            }
        }
Exemplo n.º 8
0
        public void Devo_Conseguir_Remover_Um_Item()
        {
            Servico servico1 = ServicoStub.GetInstance(1, "SERVIÇO 1", 1);
            Servico servico2 = ServicoStub.GetInstance(2, "SERVIÇO 2", 2);

            var repositorioServico = new Mock <IServicoRepositorio>();

            repositorioServico.Setup(r => r.Obter(1))
            .Returns(servico1);

            DTOItem dto = new DTOItem();

            dto.IdServico     = 1;
            dto.ValorUnitario = 15.23m;
            dto.Quantidade    = 1;

            DTOItem dto2 = new DTOItem();

            dto2.IdServico     = 2;
            dto2.ValorUnitario = 15;
            dto2.Quantidade    = 12;

            IFachadaAtendimento fachada = new FachadaAtendimento(null, this._repositorioPessoa, this._repositorioFormaPagamento, repositorioServico.Object);

            fachada.CriaNovoAtendimento(this._dtoCabecalho);
            fachada.AdicionarItem(dto);

            repositorioServico.Setup(r => r.Obter(2)).Returns(servico2);
            fachada.AdicionarItem(dto2);

            fachada.RemoverItem(dto);

            repositorioServico.Verify(r => r.Obter(1));

            // Foi removido esse assert porque o Equals
            Assert.AreEqual(1, fachada.ObterValoresAtendimento().NumeroItens);
        }
Exemplo n.º 9
0
        public void Devo_Conseguir_Obter_Totais()
        {
            var fpagto = new Mock <FormaPagamento>();

            fpagto.Setup(f => f.Id).Returns(1);
            fpagto.Setup(f => f.PercentualAcrescimo).Returns(10);
            fpagto.Setup(f => f.PercentualDesconto).Returns(20);

            Servico servico1 = ServicoStub.GetInstance(1, "serviço 1", 1);
            Servico servico2 = ServicoStub.GetInstance(2, "serviço 2", 2);
            Servico servico3 = ServicoStub.GetInstance(3, "serviço 3", 2);
            Servico servico4 = ServicoStub.GetInstance(4, "serviço 4", 2);
            Servico servico5 = ServicoStub.GetInstance(5, "serviço 5", 2);

            Atendimento atendimento = new Atendimento(DateTime.Now, this._empresaValida, this._clienteValido, fpagto.Object);

            atendimento.AdicionarItem(servico1, 10m, 3);  // 30
            atendimento.AdicionarItem(servico2, 22m, 7);  // 184
            atendimento.AdicionarItem(servico3, 23m, 12); // 460
            atendimento.AdicionarItem(servico4, 2m, 8);   // 476
            atendimento.AdicionarItem(servico5, 7m, 2);   // 490 49 98 441
            atendimento.Acrescimo = 132;                  // 552
            atendimento.Desconto  = 142;                  // 510 431

            // NumeroTotalItens = 6, TotalValorUnitario = 64, TotalQuantidade = 32, TotalValorItem = 2048

            Assert.AreEqual(5, atendimento.NumeroTotalItens);
            Assert.AreEqual(64, atendimento.TotalValorUnitario);
            Assert.AreEqual(32, atendimento.TotalQuantidade);
            Assert.AreEqual(490, atendimento.TotalValorItem);
            Assert.AreEqual(132, atendimento.Acrescimo);
            Assert.AreEqual(142, atendimento.Desconto);
            Assert.AreEqual(49m, atendimento.AcrescimoFormaPagamento);
            Assert.AreEqual(98, atendimento.DescontoFormaPagamento);
            Assert.AreEqual(431, atendimento.ValorAtendimento);
        }
Exemplo n.º 10
0
        public void Devo_Conseguir_Retornar_Os_Valores_Do_Atendimento()
        {
            var repositorioServico = new Mock <IServicoRepositorio>();
            var formaPagamento     = new Mock <FormaPagamento>();

            formaPagamento.Setup(f => f.Id).Returns(1);
            formaPagamento.Setup(f => f.PercentualAcrescimo).Returns(10);
            formaPagamento.Setup(f => f.PercentualDesconto).Returns(20);
            formaPagamento.Setup(f => f.Tipo).Returns(TipoFormaPagamento.Prazo);
            formaPagamento.Setup(f => f.Parcelamento).Returns(new ParcelamentoFormaPagamento(TipoParcelamentoFormaPagamento.ComEntrada, 3, 30));

            var repositorioFormaPagamento = new Mock <IFormaPagamentoRepositorio>();

            repositorioFormaPagamento.Setup(r => r.Obter(1)).Returns(formaPagamento.Object);

            IFachadaAtendimento fachada = new FachadaAtendimento(null, this._repositorioPessoa, repositorioFormaPagamento.Object, repositorioServico.Object);

            fachada.CriaNovoAtendimento(this._dtoCabecalho);

            #region Item 1
            DTOItem dto1 = new DTOItem();
            dto1.IdServico     = 1;
            dto1.ValorUnitario = 15m;
            dto1.Quantidade    = 1;

            Servico servico1 = ServicoStub.GetInstance(1, "Serviço 1", 1);

            repositorioServico.Setup(r => r.Obter(1))
            .Returns(servico1);

            fachada.AdicionarItem(dto1);
            repositorioServico.Verify(r => r.Obter(It.IsAny <long>()));
            #endregion

            #region Item 2
            DTOItem dto2 = new DTOItem();
            dto2.IdServico     = 2;
            dto2.ValorUnitario = 10m;
            dto2.Quantidade    = 2;

            Servico servico2 = ServicoStub.GetInstance(2, "Serviço 2", 1);

            repositorioServico.Setup(r => r.Obter(2))
            .Returns(servico2);
            fachada.AdicionarItem(dto2);
            repositorioServico.Verify(r => r.Obter(It.IsAny <long>()));

            #endregion

            #region Item 3
            DTOItem dto3 = new DTOItem();
            dto3.IdServico     = 2;
            dto3.ValorUnitario = 10m;
            dto3.Quantidade    = 2;

            Servico servico3 = ServicoStub.GetInstance(2, "Serviço 2", 1);

            repositorioServico.Setup(r => r.Obter(2))
            .Returns(servico3);

            fachada.AdicionarItem(dto3);
            repositorioServico.Verify(r => r.Obter(It.IsAny <long>()));

            #endregion

            #region Item 4
            DTOItem dto4 = new DTOItem();
            dto4.IdServico     = 4;
            dto4.ValorUnitario = 12m;
            dto4.Quantidade    = 1;

            Servico servico4 = ServicoStub.GetInstance(4, "Serviço 4", 1);

            repositorioServico.Setup(r => r.Obter(4))
            .Returns(servico4);

            fachada.AdicionarItem(dto4);
            repositorioServico.Verify(r => r.Obter(It.IsAny <long>()));

            #endregion

            #region Acréscimos e Descontos
            fachada.AdicionarAcrescimo(10);
            fachada.AdicionarDesconto(15);
            #endregion

            DTOValoresAtendimento dto = fachada.ObterValoresAtendimento();

            foreach (DTOItem i in dto.Itens)
            {
                switch (i.IdServico)
                {
                case 1: Assert.AreEqual(15m, i.ValorUnitario);
                    Assert.AreEqual(1, i.Quantidade);
                    Assert.AreEqual(15, i.ValorItem);
                    Assert.AreEqual("SERVIÇO 1", i.DescricaoServico);
                    break;

                case 2: Assert.AreEqual(10m, i.ValorUnitario);
                    Assert.AreEqual(2, i.Quantidade);
                    Assert.AreEqual(20, i.ValorItem);
                    Assert.AreEqual("SERVIÇO 2", i.DescricaoServico);
                    break;

                case 4: Assert.AreEqual(12m, i.ValorUnitario);
                    Assert.AreEqual(1, i.Quantidade);
                    Assert.AreEqual(12, i.ValorItem);
                    Assert.AreEqual("SERVIÇO 4", i.DescricaoServico);
                    break;
                }
            }

            Assert.AreEqual(10m, dto.PercentualAcrescimo);
            Assert.AreEqual(20m, dto.PercentualDesconto);
            Assert.AreEqual(10m, dto.Acrescimo);
            Assert.AreEqual(15m, dto.Desconto);
            Assert.AreEqual(3m, dto.NumeroItens);
            Assert.AreEqual(37m, dto.TotalValorUnitario);
            Assert.AreEqual(4m, dto.TotalQuantidade);
            Assert.AreEqual(47m, dto.TotalValorItens);
            Assert.AreEqual(4.7m, dto.AcrescimoFormaPagamento);
            Assert.AreEqual(9.4m, dto.DescontoFormaPagamento);
            Assert.AreEqual(37.3m, dto.ValorAtendimento);
            Assert.AreEqual(12.43m, dto.ValorEntrada);
        }
Exemplo n.º 11
0
        public void Ao_Movimentar_Um_Item_Deve_Calcular_O_Desconto_E_O_Acrescimo_Pelo_Percentual_Da_Forma_De_Pagamento()
        {
            // Primeiro testo uma forma de pagamento que não tem nenhum percentual. Nem de acréscimo nem de desconto.
            var formaPagamentoSemDescontoSemAcrescimo = new Mock <FormaPagamento>();

            formaPagamentoSemDescontoSemAcrescimo.Setup(f => f.Id)
            .Returns(1);
            formaPagamentoSemDescontoSemAcrescimo.Setup(f => f.PercentualAcrescimo)
            .Returns(0);
            formaPagamentoSemDescontoSemAcrescimo.Setup(f => f.PercentualDesconto)
            .Returns(0);

            Servico servico1 = ServicoStub.GetInstance(1, "serviço 1", 1);
            Servico servico2 = ServicoStub.GetInstance(2, "serviço 2", 2);

            Atendimento atendimento = new Atendimento(DateTime.Now, this._empresaValida, this._clienteValido, formaPagamentoSemDescontoSemAcrescimo.Object);

            atendimento.AdicionarItem(servico1, 10.50m, 3);
            Assert.AreEqual(0, atendimento.AcrescimoFormaPagamento);
            Assert.AreEqual(0, atendimento.DescontoFormaPagamento);

            atendimento.AdicionarItem(servico2, 22m, 7);
            Assert.AreEqual(0, atendimento.AcrescimoFormaPagamento);
            Assert.AreEqual(0, atendimento.DescontoFormaPagamento);

            atendimento.AdicionarItem(servico1, 11m, 4);
            Assert.AreEqual(0, atendimento.AcrescimoFormaPagamento);
            Assert.AreEqual(0, atendimento.DescontoFormaPagamento);

            // Depois testo em uma forma de pagamento que tem percentual de acréscimo e de desconto
            var formaPagamento = new Mock <FormaPagamento>();

            formaPagamento.Setup(f => f.Id)
            .Returns(1);
            formaPagamento.Setup(f => f.PercentualAcrescimo)
            .Returns(10);
            formaPagamento.Setup(f => f.PercentualDesconto)
            .Returns(20);

            atendimento = new Atendimento(DateTime.Now, this._empresaValida, this._clienteValido, formaPagamento.Object);

            atendimento.AdicionarItem(servico1, 10, 3);             // 30
            Assert.AreEqual(3m, atendimento.AcrescimoFormaPagamento);
            Assert.AreEqual(6m, atendimento.DescontoFormaPagamento);

            atendimento.AdicionarItem(servico2, 22m, 7);           // 154 184
            Assert.AreEqual(18.4m, atendimento.AcrescimoFormaPagamento);
            Assert.AreEqual(36.8m, atendimento.DescontoFormaPagamento);

            atendimento.RemoverItem(servico2);                     // 154 30
            Assert.AreEqual(3m, atendimento.AcrescimoFormaPagamento);
            Assert.AreEqual(6m, atendimento.DescontoFormaPagamento);

            atendimento.AdicionarItem(servico1, 11m, 4);           // 44
            Assert.AreEqual(4.4m, atendimento.AcrescimoFormaPagamento);
            Assert.AreEqual(8.8m, atendimento.DescontoFormaPagamento);

            atendimento.AdicionarItem(servico2, 1m, 10);           // 10 54
            Assert.AreEqual(5.4m, atendimento.AcrescimoFormaPagamento);
            Assert.AreEqual(10.8m, atendimento.DescontoFormaPagamento);
        }