Example #1
0
        public CadastroProdutoFornecedorTests()
        {
            _produto      = new Produto("PROD0001", "PRODUTO 0001", "01");
            _produtosMock = new Mock <IProdutos>(MockBehavior.Strict);
            _produtosMock.Setup(x => x.BuscaPeloCodigo("PROD0001")).Returns(_produto);
            _produtosMock.Setup(x => x.Save(It.IsAny <Produto>()))
            .Callback((Produto produto) =>
            {
                Assert.IsNotNull(produto);
                Assert.IsTrue(produto.Fornecedores.All(p => p != null));
            });

            _fornecedoresMock = new Mock <IFornecedores>(MockBehavior.Strict);
            _fornecedoresMock.Setup(x => x.BuscaListaPorCodigo(new[] { "FORNEC0001", "FORNEC0002" }))
            .Returns(_fornecedoresMock.Object);
            _fornecedoresMock.Setup(x => x.List())
            .Returns(new List <Fornecedor>()
            {
                new Fornecedor("FORNEC0001", "FORNECEDOR 0001", "*****@*****.**", "", "", "", false),
                new Fornecedor("FORNEC0002", "FORNECEDOR 0002", "*****@*****.**", "", "", "", false)
            });

            _unitOfWorkMock = CommonMocks.DefaultUnitOfWorkMock();

            _cadastroProdutoFornecedor = new CadastroProdutoFornecedor(_produtosMock.Object, _fornecedoresMock.Object, _unitOfWorkMock.Object);
        }
        public ProcessoDeCotacaoItensServiceTests()
        {
            _unitOfWorkMock = CommonMocks.DefaultUnitOfWorkMock();

            _requisicoesDeCompras = new List <RequisicaoDeCompra>
            {
                ((ProcessoDeCotacaoDeMaterialItem)_processoDeCotacao.Itens.First()).RequisicaoDeCompra,
                DefaultObjects.ObtemRequisicaoDeCompraComId(),
                DefaultObjects.ObtemRequisicaoDeCompraComId()
            };

            _processosDeCotacaoMock = new Mock <IProcessosDeCotacao>(MockBehavior.Strict);
            _processosDeCotacaoMock.Setup(x => x.BuscaPorId(It.IsAny <int>()))
            .Returns(_processosDeCotacaoMock.Object);
            _processosDeCotacaoMock.Setup(x => x.Single())
            .Returns(_processoDeCotacao);
            _processosDeCotacaoMock.Setup(x => x.Save(It.IsAny <ProcessoDeCotacao>()))
            .Callback(
                (ProcessoDeCotacao processoDeCotacao) => Assert.IsNotNull(processoDeCotacao));

            _requisicoesDeCompraMock = new Mock <IRequisicoesDeCompra>(MockBehavior.Strict);
            _requisicoesDeCompraMock.Setup(x => x.FiltraPorIds(It.IsAny <int[]>()))
            .Returns((int[] ids) => _requisicoesDeCompras.Where(x => ids.Contains(x.Id)).ToList());
            _requisicoesDeCompraMock.Setup(x => x.Save(It.IsAny <RequisicaoDeCompra>()))
            .Callback(CommonGenericMocks <RequisicaoDeCompra> .DefaultSaveCallBack(_unitOfWorkMock));

            _service = new ProcessoDeCotacaoDeMaterialItensService(_unitOfWorkMock.Object, _processosDeCotacaoMock.Object, _requisicoesDeCompraMock.Object);
        }
Example #3
0
        public CadastroQuotaTests()
        {
            _unitOfWorkMock = CommonMocks.DefaultUnitOfWorkMock();

            _quotasMock = new Mock <IQuotas>(MockBehavior.Strict);
            _quotasMock.Setup(x => x.Save(It.IsAny <Quota>()))
            .Callback(CommonGenericMocks <Quota> .DefaultSaveCallBack(_unitOfWorkMock));

            _quotasMock.Setup(x => x.Delete(It.IsAny <Quota>()))
            .Callback((Quota quota) => Assert.AreSame(_fornecedor2, quota.Fornecedor));

            _quotasMock.Setup(x => x.FiltraPorData(It.IsAny <DateTime>()))
            .Returns(_quotasMock.Object);
            _quotasMock.Setup(x => x.List()).Returns(new List <Quota>()
            {
                new Quota(Enumeradores.MaterialDeCarga.Soja, _fornecedor1, "1000", DateTime.Today, 100),
                new Quota(Enumeradores.MaterialDeCarga.Soja, _fornecedor2, "1000", DateTime.Today, 120)
            });

            _fornecedoresMock = new Mock <IFornecedores>(MockBehavior.Strict);
            _fornecedoresMock.Setup(x => x.BuscaListaPorCodigo(It.IsAny <string[]>()))
            .Returns(_fornecedoresMock.Object);
            _fornecedoresMock.Setup(x => x.List()).Returns(new List <Fornecedor>
            {
                _fornecedor3
            });
            _cadastroQuota = new CadastroQuota(_unitOfWorkMock.Object, _quotasMock.Object, _fornecedoresMock.Object);
        }
        public ProcessoDeCotacaoDeMaterialServiceTests()
        {
            _unitOfWorkMock         = CommonMocks.DefaultUnitOfWorkMock();
            _processosDeCotacaoMock = new Mock <IProcessosDeCotacao>(MockBehavior.Strict);
            _processosDeCotacaoMock.Setup(x => x.Save(It.IsAny <ProcessoDeCotacao>()))
            .Callback(
                (ProcessoDeCotacao processoDeCotacao) =>
            {
                Assert.IsNotNull(processoDeCotacao);
                foreach (var fornecedorParticipante in processoDeCotacao.FornecedoresParticipantes)
                {
                    Assert.IsNotNull(fornecedorParticipante);
                }
            });

            //ProcessoDeCotacaoDeMaterial processoDeCotacaoDeMaterial = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
            var processoDeCotacaoDeMaterial = new ProcessoDeCotacaoDeMaterialParaAtualizacao();

            //processoDeCotacaoDeMaterial.AdicionarFornecedor(DefaultObjects.ObtemFornecedorPadrao());
            //processoDeCotacaoDeMaterial.AdicionarFornecedor(DefaultObjects.ObtemFornecedorPadrao());
            _processosDeCotacaoMock.Setup(x => x.BuscaPorId(It.IsAny <int>()))
            .Returns(_processosDeCotacaoMock.Object);
            _processosDeCotacaoMock.Setup(x => x.Single())
            .Returns(processoDeCotacaoDeMaterial);

            _processoDeCotacaoService         = new ProcessoDeCotacaoDeMaterialService(_unitOfWorkMock.Object, _processosDeCotacaoMock.Object);
            _atualizacaoDoProcessoDeCotacaoVm = new ProcessoDeCotacaoAtualizarVm()
            {
                Id = 1,
                DataLimiteRetorno = DateTime.Today.AddDays(10),
                Requisitos        = "requisitos do processo"
            };
        }
Example #5
0
        public GerenciadorUsuarioTests()
        {
            _provedorDeCriptografiaMock = new Mock <IProvedorDeCriptografia>(MockBehavior.Strict);
            _provedorDeCriptografiaMock.Setup(x => x.Criptografar(It.IsAny <string>())).Returns("criptografado");

            _unitOfWorkMock = CommonMocks.DefaultUnitOfWorkMock();

            _usuariosMock = new Mock <IUsuarios>(MockBehavior.Strict);

            _usuariosMock.Setup(x => x.Save(It.IsAny <Usuario>()))
            .Callback(CommonGenericMocks <Usuario> .DefaultSaveCallBack(_unitOfWorkMock));


            _usuariosMock.Setup(x => x.BuscaPorLogin(It.IsAny <string>()))
            .Returns(
                (string login) =>
                login == "USER001"
                                 ? new UsuarioParaAtualizacao("USUARIO 001", "USER001", "")
                                  : null);

            _usuariosMock.Setup(x => x.FiltraPorListaDeLogins(It.IsAny <string[]>())).Returns(_usuariosMock.Object);
            _usuariosMock.Setup(x => x.SemSenha()).Returns(_usuariosMock.Object);

            _geradorDeSenhaMock = new Mock <IGeradorDeSenha>(MockBehavior.Strict);
            _geradorDeSenhaMock.Setup(x => x.GerarGuid(It.IsAny <int>()))
            .Returns("12345678");


            _geradorDeEmailMock = new Mock <IGeradorDeEmail>(MockBehavior.Strict);
            _geradorDeEmailMock.Setup(x => x.CriacaoAutomaticaDeSenha(It.IsAny <Usuario>(), It.IsAny <string>()));
            _gerenciadorUsuario = new GerenciadorUsuario(_unitOfWorkMock.Object, _usuariosMock.Object,
                                                         _provedorDeCriptografiaMock.Object, _geradorDeSenhaMock.Object,
                                                         ObjectFactory.GetInstance <IBuilder <Usuario, UsuarioConsultaVm> >(), _geradorDeEmailMock.Object);
        }
        public CadastroUnidadeDeMedidaTests()
        {
            _unitOfWorkMock       = CommonMocks.DefaultUnitOfWorkMock();
            _unidadesConsulta     = new List <UnidadeDeMedida>();
            _unidadesDeMedidaMock = new Mock <IUnidadesDeMedida>(MockBehavior.Strict);
            _unidadesDeMedidaMock.Setup(x => x.Save(It.IsAny <UnidadeDeMedida>()))
            .Callback(CommonGenericMocks <UnidadeDeMedida> .DefaultSaveCallBack(_unitOfWorkMock));
            _unidadesDeMedidaMock.Setup(x => x.FiltraPorListaDeCodigosInternos(It.IsAny <string[]> ()))
            .Returns(_unidadesDeMedidaMock.Object)
            .Callback(
                (string[] i) =>
            {
                if (i.Contains("I01"))
                {
                    _unidadesConsulta.Add(new UnidadeDeMedidaParaAtualizacao("I01", "E01", "Unidade 01"));
                }
            });


            _unidadesDeMedidaMock.Setup(x => x.List())
            .Returns(() => _unidadesConsulta);

            _cadastroUnidadeDeMedida = new CadastroUnidadeDeMedida(_unitOfWorkMock.Object, _unidadesDeMedidaMock.Object);
            _unidadeDeMedidaPadrao   = new UnidadeDeMedidaCadastroVm()
            {
                CodigoInterno = "I01",
                CodigoExterno = "E01",
                Descricao     = "Unidade 01"
            };
            _listaunidadesDeMedida = new List <UnidadeDeMedidaCadastroVm>()
            {
                _unidadeDeMedidaPadrao
            };
        }
        public CadastroUsuarioTests()
        {
            _provedorDeCriptografiaMock = new Mock <IProvedorDeCriptografia>(MockBehavior.Strict);
            _provedorDeCriptografiaMock.Setup(x => x.Criptografar(It.IsAny <string>())).Returns("criptografado");

            _unitOfWorkMock = CommonMocks.DefaultUnitOfWorkMock();

            _usuariosMock = new Mock <IUsuarios>(MockBehavior.Strict);

            _usuariosMock.Setup(x => x.Save(It.IsAny <Usuario>()))
            .Callback(CommonGenericMocks <Usuario> .DefaultSaveCallBack(_unitOfWorkMock));


            _usuariosMock.Setup(x => x.BuscaPorLogin(It.IsAny <string>()))
            .Returns(
                (string login) =>
                login == "USER001"
                                 ? new UsuarioParaAtualizacao("USUARIO 001", "USER001", "")
                                  : null);


            _cadastroUsuario = new CadastroUsuario(_unitOfWorkMock.Object, _usuariosMock.Object);

            _usuarioPadrao = new UsuarioCadastroVm()
            {
                Nome  = "Mauro Leal",
                Login = "******",
                Email = "*****@*****.**"
            };
        }
Example #8
0
        public CadastroItinerarioTests()
        {
            _unitOfWorkMock      = CommonMocks.DefaultUnitOfWorkMock();
            _itinerariosConsulta = new List <Itinerario>();
            _itinerariosMock     = new Mock <IItinerarios>(MockBehavior.Strict);
            _itinerariosMock.Setup(x => x.Save(It.IsAny <Itinerario>())).Callback(CommonGenericMocks <Itinerario> .DefaultSaveCallBack(_unitOfWorkMock));
            _itinerariosMock.Setup(x => x.FiltraPorListaDeCodigos(It.IsAny <string[]>    ()))
            .Returns(_itinerariosMock.Object)
            .Callback(
                (string[] codigos) =>
            {
                if (codigos.Contains("01"))
                {
                    _itinerariosConsulta.Add(new ItinerarioParaAtualizacao("01", "Itinerario 01"));
                }
            });


            _itinerariosMock.Setup(x => x.List())
            .Returns(() => _itinerariosConsulta);

            _cadastroItinerario = new CadastroItinerario(_unitOfWorkMock.Object, _itinerariosMock.Object);
            _itinerarioPadrao   = new ItinerarioCadastroVm()
            {
                Codigo    = "01",
                Descricao = "ITINERARIO 01"
            };
            _listaItinerarios = new List <ItinerarioCadastroVm>()
            {
                _itinerarioPadrao
            };
        }
        public CadastroIvaTests()
        {
            _unitOfWorkMock = CommonMocks.DefaultUnitOfWorkMock();
            _ivasConsulta   = new List <Iva>();
            _ivasMock       = new Mock <IIvas>(MockBehavior.Strict);
            _ivasMock.Setup(x => x.Save(It.IsAny <Iva>())).Callback((Iva iva) => Assert.IsNotNull(iva));
            _ivasMock.Setup(x => x.BuscaListaPorCodigo(It.IsAny <string[]>()))
            .Callback((string[] codigos) =>
            {
                if (codigos.Contains("01"))
                {
                    _ivasConsulta.Add(new IvaParaAtualizacao("01", "IVA 01"));
                }
            })
            .Returns(_ivasMock.Object);

            _ivasMock.Setup(x => x.List()).Returns(_ivasConsulta);

            _cadastroIva = new CadastroIva(_unitOfWorkMock.Object, _ivasMock.Object);
            _ivaPadrao   = new IvaCadastroVm()
            {
                Codigo    = "01",
                Descricao = "IVA 01"
            };
            _listaIvas = new List <IvaCadastroVm>()
            {
                _ivaPadrao
            };
        }
Example #10
0
        public ProcessoDeCotacaoDeMaterialFechamentoTests()
        {
            _unitOfWorkMock         = CommonMocks.DefaultUnitOfWorkMock();
            _processosDeCotacaoMock = new Mock <IProcessosDeCotacao>(MockBehavior.Strict);
            _processosDeCotacaoMock.Setup(x => x.Save(It.IsAny <ProcessoDeCotacao>()))
            .Callback(
                (ProcessoDeCotacao processoDeCotacao) =>
            {
                _unitOfWorkMock.Verify(x => x.BeginTransaction(), Times.Once());
                _unitOfWorkMock.Verify(x => x.Commit(), Times.Never());
                Assert.IsNotNull(processoDeCotacao);
                foreach (var fornecedorParticipante in processoDeCotacao.FornecedoresParticipantes)
                {
                    Assert.IsNotNull(fornecedorParticipante);
                }
            });

            _processosDeCotacaoMock.Setup(x => x.BuscaPorId(It.IsAny <int>()))
            .Returns(_processosDeCotacaoMock.Object)
            .Callback((int idProcessoCotacao) =>
            {
                _unitOfWorkMock.Verify(x => x.BeginTransaction(), Times.Once());
                _unitOfWorkMock.Verify(x => x.Commit(), Times.Never());
                if (idProcessoCotacao == 10)
                {
                    _processoDeCotacao = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
                    _processoDeCotacao.AdicionarFornecedor(DefaultObjects.ObtemFornecedorPadrao());
                }
                if (idProcessoCotacao == 20)
                {
                    _processoDeCotacao   = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAbertoPadrao();
                    var codigoFornecedor = _processoDeCotacao.FornecedoresParticipantes.First().Fornecedor.Codigo;
                    var cotacao          = _processoDeCotacao.InformarCotacao(codigoFornecedor, DefaultObjects.ObtemCondicaoDePagamentoPadrao(),
                                                                              DefaultObjects.ObtemIncotermPadrao(), "inc");
                    var processoCotacaoItem = _processoDeCotacao.Itens.First();
                    var cotacaoItem         = (CotacaoMaterialItem)cotacao.InformarCotacaoDeItem(processoCotacaoItem, 150, null, 100, DateTime.Today.AddMonths(1), "obs fornec");
                    cotacaoItem.Selecionar(100, DefaultObjects.ObtemIvaPadrao());
                }
                if (idProcessoCotacao == 30)
                {
                    _processoDeCotacao = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialFechado();
                }
            });

            _processosDeCotacaoMock.Setup(x => x.Single()).Returns(() => _processoDeCotacao);

            //_geradorDeEmailMock = new Mock<IGeradorDeEmailDeFechamentoDeProcessoDeCotacao>(MockBehavior.Strict);
            //_geradorDeEmailMock.Setup(x => x.GerarEmail(It.IsAny<ProcessoDeCotacao>()));

            _comunicacaoSapMock = new Mock <IProcessoDeCotacaoDeMaterialFechamentoComunicacaoSap>(MockBehavior.Strict);
            _comunicacaoSapMock.Setup(x => x.EfetuarComunicacao(It.IsAny <ProcessoDeCotacaoDeMaterial>(), It.IsAny <ProcessoDeCotacaoDeMaterialFechamentoInfoVm>()));

            _fechamentoDeProcessoDeCotacaoService = new FechamentoDeProcessoDeCotacaoDeMaterialService(_unitOfWorkMock.Object, _processosDeCotacaoMock.Object, _comunicacaoSapMock.Object);
        }
Example #11
0
        public AtualizadorDeIteracaoDoUsuarioTests()
        {
            _unitOfWorkMock = CommonMocks.DefaultUnitOfWorkMock();
            _processoCotacaoIteracoesUsuarioMock = new Mock <IProcessoCotacaoIteracoesUsuario>(MockBehavior.Strict);
            _processoCotacaoIteracoesUsuarioMock.Setup(x => x.BuscaPorIdParticipante(It.IsAny <int>()))
            .Returns(new ProcessoCotacaoIteracaoUsuario(10));

            _processoCotacaoIteracoesUsuarioMock.Setup(x => x.Save(It.IsAny <ProcessoCotacaoIteracaoUsuario>()))
            .Callback(
                CommonGenericMocks <ProcessoCotacaoIteracaoUsuario>
                .DefaultSaveCallBack(_unitOfWorkMock));
            _atualizadorDeIteracaoDoUsuario = new AtualizadorDeIteracaoDoUsuario(_unitOfWorkMock.Object, _processoCotacaoIteracoesUsuarioMock.Object);
        }
        public AlteradorDeRequisicaoDeCompraTests()
        {
            _unitOfWorkMock          = CommonMocks.DefaultUnitOfWorkMock();
            _requisicoesDeCompraMock = new Mock <IRequisicoesDeCompra>(MockBehavior.Strict);
            _requisicoesDeCompraMock.Setup(x => x.BuscaPeloId(It.IsAny <int>()))
            .Returns(DefaultObjects.ObtemRequisicaoDeCompraPadrao());

            _requisicoesDeCompraMock.Setup(x => x.Save(It.IsAny <RequisicaoDeCompra>()))
            .Callback(CommonGenericMocks <RequisicaoDeCompra> .DefaultSaveCallBack(_unitOfWorkMock));

            _processosDeCotacaoDeMaterialMock = new Mock <IProcessosDeCotacaoDeMaterial>(MockBehavior.Strict);
            _processosDeCotacaoDeMaterialMock.Setup(x => x.GeradosPelaRequisicaoDeCompra(It.IsAny <int>()))
            .Returns(_processosDeCotacaoDeMaterialMock.Object);

            _processosDeCotacaoDeMaterialMock.Setup(x => x.Count())
            .Returns(0);
        }
        public CadastroCondicaoPagamentoTests()
        {
            _condicoesRepositorio     = new List <CondicaoDePagamento>();
            _unitOfWorkMock           = CommonMocks.DefaultUnitOfWorkMock();
            _condicoesDePagamentoMock = new Mock <ICondicoesDePagamento>(MockBehavior.Strict);
            _condicoesDePagamentoMock.Setup(x => x.Save(It.IsAny <CondicaoDePagamento>()))
            .Callback((CondicaoDePagamento condicaoDePagamento) =>
            {
                Assert.IsNotNull(condicaoDePagamento);
                //callback assegura que a transação foi iniciada  e não foi fechada antes de salvar
                _unitOfWorkMock.Verify(x => x.BeginTransaction(), Times.Once());
                _unitOfWorkMock.Verify(x => x.Commit(), Times.Never());
            });
            _condicoesDePagamentoMock.Setup(x => x.FiltraPorListaDeCodigos(It.IsAny <string[]>()))
            //callback assegura que a transação foi iniciada e não foi fechada antes de consultar
            .Callback((string[] codigos) =>
            {
                _unitOfWorkMock.Verify(x => x.BeginTransaction(), Times.Once());
                _unitOfWorkMock.Verify(x => x.Commit(), Times.Never());
                if (codigos.Contains("C001"))
                {
                    _condicoesRepositorio.Add(new CondicaoDePagamentoParaAtualizacao("C001", "CONDICAO 001"));
                }
            })
            .Returns(_condicoesDePagamentoMock.Object);

            _condicoesDePagamentoMock.Setup(x => x.List()).Returns(_condicoesRepositorio);

            _cadastroCondicaoPagamento = new CadastroCondicaoPagamento(_unitOfWorkMock.Object, _condicoesDePagamentoMock.Object);
            _condicaoPagamento01       = new CondicaoDePagamentoCadastroVm()
            {
                Codigo    = "C001",
                Descricao = "CONDICAO 001"
            };

            _condicaoPagamento02 = new CondicaoDePagamentoCadastroVm()
            {
                Codigo    = "C002",
                Descricao = "CONDICAO 002"
            };

            _condicoesDePagamento = new List <CondicaoDePagamentoCadastroVm>()
            {
                _condicaoPagamento01, _condicaoPagamento02
            };
        }
        public ProcessoDeCotacaoFornecedoresServiceTests()
        {
            _unitOfWorkMock         = CommonMocks.DefaultUnitOfWorkMock();
            _processosDeCotacaoMock = new Mock <IProcessosDeCotacao>(MockBehavior.Strict);
            _processosDeCotacaoMock.Setup(x => x.Save(It.IsAny <ProcessoDeCotacao>()))
            .Callback(
                (ProcessoDeCotacao processoDeCotacao) =>
            {
                Assert.IsNotNull(processoDeCotacao);
                foreach (var fornecedorParticipante in processoDeCotacao.FornecedoresParticipantes)
                {
                    Assert.IsNotNull(fornecedorParticipante);
                }
            });

            ProcessoDeCotacaoDeMaterial processoDeCotacaoDeMaterial = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialNaoIniciado();

            processoDeCotacaoDeMaterial.AdicionarFornecedor(new Fornecedor("FORNEC0001", "FORNECEDOR 0001", "*****@*****.**", "", "", "", false));
            processoDeCotacaoDeMaterial.AdicionarFornecedor(new Fornecedor("FORNEC0002", "FORNECEDOR 0002", "*****@*****.**", "", "", "", false));
            _processosDeCotacaoMock.Setup(x => x.BuscaPorId(It.IsAny <int>()))
            .Returns(_processosDeCotacaoMock.Object);
            _processosDeCotacaoMock.Setup(x => x.Single())
            .Returns(processoDeCotacaoDeMaterial);

            _fornecedoresMock = new Mock <IFornecedores>(MockBehavior.Strict);
            _fornecedoresMock.Setup(x => x.BuscaListaPorCodigo(It.IsAny <string[]>()))
            .Returns(_fornecedoresMock.Object);
            _fornecedoresMock.Setup(x => x.List())
            .Returns(new List <Fornecedor>()
            {
                new Fornecedor("FORNEC0003", "FORNECEDOR 0003", "*****@*****.**", "", "", "", false)
            });

            _atualizadorDeIteracaoDoUsuarioMock = new Mock <IAtualizadorDeIteracaoDoUsuario>(MockBehavior.Strict);
            _atualizadorDeIteracaoDoUsuarioMock.Setup(x => x.Adicionar(It.IsAny <IList <FornecedorParticipante> >()))
            .Callback((IList <FornecedorParticipante> fp) => CommonVerifications.VerificaCommitDeTransacao(_unitOfWorkMock));

            _processoDeCotacaoFornecedoresService = new ProcessoDeCotacaoFornecedoresService(_unitOfWorkMock.Object, _processosDeCotacaoMock.Object,
                                                                                             _fornecedoresMock.Object, _atualizadorDeIteracaoDoUsuarioMock.Object);
            _atualizacaoDosFornecedoresVm = new ProcessoDeCotacaoFornecedoresAtualizarVm()
            {
                IdProcessoCotacao = 1,
                CodigoFornecedoresSelecionados = new[] { "FORNEC0001", "FORNEC0003" }
            };
        }
Example #15
0
        public CadastroFornecedorTests()
        {
            _unitOfWorkMock          = CommonMocks.DefaultUnitOfWorkMock();
            _fornecedoresRepositorio = new List <Fornecedor>();

            _fornecedoresMock = new Mock <IFornecedores>(MockBehavior.Strict);
            _fornecedoresMock.Setup(x => x.Save(It.IsAny <Fornecedor>())).Callback((Fornecedor fornecedor) => Assert.IsNotNull(fornecedor));
            _fornecedoresMock.Setup(x => x.BuscaListaPorCodigo(It.IsAny <string[]>()))
            .Callback((string[] codigos) =>
            {
                if (codigos.Contains("FORNEC0001"))
                {
                    _fornecedoresRepositorio.Add(new FornecedorParaAtualizacao("FORNEC0001", "FORNECEDOR 0001", "*****@*****.**", "cnpj alterado", "municipio alterado", "uf alterada", false));
                }
            })
            .Returns(_fornecedoresMock.Object);

            _fornecedoresMock.Setup(x => x.List()).Returns(_fornecedoresRepositorio);

            _usuariosRepositorio = new List <Usuario>();
            _usuariosMock        = new Mock <IUsuarios>(MockBehavior.Strict);
            _usuariosMock.Setup(x => x.FiltraPorListaDeLogins(It.IsAny <string[]>()))
            .Callback((string[] logins) =>
            {
                if (logins.Contains("FORNEC0001"))
                {
                    _usuariosRepositorio.Add(new UsuarioParaAtualizacao("FORNEC0001", "FORNECEDOR 0001", "*****@*****.**"));
                }
            })
            .Returns(_usuariosMock.Object);
            _usuariosMock.Setup(x => x.List())
            .Returns(_usuariosRepositorio);

            _usuariosMock.Setup(x => x.Save(It.IsAny <Usuario>()));

            _cadastroFornecedor = new CadastroFornecedor(_unitOfWorkMock.Object, _fornecedoresMock.Object, _usuariosMock.Object);

            _fornecedorCadastroVm = new FornecedorCadastroVm()
            {
                Codigo = "FORNEC0001",
                Nome   = "FORNECEDOR 0001",
                Email  = "*****@*****.**"
            };
        }
Example #16
0
        public CadastroProdutoTests()
        {
            _unitOfWorkMock   = CommonMocks.DefaultUnitOfWorkMock();
            _produtosConsulta = new List <Produto>();
            _produtosMock     = new Mock <IProdutos>(MockBehavior.Strict);
            _produtosMock.Setup(x => x.Save(It.IsAny <Produto>())).Callback((Produto produto) => Assert.IsNotNull(produto));
            _produtosMock.Setup(x => x.FiltraPorListaDeCodigos(It.IsAny <string[]>()))
            .Callback((string[] codigos) =>
            {
                if (codigos.Contains("PROD0001"))
                {
                    _produtosConsulta.Add(new ProdutoParaAtualizacao("PROD0001", "PRODUTO 0001", "01"));
                }
            })
            .Returns(_produtosMock.Object);

            _produtosMock.Setup(x => x.List()).Returns(_produtosConsulta);

            _cadastroProduto = new CadastroProduto(_unitOfWorkMock.Object, _produtosMock.Object);

            _produtoPadrao = new ProdutoCadastroVm()
            {
                Codigo    = "SAP 0001",
                Descricao = "PRODUTO 0001",
                Tipo      = "01"
            };

            _produtosPadrao = new List <ProdutoCadastroVm>()
            {
                new ProdutoCadastroVm()
                {
                    Codigo    = "PROD0001",
                    Descricao = "PRODUTO 0001",
                    Tipo      = "01"
                },
                new ProdutoCadastroVm()
                {
                    Codigo    = "PROD0002",
                    Descricao = "PRODUTO 0002",
                    Tipo      = "02"
                }
            };
        }
        public CadastroDeRequisicaoDeCompraTests()
        {
            _unitOfWorkMock = CommonMocks.DefaultUnitOfWorkMock();

            _requisicoesDeCompraMock = new Mock <IRequisicoesDeCompra>(MockBehavior.Strict);
            _requisicoesDeCompraMock.Setup(x => x.Save(It.IsAny <RequisicaoDeCompra>()))
            .Callback((RequisicaoDeCompra requisicaoDeCompra) => Assert.IsNotNull(requisicaoDeCompra)
                      );

            _usuariosMock = new Mock <IUsuarios>(MockBehavior.Strict);
            _usuariosMock.Setup(x => x.BuscaPorLogin(It.IsAny <string>())).Returns((string login) =>
            {
                if (login == "criador")
                {
                    return(new Usuario("Usuário Criador", "criador", null));
                }
                return(null);
            });

            _fornecedoresMock = new Mock <IFornecedores>(MockBehavior.Strict);
            _fornecedoresMock.Setup(x => x.BuscaPeloCodigo(It.IsAny <string>()))
            .Returns(new Fornecedor("FORNEC0001", "FORNECEDOR 0001", null, "", "", "", false));

            _produtosMock = new Mock <IProdutos>(MockBehavior.Strict);
            _produtosMock.Setup(x => x.BuscaPeloCodigo(It.IsAny <string>()))
            .Returns(new Produto("PROD0001", "PRODUTO 0001", "01"));

            _unidadesDeMedidaMock = new Mock <IUnidadesDeMedida>(MockBehavior.Strict);
            _unidadesDeMedidaMock.Setup(x => x.BuscaPeloCodigoInterno(It.IsAny <string>()))
            .Returns(_unidadesDeMedidaMock.Object);

            _unidadesDeMedidaMock.Setup(x => x.Single())
            .Returns(new UnidadeDeMedida("I01", "E01", "UNIDADE 01"));

            _processosDeCotacaoMock = new Mock <IProcessosDeCotacao>(MockBehavior.Strict);
            _processosDeCotacaoMock.Setup(x => x.Save(It.IsAny <ProcessoDeCotacao>()));

            _cadastroRequisicao = new CadastroRequisicaoCompra(_unitOfWorkMock.Object, _requisicoesDeCompraMock.Object,
                                                               _usuariosMock.Object, _fornecedoresMock.Object, _produtosMock.Object, _processosDeCotacaoMock.Object, _unidadesDeMedidaMock.Object);
        }
Example #18
0
        public CadastroIncotermTests()
        {
            _unitOfWorkMock = CommonMocks.DefaultUnitOfWorkMock();
            _incotermsMock  = new Mock <IIncoterms>(MockBehavior.Strict);
            _incotermsMock.Setup(x => x.Save(It.IsAny <Incoterm>())).Callback((Incoterm incoterm) => Assert.IsNotNull(incoterm));
            _incotermsMock.Setup(x => x.FiltraPorListaDeCodigos(It.IsAny <string[]>()))
            .Callback((string[] i) =>
            {
                _incotermRetornoRepositorio = (i.Contains("001")
                                                           ? new IncotermParaAtualizacao("001", "INCOTERM 001")
                                                           : null);
            })
            .Returns(_incotermsMock.Object);

            _incotermsMock.Setup(x => x.List())
            .Returns(() =>
            {
                var retorno = new List <Incoterm>();
                if (_incotermRetornoRepositorio != null)
                {
                    retorno.Add(_incotermRetornoRepositorio);
                }
                return(retorno);
            });

            _cadastroIncoterm = new CadastroIncoterm(_unitOfWorkMock.Object, _incotermsMock.Object);
            _incotermPadrao   = new IncotermCadastroVm()
            {
                Codigo    = "001",
                Descricao = "INCOTERM 001"
            };
            _listaIncoterms = new List <IncotermCadastroVm>()
            {
                _incotermPadrao
            };
        }
Example #19
0
        public ProcessoDeCotacaoAberturaTests()
        {
            _unitOfWorkMock         = CommonMocks.DefaultUnitOfWorkMock();
            _processosDeCotacaoMock = new Mock <IProcessosDeCotacao>(MockBehavior.Strict);
            _processosDeCotacaoMock.Setup(x => x.Save(It.IsAny <ProcessoDeCotacao>()))
            .Callback(
                (ProcessoDeCotacao processoDeCotacao) =>
            {
                _unitOfWorkMock.Verify(x => x.BeginTransaction(), Times.Once());
                _unitOfWorkMock.Verify(x => x.Commit(), Times.Never());
                Assert.IsNotNull(processoDeCotacao);
                foreach (var fornecedorParticipante in processoDeCotacao.FornecedoresParticipantes)
                {
                    Assert.IsNotNull(fornecedorParticipante);
                }
            });

            _processosDeCotacaoMock.Setup(x => x.BuscaPorId(It.IsAny <int>()))
            .Returns(_processosDeCotacaoMock.Object)
            .Callback((int idProcessoCotacao) =>
            {
                _unitOfWorkMock.Verify(x => x.BeginTransaction(), Times.Once());
                _unitOfWorkMock.Verify(x => x.Commit(), Times.Never());
                if (idProcessoCotacao == 10)
                {
                    _processoDeCotacao = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
                    _processoDeCotacao.AdicionarFornecedor(DefaultObjects.ObtemFornecedorPadrao());
                }
                if (idProcessoCotacao == 20)
                {
                    _processoDeCotacao   = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAbertoPadrao();
                    var codigoFornecedor = _processoDeCotacao.FornecedoresParticipantes.First().Fornecedor.Codigo;
                    var cotacao          = _processoDeCotacao.InformarCotacao(codigoFornecedor, DefaultObjects.ObtemCondicaoDePagamentoPadrao(),
                                                                              DefaultObjects.ObtemIncotermPadrao(), "inc");
                    var processoCotacaoItem = _processoDeCotacao.Itens.First();
                    var cotacaoItem         = (CotacaoMaterialItem)cotacao.InformarCotacaoDeItem(processoCotacaoItem, 150, null, 100, DateTime.Today.AddMonths(1), "obs fornec");
                    cotacaoItem.Selecionar(100, DefaultObjects.ObtemIvaPadrao());
                }
            });

            _processosDeCotacaoMock.Setup(x => x.Single()).Returns(() => _processoDeCotacao);

            _comunicacaoSapMock = new Mock <IProcessoDeCotacaoComunicacaoSap>(MockBehavior.Strict);
            _comunicacaoSapMock.Setup(x => x.EfetuarComunicacao(It.IsAny <ProcessoDeCotacao>()))
            .Returns(new ApiResponseMessage
            {
                Retorno = new Retorno
                {
                    Codigo = "200",
                    Texto  = "S"
                }
            });

            _geradorDeEmailMock = new Mock <IGeradorDeEmailDeAberturaDeProcessoDeCotacao>(MockBehavior.Strict);
            _geradorDeEmailMock.Setup(x => x.GerarEmail(It.IsAny <ProcessoDeCotacao>()));

            _gerenciadorUsuarioMock = new Mock <IGerenciadorUsuario>(MockBehavior.Strict);
            _gerenciadorUsuarioMock.Setup(x => x.CriarSenhaParaUsuariosSemSenha(It.IsAny <string[]>()));

            _usuariosMock = new Mock <IUsuarios>(MockBehavior.Strict);
            _usuariosMock.Setup(x => x.UsuarioConectado()).Returns(_usuarioConectado);

            _service = new AberturaDeProcessoDeCotacaoService(_unitOfWorkMock.Object, _processosDeCotacaoMock.Object,
                                                              _geradorDeEmailMock.Object, _comunicacaoSapMock.Object, _gerenciadorUsuarioMock.Object, _usuariosMock.Object);
        }
        public AtualizadorDeCotacaoTests()
        {
            _unitOfWorkMock         = CommonMocks.DefaultUnitOfWorkMock();
            _processoDeCotacao      = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialComCotacaoDoFornecedor();
            _processosDeCotacaoMock = new Mock <IProcessosDeCotacao>(MockBehavior.Strict);
            _processosDeCotacaoMock.Setup(x => x.Save(It.IsAny <ProcessoDeCotacao>()))
            .Callback(
                (ProcessoDeCotacao processoDeCotacao) =>
            {
                _unitOfWorkMock.Verify(x => x.BeginTransaction(), Times.Once());
                _unitOfWorkMock.Verify(x => x.Commit(), Times.Never());
                Assert.IsNotNull(processoDeCotacao);
                foreach (var fornecedorParticipante in processoDeCotacao.FornecedoresParticipantes)
                {
                    Assert.IsNotNull(fornecedorParticipante);
                }
            });

            _processosDeCotacaoMock.Setup(x => x.BuscaPorId(It.IsAny <int>()))
            .Returns(_processosDeCotacaoMock.Object)
            .Callback((int id) =>
            {
                _unitOfWorkMock.Verify(x => x.BeginTransaction(), Times.Once());
                _unitOfWorkMock.Verify(x => x.Commit(), Times.Never());
            });
            _processosDeCotacaoMock.Setup(x => x.Single())
            .Returns(_processoDeCotacao);

            _incotermsMock = new Mock <IIncoterms>(MockBehavior.Strict);
            _incotermsMock.Setup(x => x.BuscaPeloCodigo(It.IsAny <string>()))
            .Returns(_incotermsMock.Object)
            .Callback((string codigo) =>
            {
                _unitOfWorkMock.Verify(x => x.BeginTransaction(), Times.Once());
                _unitOfWorkMock.Verify(x => x.Commit(), Times.Never());
                _incotermRetorno = Incoterm.Codigo == codigo ? Incoterm : null;
            });
            _incotermsMock.Setup(x => x.Single())
            .Returns(() => _incotermRetorno);

            _condicoesDePagamentoMock = new Mock <ICondicoesDePagamento>(MockBehavior.Strict);
            _condicoesDePagamentoMock.Setup(x => x.BuscaPeloCodigo(It.IsAny <string>()))
            .Returns((string codigo) => codigo == CondicaoDePagamento.Codigo ? CondicaoDePagamento : null)
            .Callback((string codigo) =>
            {
                _unitOfWorkMock.Verify(x => x.BeginTransaction(), Times.Once());
                _unitOfWorkMock.Verify(x => x.Commit(), Times.Never());
            });

            _atualizadorDeCotacao = new AtualizadorDeCotacaoDeMaterial(_unitOfWorkMock.Object, _processosDeCotacaoMock.Object, _incotermsMock.Object, _condicoesDePagamentoMock.Object);


            _cotacaoAtualizarVm = new CotacaoMaterialInformarVm()
            {
                IdProcessoCotacao       = _processoDeCotacao.Id,
                CodigoFornecedor        = _processoDeCotacao.FornecedoresParticipantes.First().Fornecedor.Codigo,
                CodigoCondicaoPagamento = CondicaoDePagamento.Codigo,
                CodigoIncoterm          = Incoterm.Codigo,
                DescricaoIncoterm       = "Desc Incoterm",
            };

            _cotacaoItemAtualizarVm = new CotacaoMaterialItemInformarVm
            {
                IdProcessoCotacao     = _processoDeCotacao.Id,
                IdCotacao             = 0,
                IdProcessoCotacaoItem = _processoDeCotacao.Itens.First().Id,
                Preco = 110,
                Mva   = 0,
                QuantidadeDisponivel = 150,
                Impostos             = new CotacaoImpostosVm
                {
                    IcmsAliquota      = 17,
                    IcmsValor         = 12,
                    IcmsStAliquota    = 0,
                    IcmsStValor       = 0,
                    IpiAliquota       = 5,
                    IpiValor          = 4,
                    PisCofinsAliquota = 3
                },
                ObservacoesDoFornecedor = "observações do fornecedor",
                PrazoDeEntrega          = DateTime.Today.AddDays(15).ToShortDateString()
            };
        }