public void QuandoConsultaForneceedoresDeVariosProdutosRetornaListaDeTodosOFornecedoresVinculadosAosProdutosSemRepetir()
{
//cenário: dois produtos, três fornecedores distintos. Sendo que um dos fornecedores está vinculado a ambos produtos.
//Os outros dois fornecedores, cada um está vinculado a um produto.
//Deve retornar uma lista com 3 fornecedores, sem repetir o fornecedor que está compartilhado com os dois produtos.
Produto produto1 = DefaultObjects.ObtemProdutoPadrao();
Produto produto2 = DefaultObjects.ObtemProdutoPadrao();
Fornecedor fornecedor1 = DefaultObjects.ObtemFornecedorPadrao();
Fornecedor fornecedor2 = DefaultObjects.ObtemFornecedorPadrao();
Fornecedor fornecedorCompartilhado = DefaultObjects.ObtemFornecedorPadrao();
produto1.AdicionarFornecedores(new List <Fornecedor> {
fornecedor1, fornecedorCompartilhado
});
produto2.AdicionarFornecedores(new List <Fornecedor> {
fornecedor2, fornecedorCompartilhado
});
DefaultPersistedObjects.PersistirProduto(produto1);
DefaultPersistedObjects.PersistirProduto(produto2);
var consultaProduto = ObjectFactory.GetInstance <IConsultaProduto>();
PaginacaoVm paginacaoVm = DefaultObjects.ObtemPaginacaoDefault();
KendoGridVm kendoGridVm = consultaProduto.FornecedoresDosProdutos(paginacaoVm, new [] { produto1.Codigo, produto2.Codigo });
Assert.AreEqual(3, kendoGridVm.QuantidadeDeRegistros);
IList <FornecedorCadastroVm> registros = kendoGridVm.Registros.Cast <FornecedorCadastroVm>().ToList();
Assert.IsTrue(registros.Any(x => x.Codigo == fornecedor1.Codigo));
Assert.IsTrue(registros.Any(x => x.Codigo == fornecedor2.Codigo));
Assert.IsTrue(registros.Any(x => x.Codigo == fornecedorCompartilhado.Codigo));
}
public void DepoisDePersistirUmProcessoDeCotacaoDeMaterialConsigoConsultar()
{
var processoDeCotacaoDeMaterial = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processoDeCotacaoDeMaterial);
UnitOfWorkNh.Session.Clear();
var processosDeCotacaoDeMaterial = ObjectFactory.GetInstance <IProcessosDeCotacao>();
var processoConsultado = (ProcessoDeCotacaoDeMaterial)processosDeCotacaoDeMaterial.BuscaPorId(processoDeCotacaoDeMaterial.Id).Single();
Assert.IsNotNull(processoConsultado);
Assert.AreEqual(Enumeradores.StatusProcessoCotacao.NaoIniciado, processoConsultado.Status);
Assert.AreEqual(processoDeCotacaoDeMaterial.Id, processoConsultado.Id);
Assert.AreEqual(processoDeCotacaoDeMaterial.DataLimiteDeRetorno, processoConsultado.DataLimiteDeRetorno);
Assert.AreEqual(processoDeCotacaoDeMaterial.Requisitos, processoConsultado.Requisitos);
var item = (ProcessoDeCotacaoDeMaterialItem)processoDeCotacaoDeMaterial.Itens.First();
var itemConsultado = (ProcessoDeCotacaoDeMaterialItem)processoConsultado.Itens.First();
Assert.AreEqual(item.Produto.Codigo, itemConsultado.Produto.Codigo);
Assert.AreEqual(item.UnidadeDeMedida.CodigoInterno, itemConsultado.UnidadeDeMedida.CodigoInterno);
Assert.IsFalse(NHibernateUtil.IsInitialized(itemConsultado.RequisicaoDeCompra));
Assert.AreEqual(item.RequisicaoDeCompra.Id, itemConsultado.RequisicaoDeCompra.Id);
}
public void QuandoConsultarFornecedoresDoProdutoRetornaListaDeViewModels()
{
//preparando o cenários
Fornecedor fornecedor01 = DefaultObjects.ObtemFornecedorPadrao();
Fornecedor fornecedor02 = DefaultObjects.ObtemFornecedorPadrao();
Produto produto = DefaultObjects.ObtemProdutoPadrao();
produto.AdicionarFornecedores(new List <Fornecedor>()
{
fornecedor01, fornecedor02
});
DefaultPersistedObjects.PersistirProduto(produto);
var consultaProduto = ObjectFactory.GetInstance <IConsultaProduto>();
var paginacaoVm = new PaginacaoVm
{
Page = 1,
PageSize = 10,
Take = 10
};
var kendoGridVm = consultaProduto.FornecedoresDoProduto(paginacaoVm, produto.Codigo);
Assert.AreEqual(2, kendoGridVm.QuantidadeDeRegistros);
var viewModels = kendoGridVm.Registros.Cast <FornecedorCadastroVm>().ToList();
Assert.AreEqual(1, viewModels.Count(x => x.Codigo == fornecedor01.Codigo));
Assert.AreEqual(1, viewModels.Count(x => x.Codigo == fornecedor02.Codigo));
}
public void ConsultaListagemDeProcessosRetornaObjetoEsperado()
{
RemoveQueries.RemoverProcessosDeCotacaoCadastrados();
ProcessoDeCotacaoDeMaterial processoDeCotacaoDeMaterial = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processoDeCotacaoDeMaterial);
var consultaProcesso = ObjectFactory.GetInstance <IConsultaProcessoDeCotacaoDeMaterial>();
KendoGridVm kendoGridVm = consultaProcesso.Listar(new PaginacaoVm()
{
Page = 1, PageSize = 10, Take = 10
},
new ProcessoCotacaoFiltroVm());
Assert.AreEqual(1, kendoGridVm.QuantidadeDeRegistros);
ProcessoCotacaoMaterialListagemVm processoListagem = kendoGridVm.Registros.Cast <ProcessoCotacaoMaterialListagemVm>().First();
Assert.AreEqual(processoDeCotacaoDeMaterial.Id, processoListagem.Id);
//Assert.AreEqual(processoDeCotacaoDeMaterial.Itens.First().Produto.Codigo, processoListagem.CodigoMaterial);
Assert.AreEqual(processoDeCotacaoDeMaterial.Itens.First().Produto.Descricao, processoListagem.Material);
//Assert.AreEqual(1000, processoListagem.Quantidade);
Assert.AreEqual("Não Iniciado", processoListagem.Status);
Assert.IsNotNull(processoDeCotacaoDeMaterial.DataLimiteDeRetorno);
Assert.AreEqual(processoDeCotacaoDeMaterial.DataLimiteDeRetorno.Value.ToShortDateString(), processoListagem.DataTermino);
}
public void QuandoInformoImpostosDeUmaCotacaoRetornaOsDadosDosImpostos()
{
ProcessoDeCotacaoDeMaterial processo = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAbertoPadrao();
Fornecedor fornecedor = processo.FornecedoresParticipantes.First().Fornecedor;
var cotacao = processo.InformarCotacao(fornecedor.Codigo, DefaultObjects.ObtemCondicaoDePagamentoPadrao(),
DefaultObjects.ObtemIncotermPadrao(), "Desc Incoterm");
var itemDoProcesso = (ProcessoDeCotacaoDeMaterialItem)processo.Itens.First();
RequisicaoDeCompra requisicaoDeCompra = itemDoProcesso.RequisicaoDeCompra;
var cotacaoItem = cotacao.InformarCotacaoDeItem(itemDoProcesso, 100, 120, 12, DateTime.Today.AddMonths(1), "observacoes");
cotacaoItem.InformarImposto(Enumeradores.TipoDeImposto.Icms, 1);
cotacaoItem.InformarImposto(Enumeradores.TipoDeImposto.IcmsSubstituicao, 11);
cotacaoItem.InformarImposto(Enumeradores.TipoDeImposto.Ipi, 21);
cotacaoItem.InformarImposto(Enumeradores.TipoDeImposto.PisCofins, 3);
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processo);
var consulta = ObjectFactory.GetInstance <IConsultaCotacaoDoFornecedor>();
CotacaoImpostosVm vm = consulta.ConsultarCotacaoDeItemDeMaterial(processo.Id, fornecedor.Codigo, requisicaoDeCompra.Numero, requisicaoDeCompra.NumeroItem).Impostos;
Assert.AreEqual(1, vm.IcmsAliquota);
Assert.AreEqual(1, vm.IcmsValor);
Assert.AreEqual(11, vm.IcmsStAliquota);
Assert.AreEqual(11, vm.IcmsStValor);
Assert.AreEqual(21, vm.IpiAliquota);
Assert.AreEqual(21, vm.IpiValor);
Assert.AreEqual(3, vm.PisCofinsValor);
Assert.AreEqual(3, vm.PisCofinsAliquota);
}
public void QuandoConsultoUmaCotacaoDoFornecedorQueJaFoiPreenchidaRetornaOsDadosEsperados()
{
ProcessoDeCotacaoDeMaterial processo = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAbertoPadrao();
Fornecedor fornecedor = processo.FornecedoresParticipantes.First().Fornecedor;
var cotacao = processo.InformarCotacao(fornecedor.Codigo, DefaultObjects.ObtemCondicaoDePagamentoPadrao(),
DefaultObjects.ObtemIncotermPadrao(),
"Desc Incoterm");
var processoCotacaoItem = processo.Itens.First();
cotacao.InformarCotacaoDeItem(processoCotacaoItem, 100, 120, 12, DateTime.Today.AddMonths(1), "observacoes");
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processo);
var consulta = ObjectFactory.GetInstance <IConsultaCotacaoDoFornecedor>();
CotacaoMaterialCadastroVm vm = consulta.ConsultarCotacaoDeMaterial(processo.Id, fornecedor.Codigo);
Assert.IsNotNull(vm);
Assert.AreEqual(processo.Id, vm.IdProcessoCotacao);
Assert.AreEqual(cotacao.Id, vm.IdCotacao);
Assert.AreEqual(cotacao.CondicaoDePagamento.Codigo, vm.CodigoCondicaoPagamento);
Assert.AreEqual(cotacao.Incoterm.Codigo, vm.CodigoIncoterm);
Assert.AreEqual("Desc Incoterm", vm.DescricaoIncoterm);
Assert.AreEqual(fornecedor.Codigo, vm.CodigoFornecedor);
Assert.IsTrue(processo.DataLimiteDeRetorno.HasValue);
Assert.AreEqual(processo.DataLimiteDeRetorno.Value.ToShortDateString(), vm.DataLimiteDeRetorno);
Assert.AreEqual("Aberto", vm.Status);
}
public void RetornaListaComTodosFornecedoresParticipantesDoProcessoDeCotacao()
{
//crio um processo de cotação de materiais
ProcessoDeCotacaoDeMaterial processoDeCotacao = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialNaoIniciado();
processoDeCotacao.Atualizar(DateTime.Today.AddDays(4), "req");
Fornecedor fornecedor1 = DefaultObjects.ObtemFornecedorPadrao();
Fornecedor fornecedor2 = DefaultObjects.ObtemFornecedorPadrao();
Fornecedor fornecedor3 = DefaultObjects.ObtemFornecedorPadrao();
processoDeCotacao.AdicionarFornecedor(fornecedor1);
processoDeCotacao.AdicionarFornecedor(fornecedor2);
processoDeCotacao.AdicionarFornecedor(fornecedor3);
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processoDeCotacao);
var consulta = ObjectFactory.GetInstance <IConsultaProcessoDeCotacaoDeMaterial>();
FornecedorVm[] fornecedores = consulta.ListarFornecedores(processoDeCotacao.Id);
Assert.AreEqual(3, fornecedores.Count());
Assert.IsTrue(fornecedores.Any(x => x.Codigo == fornecedor1.Codigo && x.Nome == fornecedor1.Nome));
Assert.IsTrue(fornecedores.Any(x => x.Codigo == fornecedor2.Codigo && x.Nome == fornecedor2.Nome));
Assert.IsTrue(fornecedores.Any(x => x.Codigo == fornecedor3.Codigo && x.Nome == fornecedor3.Nome));
}
public void QuandoConsultaCotacaoResumidaAntesDoFornecedorInformarCotacaoRetornaObjetoEsperado()
{
ProcessoDeCotacaoDeFrete processoDeCotacao = DefaultObjects.ObtemProcessoDeCotacaoDeFrete();
Fornecedor fornecedor = DefaultObjects.ObtemFornecedorPadrao();
FornecedorParticipante fornecedorParticipante = processoDeCotacao.AdicionarFornecedor(fornecedor);
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeFrete(processoDeCotacao);
UnitOfWorkNh.Session.Clear();
var consultaProcesso = ObjectFactory.GetInstance <IConsultaProcessoDeCotacaoDeMaterial>();
KendoGridVm kendoGridVm = consultaProcesso.CotacoesDosFornecedoresResumido(processoDeCotacao.Id);
Assert.AreEqual(1, kendoGridVm.QuantidadeDeRegistros);
var processoCotacaoFornecedorVm = (ProcessoCotacaoFornecedorVm)kendoGridVm.Registros.First();
Assert.AreEqual(fornecedorParticipante.Id, processoCotacaoFornecedorVm.IdFornecedorParticipante);
Assert.AreEqual(fornecedor.Codigo, processoCotacaoFornecedorVm.Codigo);
Assert.AreEqual(fornecedor.Nome, processoCotacaoFornecedorVm.Nome);
Assert.AreEqual("Não", processoCotacaoFornecedorVm.Selecionado);
Assert.IsNull(processoCotacaoFornecedorVm.ValorLiquido);
Assert.IsNull(processoCotacaoFornecedorVm.ValorComImpostos);
Assert.IsNull(processoCotacaoFornecedorVm.QuantidadeDisponivel);
Assert.AreEqual("Não", processoCotacaoFornecedorVm.VisualizadoPeloFornecedor);
}
public void QuandoConsultaProcessosDeCotacaoDeUmDeterminadoFornecedorNaoConsideraOsProcessosNaoIniciados()
{
//crio um fornecedor e adiciono ele em uma cotação aberta e uma não iniciada
Fornecedor fornecedor1 = DefaultObjects.ObtemFornecedorPadrao();
ProcessoDeCotacaoDeMaterial processoDeCotacao1 = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
ProcessoDeCotacaoDeMaterial processoDeCotacao2 = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
processoDeCotacao1.AdicionarFornecedor(fornecedor1);
processoDeCotacao1.Abrir(DefaultObjects.ObtemUsuarioPadrao());
processoDeCotacao2.AdicionarFornecedor(fornecedor1);
DefaultPersistedObjects.PersistirProcessosDeCotacaoDeMaterial(new List <ProcessoDeCotacaoDeMaterial>()
{
processoDeCotacao1, processoDeCotacao2
});
var consultaProcesso = ObjectFactory.GetInstance <IConsultaProcessoDeCotacaoDeMaterial>();
//consulta filtrando pelo fornecedor
KendoGridVm kendoGridVm = consultaProcesso.Listar(new PaginacaoVm()
{
Page = 1, PageSize = 10, Take = 10
},
new ProcessoCotacaoFiltroVm()
{
CodigoFornecedor = fornecedor1.Codigo
});
Assert.AreEqual(1, kendoGridVm.QuantidadeDeRegistros);
var viewModels = kendoGridVm.Registros.Cast <ProcessoCotacaoMaterialListagemVm>().ToList();
//verifico que está retornado apenas o processo que foi aberto
Assert.IsNotNull(viewModels.First(x => x.Id == processoDeCotacao1.Id));
}
public void QuandoConsultoUmaCotacaoDoFornecedorParaUmItemQueJaFoiPreenchidaRetornaOsDadosEsperados()
{
ProcessoDeCotacaoDeMaterial processo = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAbertoPadrao();
Fornecedor fornecedor = processo.FornecedoresParticipantes.First().Fornecedor;
var cotacao = processo.InformarCotacao(fornecedor.Codigo, DefaultObjects.ObtemCondicaoDePagamentoPadrao(),
DefaultObjects.ObtemIncotermPadrao(),
"Desc Incoterm");
var processoCotacaoItem = processo.Itens.First();
var cotacaoItem = cotacao.InformarCotacaoDeItem(processoCotacaoItem, 100, 120, 12, DateTime.Today.AddMonths(1), "observacoes");
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processo);
var consulta = ObjectFactory.GetInstance <IConsultaCotacaoDoFornecedor>();
var itemDoProcesso = (ProcessoDeCotacaoDeMaterialItem)processo.Itens.First();
RequisicaoDeCompra requisicaoDeCompra = itemDoProcesso.RequisicaoDeCompra;
CotacaoMaterialItemCadastroVm vm = consulta.ConsultarCotacaoDeItemDeMaterial(processo.Id, fornecedor.Codigo, requisicaoDeCompra.Numero, requisicaoDeCompra.NumeroItem);
Assert.IsNotNull(vm);
Assert.AreEqual(processo.Id, vm.IdProcessoCotacao);
Assert.AreEqual(cotacao.Id, vm.IdCotacao);
Assert.AreEqual(cotacaoItem.Id, vm.IdCotacaoItem);
Assert.AreEqual(itemDoProcesso.Id, vm.IdProcessoCotacaoItem);
Assert.AreEqual(itemDoProcesso.Produto.Descricao, vm.Material);
Assert.AreEqual(itemDoProcesso.Quantidade, vm.Quantidade);
Assert.AreEqual(itemDoProcesso.UnidadeDeMedida.Descricao, vm.UnidadeDeMedida);
Assert.AreEqual(100, vm.ValorComImpostos);
Assert.AreEqual(100, vm.Custo);
Assert.AreEqual(100, vm.Preco);
Assert.AreEqual(120, vm.Mva);
}
public void QuandoConsultoRequisicoesDisponiveisParaUmProcessoDeCotacaoListaAsRequisicoesQueJaEstaoAssociadasAoProcessoETambemAsQueNaoEstaoAssociadasANenhumOutroProcesso()
{
//Cria duas requisições de compra: 1 e 2
//Cria um processo de cotação 1 e associa a requisição 1 com este processo
//Salva os registros
//Depois consultar novamente as requisições para o processo 1: deve listar as requisiões 1 e 2
RemoveQueries.RemoverRequisicoesDeCompraCadastradas();
RequisicaoDeCompra requisicao1 = DefaultObjects.ObtemRequisicaoDeCompraPadrao();
RequisicaoDeCompra requisicao2 = DefaultObjects.ObtemRequisicaoDeCompraPadrao();
var processo1 = new ProcessoDeCotacaoDeMaterial();
processo1.AdicionarItem(requisicao1);
DefaultPersistedObjects.PersistirRequisicaoDeCompra(requisicao1);
DefaultPersistedObjects.PersistirRequisicaoDeCompra(requisicao2);
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processo1);
var consultaRequisicao = ObjectFactory.GetInstance <IConsultaRequisicaoDeCompra>();
var kendoGridVm = consultaRequisicao.Listar(DefaultObjects.ObtemPaginacaoDefault(), new RequisicaoDeCompraFiltroVm(processo1.Id));
Assert.AreEqual(2, kendoGridVm.QuantidadeDeRegistros);
}
public void QuandoFiltraFornecedoresPorNomeRetornaListaEContabemDeRegistrosCorreta()
{
Fornecedor fornecedor1 = DefaultObjects.ObtemFornecedorPadrao();
Fornecedor fornecedor2 = DefaultObjects.ObtemFornecedorPadrao();
Fornecedor fornecedor3 = DefaultObjects.ObtemFornecedorPadrao();
fornecedor2.Atualizar("CARLOS EDUARDO DA SILVA", fornecedor2.Email, "", "", "", false);
fornecedor3.Atualizar("LUIS EDUARDO SILVA", fornecedor3.Email, "", "", "", false);
DefaultPersistedObjects.PersistirFornecedor(fornecedor1);
DefaultPersistedObjects.PersistirFornecedor(fornecedor2);
DefaultPersistedObjects.PersistirFornecedor(fornecedor3);
var consultaFornecedor = ObjectFactory.GetInstance <IConsultaFornecedor>();
var paginacaoVm = new PaginacaoVm()
{
Page = 1,
PageSize = 10,
Take = 10
};
var filtro = new FornecedorFiltroVm
{
Nome = "eduardo"
};
KendoGridVm kendoGridVm = consultaFornecedor.Listar(paginacaoVm, filtro);
Assert.AreEqual(2, kendoGridVm.QuantidadeDeRegistros);
}
public void QuandoUmaRequisicaoDeCompraJaGerouUmProcessoDeCotacaoNaoApareceMaisDisponivelParaOutrosProcessos()
{
//Cria duas requisições de compra: 1 e 2
//Cria um processo de cotação e associa a requisição 1 com este processo
//Cria um novo processo de cotação, salva e Lista as requisições para este processo. A requisição ' não deve aparecer.
RemoveQueries.RemoverRequisicoesDeCompraCadastradas();
RequisicaoDeCompra requisicao1 = DefaultObjects.ObtemRequisicaoDeCompraPadrao();
RequisicaoDeCompra requisicao2 = DefaultObjects.ObtemRequisicaoDeCompraPadrao();
var processo1 = new ProcessoDeCotacaoDeMaterial();
processo1.AdicionarItem(requisicao1);
var processo2 = new ProcessoDeCotacaoDeMaterial();
DefaultPersistedObjects.PersistirRequisicaoDeCompra(requisicao2);
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processo1);
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processo2);
var consultaRequisicao = ObjectFactory.GetInstance <IConsultaRequisicaoDeCompra>();
var kendoGridVm = consultaRequisicao.Listar(DefaultObjects.ObtemPaginacaoDefault(), new RequisicaoDeCompraFiltroVm(processo2.Id));
Assert.AreEqual(1, kendoGridVm.QuantidadeDeRegistros);
var requisicaoDeCompraVm = kendoGridVm.Registros.Cast <RequisicaoDeCompraVm>().Single();
Assert.AreEqual(requisicao2.Numero, requisicaoDeCompraVm.NumeroRequisicao);
Assert.AreEqual(requisicao2.NumeroItem, requisicaoDeCompraVm.NumeroItem);
}
public void DepoisDePersistirUmaRequisicaoDeCompraConsigoConsultar()
{
var requisicaoDeCompra = DefaultObjects.ObtemRequisicaoDeCompraPadrao();
DefaultPersistedObjects.PersistirRequisicaoDeCompra(requisicaoDeCompra);
UnitOfWorkNh.Session.Clear();
RequisicaoDeCompra requisicaoConsultada = _requisicoesDeCompra.BuscaPeloId(requisicaoDeCompra.Id);
Assert.IsNotNull(requisicaoConsultada);
Assert.AreEqual(requisicaoDeCompra.Criador.Login, requisicaoConsultada.Criador.Login);
Assert.AreEqual("requisitante", requisicaoConsultada.Requisitante);
Assert.AreEqual(requisicaoDeCompra.FornecedorPretendido.Codigo, requisicaoConsultada.FornecedorPretendido.Codigo);
Assert.AreEqual(requisicaoDeCompra.Material.Codigo, requisicaoConsultada.Material.Codigo);
Assert.AreEqual(DateTime.Today.AddDays(-2), requisicaoConsultada.DataDeRemessa);
Assert.AreEqual(DateTime.Today.AddDays(-1), requisicaoConsultada.DataDeLiberacao);
Assert.AreEqual(DateTime.Today, requisicaoConsultada.DataDeSolicitacao);
Assert.AreEqual("C001", requisicaoConsultada.Centro);
Assert.AreEqual(requisicaoDeCompra.UnidadeMedida.CodigoInterno, requisicaoConsultada.UnidadeMedida.CodigoInterno);
Assert.AreEqual(1000, requisicaoConsultada.Quantidade);
Assert.AreEqual("Requisição de Compra enviada pelo SAP", requisicaoConsultada.Descricao);
Assert.AreEqual(requisicaoDeCompra.Numero, requisicaoConsultada.Numero);
Assert.AreEqual(requisicaoDeCompra.NumeroItem, requisicaoConsultada.NumeroItem);
Assert.AreEqual(requisicaoDeCompra.CodigoGrupoDeCompra, requisicaoConsultada.CodigoGrupoDeCompra);
Assert.AreEqual(requisicaoDeCompra.Mrp, requisicaoConsultada.Mrp);
}
public void ConsigoPersistirEConsultarUmProcessoDeCotacaoComImpostosNasCotacoes()
{
ProcessoDeCotacaoDeMaterial processoDeCotacaoDeMaterial = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
Fornecedor fornecedor = DefaultObjects.ObtemFornecedorPadrao();
processoDeCotacaoDeMaterial.AdicionarFornecedor(fornecedor);
processoDeCotacaoDeMaterial.Abrir(DefaultObjects.ObtemUsuarioPadrao());
var cotacao = processoDeCotacaoDeMaterial.InformarCotacao(fornecedor.Codigo, DefaultObjects.ObtemCondicaoDePagamentoPadrao(), DefaultObjects.ObtemIncotermPadrao(), "inc");
var processoCotacaoItem = processoDeCotacaoDeMaterial.Itens.First();
var cotacaoItem = cotacao.InformarCotacaoDeItem(processoCotacaoItem, 100, 120, 100, DateTime.Today.AddMonths(1), "obs fornec");
cotacaoItem.InformarImposto(Enumeradores.TipoDeImposto.Icms, 17);
cotacaoItem.InformarImposto(Enumeradores.TipoDeImposto.Ipi, 5);
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processoDeCotacaoDeMaterial);
var processosDeCotacaoDeMaterial = ObjectFactory.GetInstance <IProcessosDeCotacao>();
Console.WriteLine("Consultando Cotacao - INICIO");
var processoConsultado = (ProcessoDeCotacaoDeMaterial)processosDeCotacaoDeMaterial.BuscaPorId(processoDeCotacaoDeMaterial.Id).Single();
Cotacao cotacaoConsultada = processoConsultado.FornecedoresParticipantes.First().Cotacao;
Assert.AreEqual(2, cotacaoConsultada.Itens.First().Impostos.Count);
Console.WriteLine("Consultando Cotacao - FIM");
}
public void QuandoFiltraPorUsuariosSemSenhaTodosUsuariosRetornadosNaoPossuemSenha()
{
RemoveQueries.RemoverUsuariosCadastrados();
Usuario usuario1 = DefaultObjects.ObtemUsuarioPadrao();
usuario1.CriarSenha("123456");
Usuario usuario2 = DefaultObjects.ObtemUsuarioPadrao();
Usuario usuario3 = DefaultObjects.ObtemUsuarioPadrao();
DefaultPersistedObjects.PersistirUsuario(usuario1);
DefaultPersistedObjects.PersistirUsuario(usuario2);
DefaultPersistedObjects.PersistirUsuario(usuario3);
UnitOfWorkNh.Session.Clear();
var usuarios = ObjectFactory.GetInstance <IUsuarios>();
IList <Usuario> usuariosSelecionados = usuarios.SemSenha().List();
Assert.AreEqual(2, usuariosSelecionados.Count);
foreach (var usuarioSelecionado in usuariosSelecionados)
{
Assert.IsNull(usuarioSelecionado.Senha);
}
}
public void QuandoConsultaCotacaoDeFornecedoresQueNaoInformaramCotacaoRetornaDadosEsperados()
{
ProcessoDeCotacaoDeFrete processo = DefaultObjects.ObtemProcessoDeCotacaoDeFreteComFornecedor();
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeFrete(processo);
FornecedorParticipante fornecedorParticipante = processo.FornecedoresParticipantes.Single();
Fornecedor fornecedor = fornecedorParticipante.Fornecedor;
var consulta = ObjectFactory.GetInstance <IConsultaProcessoDeCotacaoDeFrete>();
IList <CotacaoSelecionarVm> cotacoes = consulta.CotacoesDosFornecedores(processo.Id);
Assert.AreEqual(1, cotacoes.Count);
var cotacaoSelecionarVm = cotacoes.Single();
Assert.AreEqual(fornecedor.Cnpj, cotacaoSelecionarVm.Cnpj);
Assert.AreEqual(fornecedor.Nome, cotacaoSelecionarVm.Fornecedor);
Assert.AreEqual(fornecedor.Codigo, cotacaoSelecionarVm.CodigoFornecedor);
Assert.AreEqual(0, cotacaoSelecionarVm.IdCotacao);
Assert.AreEqual(0, cotacaoSelecionarVm.IdProcessoCotacaoItem);
Assert.IsFalse(cotacaoSelecionarVm.Selecionada);
Assert.IsNull(cotacaoSelecionarVm.QuantidadeAdquirida);
Assert.IsNull(cotacaoSelecionarVm.QuantidadeDisponivel);
Assert.IsNull(cotacaoSelecionarVm.ValorComImpostos);
Assert.IsNull(cotacaoSelecionarVm.ObservacaoDoFornecedor);
}
public static void Inicializar(TestContext testContext)
{
Initialize(testContext);
Usuario usuario = DefaultObjects.ObtemUsuarioPadrao();
usuario.AdicionarPerfil(Enumeradores.Perfil.AgendadorDeCargas);
DefaultPersistedObjects.PersistirUsuario(usuario);
BaseTestClass.SubstituirUsuarioConectado(new UsuarioConectado(usuario.Login, usuario.Nome, usuario.Perfis));
}
public void QuandoConsultaQuotaEmUmaDataQueNaoPossuiQuotaRetornaFalso()
{
//RemoveQueries.RemoverQuotasCadastradas();
var quota = new Quota(Enumeradores.MaterialDeCarga.Soja, DefaultObjects.ObtemTransportadoraPadrao(),
"1000", DateTime.Today, 1200);
DefaultPersistedObjects.PersistirQuota(quota);
var consultaQuota = ObjectFactory.GetInstance <IConsultaQuota>();
Assert.IsFalse(consultaQuota.PossuiQuotaNaData(DateTime.Today.AddDays(-10)));
}
public void QuandoConsultaQuotasEmUmaDeterminadaDataRetornaListaDeQuotasDeTodosOsFornecedoresDaquelaData()
{
RemoveQueries.RemoverQuotasCadastradas();
Quota quota = DefaultObjects.ObtemQuotaDeCarregamento();
DefaultPersistedObjects.PersistirQuota(quota);
var consultaQuota = ObjectFactory.GetInstance <IConsultaQuota>();
IList <QuotaConsultarVm> quotas = consultaQuota.QuotasDaData(quota.Data);
Assert.AreEqual(1, quotas.Count);
}
public void ConsigoConsultarOsDadosDeUmProcesso()
{
ProcessoDeCotacaoDeFrete processo = DefaultObjects.ObtemProcessoDeCotacaoDeFrete();
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeFrete(processo);
var consulta = ObjectFactory.GetInstance <IConsultaProcessoDeCotacaoDeFrete>();
ProcessoCotacaoFreteCadastroVm viewModel = consulta.ConsultaProcesso(processo.Id);
Assert.IsNotNull(viewModel);
}
public void ConsigoPersistirUmProcessoDeCotacaoDeFreteEConsultarPosteriormente()
{
ProcessoDeCotacaoDeFrete processo = DefaultObjects.ObtemProcessoDeCotacaoDeFrete();
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeFrete(processo);
UnitOfWorkNh.Session.Clear();
var processosDeCotacao = ObjectFactory.GetInstance <IProcessosDeCotacao>();
ProcessoDeCotacao processoConsultado = processosDeCotacao.BuscaPorId(processo.Id).Single();
Assert.IsNotNull(processoConsultado);
Assert.AreEqual(1, processoConsultado.Itens.Count);
}
public void ConsigoPersistirEConsultarUmProcessoDeCotacaoComFornecedores()
{
ProcessoDeCotacaoDeMaterial processoDeCotacaoDeMaterial = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAbertoPadrao();
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processoDeCotacaoDeMaterial);
var processosDeCotacaoDeMaterial = ObjectFactory.GetInstance <IProcessosDeCotacao>();
//sou obrigado a executar o método Clear aqui, caso contrário o objeto que foi persistido fica em cache
UnitOfWorkNh.Session.Clear();
var processoConsultado = (ProcessoDeCotacaoDeMaterial)processosDeCotacaoDeMaterial.BuscaPorId(processoDeCotacaoDeMaterial.Id).Single();
Assert.AreEqual(processoDeCotacaoDeMaterial.FornecedoresParticipantes.Count, processoConsultado.FornecedoresParticipantes.Count);
}
public void QuandoConsultaPerfisDoUsuarioRetornaListaDePerfis()
{
Usuario usuario = DefaultObjects.ObtemUsuarioPadrao();
usuario.AdicionarPerfil(Enumeradores.Perfil.AgendadorDeCargas);
usuario.AdicionarPerfil(Enumeradores.Perfil.CompradorLogistica);
DefaultPersistedObjects.PersistirUsuario(usuario);
var consultaUsuario = ObjectFactory.GetInstance <IConsultaUsuario>();
IList <PerfilVm> perfisVm = consultaUsuario.PerfisDoUsuario(usuario.Login);
Assert.AreEqual(2, perfisVm.Count);
}
public void FiltrarUmProcessoDeCotacaoPorStatusRetornaProcessoEsperado()
{
RemoveQueries.RemoverProcessosDeCotacaoCadastrados();
ProcessoDeCotacaoDeMaterial processoDeCotacao1 = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialNaoIniciado();
ProcessoDeCotacaoDeMaterial processoDeCotacao2 = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialFechado();
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processoDeCotacao1);
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processoDeCotacao2);
var processosDeCotacao = ObjectFactory.GetInstance <IProcessosDeCotacao>();
IList <ProcessoDeCotacao> processosConsultados = processosDeCotacao.FiltraPorStatus(Enumeradores.StatusProcessoCotacao.NaoIniciado).List();
Assert.AreEqual(1, processosConsultados.Count());
Assert.AreEqual(Enumeradores.StatusProcessoCotacao.NaoIniciado, processosConsultados.First().Status);
}
public void ConsigoListarAsRequisicoesDeCompra()
{
RemoveQueries.RemoverRequisicoesDeCompraCadastradas();
RequisicaoDeCompra requisicao1 = DefaultObjects.ObtemRequisicaoDeCompraPadrao();
RequisicaoDeCompra requisicao2 = DefaultObjects.ObtemRequisicaoDeCompraPadrao();
DefaultPersistedObjects.PersistirRequisicaoDeCompra(requisicao1);
DefaultPersistedObjects.PersistirRequisicaoDeCompra(requisicao2);
var consultaRequisicao = ObjectFactory.GetInstance <IConsultaRequisicaoDeCompra>();
var kendoGridVm = consultaRequisicao.Listar(DefaultObjects.ObtemPaginacaoDefault(), new RequisicaoDeCompraFiltroVm(10));
Assert.AreEqual(2, kendoGridVm.QuantidadeDeRegistros);
}
public void ConsigoConsultarUmAgendamentoPeloNumeroDaNotaFiscal()
{
Quota quota = DefaultObjects.ObtemQuotaDeDescarregamento();
//AgendamentoDeDescarregamento agendamento = DefaultObjects.ObtemAgendamentoDeDescarregamento(quota);
var agendamentoVm = new AgendamentoDeDescarregamentoSalvarVm
{
IdQuota = quota.Id,
Placa = "IOQ5338",
IdAgendamento = 0,
NotasFiscais = new List <NotaFiscalVm>
{
new NotaFiscalVm
{
Numero = "1234",
Serie = "1",
DataDeEmissao = DateTime.Today.ToShortDateString(),
CnpjDoEmitente = "123",
NomeDoEmitente = "Emitente",
CnpjDoContratante = "666",
NomeDoContratante = "contratante",
NumeroDoContrato = "4001",
Peso = 100,
Valor = 150
}
}
};
quota.InformarAgendamento(agendamentoVm);
DefaultPersistedObjects.PersistirQuota(quota);
var consultaQuota = ObjectFactory.GetInstance <IConsultaQuota>();
UnitOfWorkNh.Session.Clear();
var filtro = new ConferenciaDeCargaFiltroVm
{
CodigoTerminal = "1000",
NumeroNf = "1234"/*,
* CodigoRealizacaoDeAgendamento = (int) Enumeradores.RealizacaoDeAgendamento.NaoRealizado*/
};
KendoGridVm kendoGridVm = consultaQuota.Consultar(new PaginacaoVm {
Page = 1, PageSize = 10, Take = 10
}, filtro);
Assert.AreEqual(1, kendoGridVm.QuantidadeDeRegistros);
}
public void ConsigoFiltrarQuotaPorTerminal()
{
RemoveQueries.RemoverQuotasCadastradas();
Quota quota1 = DefaultObjects.ObtemQuotaDeDescarregamentoParaTerminalEspecifico("1000");
Quota quota2 = DefaultObjects.ObtemQuotaDeDescarregamentoParaTerminalEspecifico("2000");
DefaultPersistedObjects.PersistirQuota(quota1);
DefaultPersistedObjects.PersistirQuota(quota2);
var quotas = ObjectFactory.GetInstance <IQuotas>();
IList <Quota> quotasConsultadas = quotas.DoTerminal("1000").List();
Assert.AreEqual(1, quotasConsultadas.Count());
var quotaConsultada = quotasConsultadas.First();
Assert.AreEqual("1000", quotaConsultada.CodigoTerminal);
}
public void ConsultaProcessoRetornaObjetoEsperado()
{
RemoveQueries.RemoverProcessosDeCotacaoCadastrados();
ProcessoDeCotacaoDeMaterial processoDeCotacaoDeMaterial = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processoDeCotacaoDeMaterial);
var consultaProcesso = ObjectFactory.GetInstance <IConsultaProcessoDeCotacaoDeMaterial>();
ProcessoCotacaoMaterialCadastroVm processoCotacaoMaterialCadastroVm = consultaProcesso.ConsultaProcesso(processoDeCotacaoDeMaterial.Id);
Assert.AreEqual(processoDeCotacaoDeMaterial.Id, processoCotacaoMaterialCadastroVm.Id);
//Assert.AreEqual(processoDeCotacaoDeMaterial.Itens.First().Produto.Codigo,processoCotacaoMaterialCadastroVm.CodigoMaterial);
Assert.IsTrue(processoDeCotacaoDeMaterial.DataLimiteDeRetorno.HasValue);
Assert.AreEqual(processoDeCotacaoDeMaterial.DataLimiteDeRetorno.Value.ToShortDateString(), processoCotacaoMaterialCadastroVm.DataLimiteRetorno);
Assert.AreEqual("Não Iniciado", processoCotacaoMaterialCadastroVm.DescricaoStatus);
Assert.AreEqual("Requisitos do Processo de Cotação de Materiais", processoCotacaoMaterialCadastroVm.Requisitos);
}
public void RepositorioDoProcessoDeCotacaoDeMateriasContemApenasProcessosDeCotacaoDeMaterial()
{
RemoveQueries.RemoverProcessosDeCotacaoCadastrados();
//crio dois processos de cotação (um de frete e um de materiais) e persisto
ProcessoDeCotacaoDeMaterial processoDeCotacaoDeMaterial = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialNaoIniciado();
ProcessoDeCotacaoDeFrete processoDeCotacaoDeFrete = DefaultObjects.ObtemProcessoDeCotacaoDeFrete();
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processoDeCotacaoDeMaterial);
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeFrete(processoDeCotacaoDeFrete);
//listo todos os processsos do repositório: deve retornar apenas o processo de cotação de material
var processosDeCotacaoDeMaterias = ObjectFactory.GetInstance <IProcessosDeCotacaoDeMaterial>();
var todosProcessos = processosDeCotacaoDeMaterias.List();
Assert.AreEqual(1, todosProcessos.Count);
Assert.IsInstanceOfType(todosProcessos.Single(), typeof(ProcessoDeCotacaoDeMaterial));
}
