public void QuandoCrioUmaRequisicaoAsPropriedadesFicamCorretas()
{
var usuarioCriador = new Usuario("Usuario Criador", "criador", "");
Fornecedor fornecedorPretendido = DefaultObjects.ObtemFornecedorPadrao();
UnidadeDeMedida unidadeDeMedida = DefaultObjects.ObtemUnidadeDeMedidaPadrao();
var material = new Produto("MAT0001", "MATERIAL DE COMPRA", "T01");
var dataDeRemessa = DateTime.Today.AddDays(-2);
var dataDeLiberacao = DateTime.Today.AddDays(-1);
var dataDeSolicitacao = DateTime.Today;
var requisicaoDeCompra = new RequisicaoDeCompra(usuarioCriador, "requisitante", fornecedorPretendido,
dataDeRemessa, dataDeLiberacao, dataDeSolicitacao, "CENTRO", unidadeDeMedida, 1000,
material, "Requisição de Compra enviada pelo SAP", "ITEM001", "REQ0001", "GC1", false);
Assert.AreEqual("criador", requisicaoDeCompra.Criador.Login);
Assert.AreEqual("requisitante", requisicaoDeCompra.Requisitante);
Assert.AreEqual(fornecedorPretendido.Codigo, requisicaoDeCompra.FornecedorPretendido.Codigo);
Assert.AreEqual("MAT0001", requisicaoDeCompra.Material.Codigo);
Assert.AreEqual(dataDeRemessa, requisicaoDeCompra.DataDeRemessa);
Assert.AreEqual(dataDeLiberacao, requisicaoDeCompra.DataDeLiberacao);
Assert.AreEqual(dataDeSolicitacao, requisicaoDeCompra.DataDeSolicitacao);
Assert.AreEqual("CENTRO", requisicaoDeCompra.Centro);
Assert.AreSame(unidadeDeMedida, requisicaoDeCompra.UnidadeMedida);
Assert.AreEqual(1000, requisicaoDeCompra.Quantidade);
Assert.AreEqual("Requisição de Compra enviada pelo SAP", requisicaoDeCompra.Descricao);
Assert.AreEqual("REQ0001", requisicaoDeCompra.Numero);
Assert.AreEqual("ITEM001", requisicaoDeCompra.NumeroItem);
Assert.AreEqual("GC1", requisicaoDeCompra.CodigoGrupoDeCompra);
Assert.IsFalse(requisicaoDeCompra.Mrp);
Assert.AreEqual(Enumeradores.StatusRequisicaoCompra.Ativo, requisicaoDeCompra.Status);
}
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 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 QuandoPersistoUmFornecedorComSucessoConsigoConsultarPosteriormente()
{
var fornecedores = ObjectFactory.GetInstance <IFornecedores>();
Fornecedor fornecedor;
try
{
Session.BeginTransaction();
fornecedor = DefaultObjects.ObtemFornecedorPadrao();
Session.Save(fornecedor);
Session.Transaction.Commit();
}
catch (Exception)
{
RollbackSessionTransaction();
throw;
}
Session.Clear();
Fornecedor fornecedorConsulta = fornecedores.BuscaPeloCodigo(fornecedor.Codigo);
Assert.IsNotNull(fornecedorConsulta);
Assert.AreEqual(fornecedor.Codigo, fornecedorConsulta.Codigo);
Assert.AreEqual("FORNECEDOR " + fornecedor.Codigo, fornecedorConsulta.Nome);
Assert.AreEqual("fornecedor" + fornecedor.Codigo + "@empresa.com.br", fornecedorConsulta.Email);
Assert.AreEqual("cnpj" + fornecedor.Codigo, fornecedor.Cnpj);
Assert.AreEqual("municipio" + fornecedor.Codigo, fornecedorConsulta.Municipio);
Assert.AreEqual("uf", fornecedorConsulta.Uf);
}
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 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 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 QuandoCarregarPorListaDeCodigosTemQueCarregarFornecedoresEquivalentesALista()
{
var fornecedores = ObjectFactory.GetInstance <IFornecedores>();
string[] codigoDosFornecedores;
try
{
Session.BeginTransaction();
Fornecedor fornecedor1 = DefaultObjects.ObtemFornecedorPadrao();
Fornecedor fornecedor2 = DefaultObjects.ObtemFornecedorPadrao();
Fornecedor fornecedor3 = DefaultObjects.ObtemFornecedorPadrao();
Session.Save(fornecedor1);
Session.Save(fornecedor2);
Session.Save(fornecedor3);
codigoDosFornecedores = new[] { fornecedor1.Codigo, fornecedor2.Codigo };
Session.Transaction.Commit();
}
catch (Exception)
{
UnitOfWorkNh.RollBack();
throw;
}
IList <Fornecedor> fornecedoresConsulta = fornecedores.BuscaListaPorCodigo(codigoDosFornecedores).List();
Assert.AreEqual(codigoDosFornecedores.Length, fornecedoresConsulta.Count);
foreach (var codigoDoFornecedor in codigoDosFornecedores)
{
Assert.IsNotNull(fornecedoresConsulta.SingleOrDefault(x => x.Codigo == codigoDoFornecedor));
}
}
public void QuandoConsultarFornecedoresNaoVinculadosAoProdutoNenhumDosFornecedoresRetornadosEstaVinculadoAoProduto()
{
RemoveQueries.RemoverProdutosCadastrados();
RemoveQueries.RemoverFornecedoresCadastrados();
Session.BeginTransaction();
var produto = DefaultObjects.ObtemProdutoPadrao();
//CRIA 4 FORNECEDORES
var fornecedor01 = DefaultObjects.ObtemFornecedorPadrao();
var fornecedor02 = DefaultObjects.ObtemFornecedorPadrao();
var fornecedor03 = DefaultObjects.ObtemFornecedorPadrao();
var fornecedor04 = DefaultObjects.ObtemFornecedorPadrao();
//VINCULA FORNECEDORES 1 E 2 AO PRODUTO. OS FORNECEDORES 3 E 4 NÃO SERÃO VINCULADOS
produto.AdicionarFornecedores(new List <Fornecedor> {
fornecedor01, fornecedor02
});
Session.Save(produto);
Session.Save(fornecedor03);
Session.Save(fornecedor04);
Session.Transaction.Commit();
UnitOfWorkNh.Session.Clear();
var fornecedores = ObjectFactory.GetInstance <IFornecedores>();
fornecedores.FornecedoresNaoVinculadosAoProduto(produto.Codigo);
Assert.AreEqual(2, fornecedores.Count());
IList <Fornecedor> fornecedoresNaoVinculados = fornecedores.List();
Assert.AreEqual(1, fornecedoresNaoVinculados.Count(x => x.Codigo == fornecedor03.Codigo));
Assert.AreEqual(1, fornecedoresNaoVinculados.Count(x => x.Codigo == fornecedor04.Codigo));
}
public void NaoEPermitidoAbrirProcessoDeCotacaoSemItens()
{
ProcessoDeCotacaoDeMaterial processoDeCotacao = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
processoDeCotacao.AdicionarFornecedor(DefaultObjects.ObtemFornecedorPadrao());
processoDeCotacao.RemoverItem(processoDeCotacao.Itens.First());
processoDeCotacao.Abrir(DefaultObjects.ObtemUsuarioPadrao());
}
public void QuandoAbroOProcessoDeCotacaoOStatusPassaParaAberto()
{
ProcessoDeCotacaoDeMaterial processoDeCotacaoDeMaterial = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
processoDeCotacaoDeMaterial.AdicionarFornecedor(DefaultObjects.ObtemFornecedorPadrao());
processoDeCotacaoDeMaterial.Abrir(DefaultObjects.ObtemUsuarioPadrao());
Assert.AreEqual(Enumeradores.StatusProcessoCotacao.Aberto, processoDeCotacaoDeMaterial.Status);
}
public void AposOProcessoDeCotacaoSerAbertoNaoEPossivelAtualizarOsDadosComplementares()
{
ProcessoDeCotacaoDeFrete processoDeCotacaoDeFrete = DefaultObjects.ObtemProcessoDeCotacaoDeFrete();
processoDeCotacaoDeFrete.AdicionarFornecedor(DefaultObjects.ObtemFornecedorPadrao());
processoDeCotacaoDeFrete.Abrir(DefaultObjects.ObtemUsuarioPadrao());
processoDeCotacaoDeFrete.Atualizar("requisitos alterados", "1500", processoDeCotacaoDeFrete.DataLimiteDeRetorno.Value,
processoDeCotacaoDeFrete.DataDeValidadeInicial, processoDeCotacaoDeFrete.DataDeValidadeFinal, processoDeCotacaoDeFrete.Itinerario);
}
public void SeTentarInformarUmaCotacaoAposADataLimiteDeRetornoDeveGerarExcecao()
{
ProcessoDeCotacaoDeMaterial processoDeCotacaoDeMaterial = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialNaoIniciado();
processoDeCotacaoDeMaterial.Atualizar(DateTime.Today.AddDays(-1), processoDeCotacaoDeMaterial.Requisitos);
processoDeCotacaoDeMaterial.AdicionarFornecedor(DefaultObjects.ObtemFornecedorPadrao());
processoDeCotacaoDeMaterial.Abrir(DefaultObjects.ObtemUsuarioPadrao());
processoDeCotacaoDeMaterial.InformarCotacao("FORNEC0001", DefaultObjects.ObtemCondicaoDePagamentoPadrao(), new Incoterm("001", "INCOTERM 001"), "inc");
}
public void QuandoInstanciaUmFornecedorParticipanteAsPropriedadesSaoCriadasCorretamente()
{
ProcessoDeCotacaoDeMaterial processoDeCotacaoDeMaterial = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialNaoIniciado();
Fornecedor fornecedor = DefaultObjects.ObtemFornecedorPadrao();
var fornecedorParticipante = processoDeCotacaoDeMaterial.AdicionarFornecedor(fornecedor);
Assert.AreEqual(processoDeCotacaoDeMaterial.Id, fornecedorParticipante.ProcessoDeCotacao.Id);
Assert.AreEqual(fornecedor.Codigo, fornecedorParticipante.Fornecedor.Codigo);
}
public void QuandoAdicionaMaisDeUmaVezOMesmoFornecedorEsteApareceNaListaApenasUmaUnicaVez()
{
var fornecedor1 = DefaultObjects.ObtemFornecedorPadrao();
ProcessoDeCotacaoDeMaterial processoDeCotacaoDeMaterial = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialNaoIniciado();
processoDeCotacaoDeMaterial.AdicionarFornecedor(fornecedor1);
processoDeCotacaoDeMaterial.AdicionarFornecedor(fornecedor1);
Assert.AreEqual(1, processoDeCotacaoDeMaterial.FornecedoresParticipantes.Count);
}
public void QuandoAdicionarUmFornecedorNoProcessoEsteFicaVinculadoAoProcesso()
{
var fornecedor1 = DefaultObjects.ObtemFornecedorPadrao();
ProcessoDeCotacaoDeMaterial processoDeCotacaoDeMaterial = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialNaoIniciado();
processoDeCotacaoDeMaterial.AdicionarFornecedor(fornecedor1);
Assert.IsNotNull(processoDeCotacaoDeMaterial.FornecedoresParticipantes.SingleOrDefault(x => x.Fornecedor.Codigo == fornecedor1.Codigo));
}
public void BuilderSingleCriarAViewModelComAsPropriedadesCorretas()
{
var builder = new FornecedorCadastroBuilder();
Fornecedor fornecedor = DefaultObjects.ObtemFornecedorPadrao();
FornecedorCadastroVm viewModel = builder.BuildSingle(fornecedor);
Assert.AreEqual(fornecedor.Codigo, viewModel.Codigo);
Assert.AreEqual(fornecedor.Nome, viewModel.Nome);
Assert.AreEqual(fornecedor.Email, viewModel.Email);
}
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);
}
public void QuandoAbroProcessoDeCotacaoRegistroOComprador()
{
ProcessoDeCotacaoDeMaterial processoDeCotacaoDeMaterial = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
processoDeCotacaoDeMaterial.AdicionarFornecedor(DefaultObjects.ObtemFornecedorPadrao());
Usuario comprador = DefaultObjects.ObtemUsuarioPadrao();
processoDeCotacaoDeMaterial.Abrir(comprador);
Assert.AreEqual(Enumeradores.StatusProcessoCotacao.Aberto, processoDeCotacaoDeMaterial.Status);
Assert.AreEqual(comprador, processoDeCotacaoDeMaterial.Comprador);
}
public void AposOProcessoDeCotacaoSerAbertoNaoEPossivelRemoverFornecedores()
{
ProcessoDeCotacaoDeMaterial processoDeCotacaoDeMaterial = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
var fornecedor1 = DefaultObjects.ObtemFornecedorPadrao();
var fornecedor2 = DefaultObjects.ObtemFornecedorPadrao();
processoDeCotacaoDeMaterial.AdicionarFornecedor(fornecedor1);
processoDeCotacaoDeMaterial.AdicionarFornecedor(fornecedor2);
processoDeCotacaoDeMaterial.Abrir(DefaultObjects.ObtemUsuarioPadrao());
processoDeCotacaoDeMaterial.RemoverFornecedor(fornecedor1.Codigo);
}
QuandoAdicionoUmaListaDeFornecedoresEmUmProdutoSemFornecedoresTodosOsFornecedoresSaoAdicionadosNoProduto()
{
var produto = new Produto("PROD0001", "Produto de Teste", "01");
var fornecedores = new List <Fornecedor>()
{
DefaultObjects.ObtemFornecedorPadrao(),
DefaultObjects.ObtemFornecedorPadrao()
};
produto.AdicionarFornecedores(fornecedores);
Assert.AreEqual(2, produto.Fornecedores.Count);
}
public void QuandoAdicionaIteracaoDeUsuarioOcorrePersistencia()
{
ProcessoDeCotacao processoDeCotacao = DefaultObjects.ObtemProcessoDeCotacaoDeFrete();
IList <FornecedorParticipante> fornecedoresParticipantes = new List <FornecedorParticipante>();
fornecedoresParticipantes.Add(processoDeCotacao.AdicionarFornecedor(DefaultObjects.ObtemFornecedorPadrao()));
fornecedoresParticipantes.Add(processoDeCotacao.AdicionarFornecedor(DefaultObjects.ObtemFornecedorPadrao()));
_atualizadorDeIteracaoDoUsuario.Adicionar(fornecedoresParticipantes);
_processoCotacaoIteracoesUsuarioMock.Verify(x => x.Save(It.IsAny <ProcessoCotacaoIteracaoUsuario>()), Times.Exactly(fornecedoresParticipantes.Count));
CommonVerifications.VerificaCommitDeTransacao(_unitOfWorkMock);
}
public void BuilderListChamaOMetodoSingleParaCadaUmDosFornecedoresDaLista()
{
var builder = new FornecedorCadastroBuilder();
Fornecedor fornecedor1 = DefaultObjects.ObtemFornecedorPadrao();
Fornecedor fornecedor2 = DefaultObjects.ObtemFornecedorPadrao();
var viewModels = builder.BuildList(new List <Fornecedor>()
{
fornecedor1, fornecedor2
});
Assert.AreEqual(2, viewModels.Count);
Assert.AreEqual(1, viewModels.Count(x => x.Codigo == fornecedor1.Codigo));
Assert.AreEqual(1, viewModels.Count(x => x.Codigo == fornecedor2.Codigo));
}
public void ServicoDeVerificacaoDeQuantidadeAdquiridaRetornaResultadoDaComparacao()
{
var processoDeCotacaoDeMaterial = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
processoDeCotacaoDeMaterial.AdicionarFornecedor(DefaultObjects.ObtemFornecedorPadrao());
processoDeCotacaoDeMaterial.AdicionarFornecedor(DefaultObjects.ObtemFornecedorPadrao());
_processosDeCotacaoMock.Setup(x => x.Single())
.Returns(processoDeCotacaoDeMaterial);
VerificacaoDeQuantidadeAdquiridaVm verificacaoVm = _processoDeCotacaoService.VerificarQuantidadeAdquirida(10, 0, 1001);
Assert.AreEqual(1000, verificacaoVm.QuantidadeSolicitadaNoProcessoDeCotacao);
Assert.IsTrue(verificacaoVm.SuperouQuantidadeSolicitada);
_processosDeCotacaoMock.Verify(x => x.BuscaPorId(It.IsAny <int>()), Times.Once());
}
public void QuandoListaProcessosDeCotacaoDeUmDeterminadoFornecedorRetornaApenasProcessosDesteFornecedor()
{
//crio dois fornecedores e adiciono cada um deles em duas cotações distintas
Fornecedor fornecedor1 = DefaultObjects.ObtemFornecedorPadrao();
Fornecedor fornecedor2 = DefaultObjects.ObtemFornecedorPadrao();
ProcessoDeCotacaoDeMaterial processoDeCotacao1 = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
ProcessoDeCotacaoDeMaterial processoDeCotacao2 = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
ProcessoDeCotacaoDeMaterial processoDeCotacao3 = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
ProcessoDeCotacaoDeMaterial processoDeCotacao4 = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
processoDeCotacao1.AdicionarFornecedor(fornecedor1);
processoDeCotacao1.Abrir(DefaultObjects.ObtemUsuarioPadrao());
processoDeCotacao2.AdicionarFornecedor(fornecedor1);
processoDeCotacao2.Abrir(DefaultObjects.ObtemUsuarioPadrao());
processoDeCotacao3.AdicionarFornecedor(fornecedor2);
processoDeCotacao3.Abrir(DefaultObjects.ObtemUsuarioPadrao());
processoDeCotacao4.AdicionarFornecedor(fornecedor2);
processoDeCotacao4.Abrir(DefaultObjects.ObtemUsuarioPadrao());
DefaultPersistedObjects.PersistirProcessosDeCotacaoDeMaterial(new List <ProcessoDeCotacaoDeMaterial>()
{
processoDeCotacao1, processoDeCotacao2, processoDeCotacao3, processoDeCotacao4
});
var consultaProcesso = ObjectFactory.GetInstance <IConsultaProcessoDeCotacaoDeMaterial>();
//consulta filtrando pelo fornecedor1
KendoGridVm kendoGridVm = consultaProcesso.Listar(new PaginacaoVm()
{
Page = 1, PageSize = 10, Take = 10
},
new ProcessoCotacaoFiltroVm()
{
CodigoFornecedor = fornecedor1.Codigo
});
Assert.AreEqual(2, kendoGridVm.QuantidadeDeRegistros);
var viewModels = kendoGridVm.Registros.Cast <ProcessoCotacaoMaterialListagemVm>().ToList();
//verifico que está retornado os dois processos vinculados ao fornecedor 1
Assert.IsNotNull(viewModels.First(x => x.Id == processoDeCotacao1.Id));
Assert.IsNotNull(viewModels.First(x => x.Id == processoDeCotacao2.Id));
}
public void ConsultaPrevistoRealizadoFiltraPorFornecedorCorretamente()
{
//cria duas quotas, dois fornecedores. Os fornecedores tem agendamentos nas duas quotas.
//Apenas uma das quotas de cada fornecedor está realizada.
RemoveQueries.RemoverQuotasCadastradas();
Fornecedor fornecedor1 = DefaultObjects.ObtemFornecedorPadrao();
Fornecedor fornecedor2 = DefaultObjects.ObtemFornecedorPadrao();
var quota1 = new Quota(Enumeradores.MaterialDeCarga.Farelo, fornecedor1, "1000", DateTime.Today.AddDays(1), 100);
var quota2 = new Quota(Enumeradores.MaterialDeCarga.Farelo, fornecedor1, "1000", DateTime.Today.AddDays(2), 200);
var quota3 = new Quota(Enumeradores.MaterialDeCarga.Farelo, fornecedor2, "1000", DateTime.Today.AddDays(1), 150);
var quota4 = new Quota(Enumeradores.MaterialDeCarga.Farelo, fornecedor2, "1000", DateTime.Today.AddDays(2), 250);
DefaultPersistedObjects.PersistirQuota(quota1);
DefaultPersistedObjects.PersistirQuota(quota2);
DefaultPersistedObjects.PersistirQuota(quota3);
DefaultPersistedObjects.PersistirQuota(quota4);
AgendamentoDeCarregamento agendamento1 = quota1.InformarAgendamento(new AgendamentoDeCarregamentoCadastroVm {
Placa = "IOQ3434", Peso = 30
});
AgendamentoDeCarregamento agendamento2 = quota4.InformarAgendamento(new AgendamentoDeCarregamentoCadastroVm {
Placa = "IOQ3435", Peso = 250
});
DefaultPersistedObjects.PersistirQuota(quota1);
DefaultPersistedObjects.PersistirQuota(quota4);
quota1.RealizarAgendamento(agendamento1.Id);
quota4.RealizarAgendamento(agendamento2.Id);
DefaultPersistedObjects.PersistirQuota(quota1);
DefaultPersistedObjects.PersistirQuota(quota4);
var consultaQuotaRelatorio = ObjectFactory.GetInstance <IConsultaQuotaRelatorio>();
IList <QuotaPlanejadoRealizadoVm> quotas = consultaQuotaRelatorio.PlanejadoRealizado(
new RelatorioAgendamentoFiltroVm
{
CodigoTerminal = "1000",
CodigoFornecedor = fornecedor1.Codigo
});
Assert.AreEqual(1, quotas.Count);
}
public void QuandoRemovoUmFornecedorEsteNaoFicaMaisVinculadoAoProcesso()
{
var fornecedor1 = DefaultObjects.ObtemFornecedorPadrao();
var fornecedor2 = DefaultObjects.ObtemFornecedorPadrao();
var fornecedor3 = DefaultObjects.ObtemFornecedorPadrao();
ProcessoDeCotacaoDeMaterial processoDeCotacaoDeMaterial = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialNaoIniciado();
processoDeCotacaoDeMaterial.AdicionarFornecedor(fornecedor1);
processoDeCotacaoDeMaterial.AdicionarFornecedor(fornecedor2);
processoDeCotacaoDeMaterial.AdicionarFornecedor(fornecedor3);
Assert.AreEqual(3, processoDeCotacaoDeMaterial.FornecedoresParticipantes.Count);
processoDeCotacaoDeMaterial.RemoverFornecedor(fornecedor2.Codigo);
Assert.AreEqual(2, processoDeCotacaoDeMaterial.FornecedoresParticipantes.Count);
}
public void QuandoFiltraSomenteFornecedoresQueNaoSaoDeTransporteTodosFornecedoresListadosNaoSaoDeTransporte()
{
RemoveQueries.RemoverFornecedoresCadastrados();
Fornecedor naoTransportadora = DefaultObjects.ObtemFornecedorPadrao();
Fornecedor transportadora = DefaultObjects.ObtemTransportadoraPadrao();
DefaultPersistedObjects.PersistirFornecedor(naoTransportadora);
DefaultPersistedObjects.PersistirFornecedor(transportadora);
UnitOfWorkNh.Session.Clear();
var fornecedores = ObjectFactory.GetInstance <IFornecedores>();
IList <Fornecedor> naoTransportadoras = fornecedores.RemoveTransportadoras().List();
Assert.AreEqual(1, naoTransportadoras.Count);
Assert.IsFalse(naoTransportadoras.First().Transportadora);
}