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 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 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 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 QuandoAbroOProcessoDeCotacaoOStatusPassaParaAberto()
{
ProcessoDeCotacaoDeMaterial processoDeCotacaoDeMaterial = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
processoDeCotacaoDeMaterial.AdicionarFornecedor(DefaultObjects.ObtemFornecedorPadrao());
processoDeCotacaoDeMaterial.Abrir(DefaultObjects.ObtemUsuarioPadrao());
Assert.AreEqual(Enumeradores.StatusProcessoCotacao.Aberto, processoDeCotacaoDeMaterial.Status);
}
public void NaoEPermitidoAbrirProcessoDeCotacaoSemItens()
{
ProcessoDeCotacaoDeMaterial processoDeCotacao = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
processoDeCotacao.AdicionarFornecedor(DefaultObjects.ObtemFornecedorPadrao());
processoDeCotacao.RemoverItem(processoDeCotacao.Itens.First());
processoDeCotacao.Abrir(DefaultObjects.ObtemUsuarioPadrao());
}
public void NaoEPermitidoAdicionarSelecionarUmaRequisicaoDeCompraBloqueadaParaUmProcessoDeCotacao()
{
RequisicaoDeCompra requisicaoDeCompra = DefaultObjects.ObtemRequisicaoDeCompraPadrao();
requisicaoDeCompra.Bloquear();
ProcessoDeCotacaoDeMaterial processoDeCotacao = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
processoDeCotacao.AdicionarItem(requisicaoDeCompra);
}
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 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 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);
}
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 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 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 QuandoFiltroProcessosDeCotacaoPorRequisicaoDeCompraRetornaApenasProcessosVinculadosComARequisicao()
{
//crio duas requisicoes de compra e um processo para cada requisicão
ProcessoDeCotacaoDeMaterial processoDeCotacao1 = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
RequisicaoDeCompra requisicaoDeCompra1 = ((ProcessoDeCotacaoDeMaterialItem)processoDeCotacao1.Itens.Single()).RequisicaoDeCompra;
ProcessoDeCotacaoDeMaterial processoDeCotacao2 = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
DefaultPersistedObjects.PersistirProcessosDeCotacaoDeMaterial(new List <ProcessoDeCotacaoDeMaterial> {
processoDeCotacao1, processoDeCotacao2
});
//filtra os processos por uma das requisições
var processosDeCotacao = ObjectFactory.GetInstance <IProcessosDeCotacaoDeMaterial>();
var processosConsultados = processosDeCotacao.GeradosPelaRequisicaoDeCompra(requisicaoDeCompra1.Id).Count();
//retorna apenas o processo vinculado com a requisição indicada
Assert.AreEqual(1, processosConsultados);
//Assert.AreEqual(processoDeCotacao1.Id, processosConsultados.Single().Id);
}
public void QuandoInformoUmaCotacaoParaUmaCotacaoParaUmProdutoQueNaoEMateriaPrimaCalculadoCustoCorretamente()
{
ProcessoDeCotacaoDeMaterial processoDeCotacao = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
Fornecedor fornecedor = DefaultObjects.ObtemFornecedorPadrao();
processoDeCotacao.AdicionarFornecedor(fornecedor);
processoDeCotacao.Abrir(DefaultObjects.ObtemUsuarioPadrao());
CotacaoMaterial cotacao = processoDeCotacao.InformarCotacao(fornecedor.Codigo, DefaultObjects.ObtemCondicaoDePagamentoPadrao(),
DefaultObjects.ObtemIncotermPadrao(), "incoterm");
ProcessoDeCotacaoItem item = processoDeCotacao.Itens.Single();
var cotacaoItem = cotacao.InformarCotacaoDeItem(item, 100, 0, 10, DateTime.Today.AddDays(10), "obs");
cotacaoItem.InformarImposto(Enumeradores.TipoDeImposto.Icms, 17);
cotacaoItem.InformarImposto(Enumeradores.TipoDeImposto.PisCofins, 9);
cotacaoItem.InformarImposto(Enumeradores.TipoDeImposto.Ipi, 10);
//preço + ipi
Assert.AreEqual(110, cotacaoItem.Custo);
}
public void QuandoAtualizarUmaCotacaoDoProcessoAsPropriedadesSaoAtualizadas()
{
ProcessoDeCotacaoDeMaterial processoDeCotacao = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
Fornecedor fornecedor = DefaultObjects.ObtemFornecedorPadrao();
processoDeCotacao.AdicionarFornecedor(fornecedor);
processoDeCotacao.Abrir(DefaultObjects.ObtemUsuarioPadrao());
Incoterm incoterm = DefaultObjects.ObtemIncotermPadrao();
CondicaoDePagamento condicaoDePagamento = DefaultObjects.ObtemCondicaoDePagamentoPadrao();
processoDeCotacao.InformarCotacao(fornecedor.Codigo, condicaoDePagamento, incoterm, "Descrição do Incoterm 2");
var cotacao = (CotacaoMaterial)processoDeCotacao.FornecedoresParticipantes.First().Cotacao;
Assert.IsNotNull(cotacao);
Assert.AreSame(condicaoDePagamento, cotacao.CondicaoDePagamento);
Assert.AreSame(incoterm, cotacao.Incoterm);
Assert.AreEqual("Descrição do Incoterm 2", cotacao.DescricaoIncoterm);
}
public void ConsigoPersistirEConsultarUmProcessoDeCotacaoComCotacoes()
{
ProcessoDeCotacaoDeMaterial processoDeCotacaoDeMaterial = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
Fornecedor fornecedor = DefaultObjects.ObtemFornecedorPadrao();
processoDeCotacaoDeMaterial.AdicionarFornecedor(fornecedor);
var usuarioComprador = DefaultObjects.ObtemUsuarioPadrao();
processoDeCotacaoDeMaterial.Abrir(usuarioComprador);
var cotacao = processoDeCotacaoDeMaterial.InformarCotacao(fornecedor.Codigo, DefaultObjects.ObtemCondicaoDePagamentoPadrao(),
DefaultObjects.ObtemIncotermPadrao(), "inc");
var processoDeCotacaoItem = processoDeCotacaoDeMaterial.Itens.First();
var cotacaoItem = cotacao.InformarCotacaoDeItem(processoDeCotacaoItem, 1000, 120, 100, DateTime.Today.AddMonths(1), "obs fornec");
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processoDeCotacaoDeMaterial);
var processosDeCotacaoDeMaterial = ObjectFactory.GetInstance <IProcessosDeCotacao>();
Console.WriteLine("Consultando Cotacao - INICIO");
var processoConsultado = (ProcessoDeCotacaoDeMaterial)processosDeCotacaoDeMaterial.BuscaPorId(processoDeCotacaoDeMaterial.Id).Single();
Assert.AreEqual(processoDeCotacaoDeMaterial.FornecedoresParticipantes.Count(x => x.Cotacao != null), processoConsultado.FornecedoresParticipantes.Count(x => x.Cotacao != null));
var cotacaoConsultada = (CotacaoMaterial)processoConsultado.FornecedoresParticipantes.First().Cotacao.CastEntity();
Assert.AreEqual(cotacao.Incoterm, cotacaoConsultada.Incoterm.CastEntity());
Assert.AreEqual(cotacao.DescricaoIncoterm, cotacaoConsultada.DescricaoIncoterm);
Assert.AreEqual(cotacao.CondicaoDePagamento, cotacaoConsultada.CondicaoDePagamento.CastEntity());
Assert.AreEqual(processoDeCotacaoDeMaterial.Comprador.Login, processoConsultado.Comprador.Login);
var cotacaoItemConsultada = (CotacaoMaterialItem)cotacaoConsultada.Itens.First().CastEntity();
Assert.AreEqual(cotacaoItem.ValorComImpostos, cotacaoItemConsultada.ValorComImpostos);
Assert.AreEqual(cotacaoItem.Preco, cotacaoItemConsultada.Preco);
Assert.AreEqual(cotacaoItem.PrecoInicial, cotacaoItemConsultada.PrecoInicial);
Assert.AreEqual(cotacaoItem.Selecionada, cotacaoItemConsultada.Selecionada);
Assert.AreEqual(cotacaoItem.QuantidadeDisponivel, cotacaoItemConsultada.QuantidadeDisponivel);
Assert.AreEqual(cotacaoItem.QuantidadeAdquirida, cotacaoItemConsultada.QuantidadeAdquirida);
Assert.AreEqual(cotacaoItem.Observacoes, cotacaoItemConsultada.Observacoes);
Console.WriteLine("Consultando Cotacao - FIM");
}
public void QuandoSelecionaUmFornecedorACotacaoFicaMarcadaComoSelecionadaQuantidadeAdquiridaEIvaSaoPreenchidos()
{
ProcessoDeCotacaoDeMaterial processoDeCotacao = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
Fornecedor fornecedor = DefaultObjects.ObtemFornecedorPadrao();
processoDeCotacao.AdicionarFornecedor(fornecedor);
processoDeCotacao.Abrir(DefaultObjects.ObtemUsuarioPadrao());
Incoterm incoterm = DefaultObjects.ObtemIncotermPadrao();
CondicaoDePagamento condicaoDePagamento = DefaultObjects.ObtemCondicaoDePagamentoPadrao();
var processoCotacaoItem = processoDeCotacao.Itens.First();
var cotacao = processoDeCotacao.InformarCotacao(fornecedor.Codigo, condicaoDePagamento, incoterm, "Descrição do Incoterm 2");
var cotacaoItem = (CotacaoMaterialItem)cotacao.InformarCotacaoDeItem(processoCotacaoItem, new decimal(150.20), 180, 10, DateTime.Today.AddMonths(1), "obs fornec");
Iva iva = DefaultObjects.ObtemIvaPadrao();
cotacaoItem.Selecionar(new decimal(120.00), iva);
Assert.IsTrue(cotacaoItem.Selecionada);
Assert.AreEqual(new decimal(120.00), cotacaoItem.QuantidadeAdquirida);
Assert.AreEqual(iva.Codigo, cotacaoItem.Iva.Codigo);
}
public void QuandoConsultaUmaCotacaoQueParticipaMaisDeUmFornecedorRetornaOsDadoDoFornecedorInformado()
{
ProcessoDeCotacaoDeMaterial processo = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
Fornecedor fornecedor1 = DefaultObjects.ObtemFornecedorPadrao();
Fornecedor fornecedor2 = DefaultObjects.ObtemFornecedorPadrao();
processo.AdicionarFornecedor(fornecedor1);
processo.AdicionarFornecedor(fornecedor2);
processo.Abrir(DefaultObjects.ObtemUsuarioPadrao());
var processoDeCotacaoItem = processo.Itens.First();
var cotacao1 = processo.InformarCotacao(fornecedor1.Codigo, DefaultObjects.ObtemCondicaoDePagamentoPadrao(),
DefaultObjects.ObtemIncotermPadrao(), "Desc Incoterm");
cotacao1.InformarCotacaoDeItem(processoDeCotacaoItem, 100, 120, 12, DateTime.Today.AddMonths(1), "observacoes");
var cotacao2 = processo.InformarCotacao(fornecedor2.Codigo, DefaultObjects.ObtemCondicaoDePagamentoPadrao(),
DefaultObjects.ObtemIncotermPadrao(), "Desc Incoterm");
cotacao2.InformarCotacaoDeItem(processoDeCotacaoItem, 120, 130, 14, DateTime.Today.AddMonths(1), "observacoes");
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processo);
var cotacao = (CotacaoMaterial)processo.FornecedoresParticipantes.Single(x => x.Fornecedor.Codigo == fornecedor1.Codigo).Cotacao;
var consulta = ObjectFactory.GetInstance <IConsultaCotacaoDoFornecedor>();
CotacaoMaterialCadastroVm vm = consulta.ConsultarCotacaoDeMaterial(processo.Id, fornecedor1.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(fornecedor1.Codigo, vm.CodigoFornecedor);
Assert.IsTrue(processo.DataLimiteDeRetorno.HasValue);
Assert.AreEqual(processo.DataLimiteDeRetorno.Value.ToShortDateString(), vm.DataLimiteDeRetorno);
Assert.AreEqual("Aberto", vm.Status);
}
public void QuandoRemoverASelecaoDeUmaCotacaoFicaDesmarcadaESemQuantidade()
{
ProcessoDeCotacaoDeMaterial processoDeCotacao = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
Fornecedor fornecedor = DefaultObjects.ObtemFornecedorPadrao();
processoDeCotacao.AdicionarFornecedor(fornecedor);
processoDeCotacao.Abrir(DefaultObjects.ObtemUsuarioPadrao());
Incoterm incoterm = DefaultObjects.ObtemIncotermPadrao();
CondicaoDePagamento condicaoDePagamento = DefaultObjects.ObtemCondicaoDePagamentoPadrao();
var cotacao = processoDeCotacao.InformarCotacao(fornecedor.Codigo, condicaoDePagamento, incoterm, "Descrição do Incoterm 2");
var processoCotacaoItem = processoDeCotacao.Itens.First();
var cotacaoItem = (CotacaoMaterialItem)cotacao.InformarCotacaoDeItem(processoCotacaoItem, new decimal(150.20), 180, 10, DateTime.Today.AddMonths(1), "obs fornec");
Iva iva = DefaultObjects.ObtemIvaPadrao();
cotacaoItem.Selecionar(new decimal(120.00), iva);
Iva ivaAlteracao = DefaultObjects.ObtemIvaPadrao();
cotacaoItem.RemoverSelecao(ivaAlteracao);
Assert.IsFalse(cotacaoItem.Selecionada);
Assert.IsNull(cotacaoItem.QuantidadeAdquirida);
Assert.AreSame(ivaAlteracao, cotacaoItem.Iva);
}
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 void ConsigoConsultarAsCotacoesDetalhadasDeTodosOsFornecedores()
{
Fornecedor fornecedor1 = DefaultObjects.ObtemFornecedorPadrao();
Fornecedor fornecedor2 = DefaultObjects.ObtemFornecedorPadrao();
Fornecedor fornecedor3 = DefaultObjects.ObtemFornecedorPadrao();
//crio um processo de cotação com um item e três fornecedores.
ProcessoDeCotacaoDeMaterial processoDeCotacao = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
ProcessoDeCotacaoItem processoDeCotacaoItem = processoDeCotacao.Itens.Single();
processoDeCotacao.AdicionarFornecedor(fornecedor1);
processoDeCotacao.AdicionarFornecedor(fornecedor2);
processoDeCotacao.AdicionarFornecedor(fornecedor3);
processoDeCotacao.Abrir(DefaultObjects.ObtemCompradorDeSuprimentos());
//para os fornecedores 1 e 3 informo o preço duas vezes
CotacaoMaterial cotacaoFornecedor1 = processoDeCotacao.InformarCotacao(fornecedor1.Codigo, DefaultObjects.ObtemCondicaoDePagamentoPadrao(),
DefaultObjects.ObtemIncotermPadrao(), "inc");
CotacaoItem cotacaoItemFornecedor1 = cotacaoFornecedor1.InformarCotacaoDeItem(processoDeCotacaoItem, 1000, 0, 200, DateTime.Today.AddDays(10), "OBS");
cotacaoFornecedor1.InformarCotacaoDeItem(processoDeCotacaoItem, 995, 0, 200, DateTime.Today.AddDays(10), "OBS");
CotacaoMaterial cotacaoFornecedor3 = processoDeCotacao.InformarCotacao(fornecedor3.Codigo, DefaultObjects.ObtemCondicaoDePagamentoPadrao(),
DefaultObjects.ObtemIncotermPadrao(), "inc");
cotacaoFornecedor3.InformarCotacaoDeItem(processoDeCotacaoItem, 1010, 0, 100, DateTime.Today.AddDays(10), "OBS");
cotacaoFornecedor3.InformarCotacaoDeItem(processoDeCotacaoItem, 1000, 0, 100, DateTime.Today.AddDays(10), "OBS");
//para o fornecedor 2 informo o preço apenas uma vez
CotacaoMaterial cotacaoFornecedor2 = processoDeCotacao.InformarCotacao(fornecedor2.Codigo, DefaultObjects.ObtemCondicaoDePagamentoPadrao(),
DefaultObjects.ObtemIncotermPadrao(), "inc");
cotacaoFornecedor2.InformarCotacaoDeItem(processoDeCotacaoItem, 1200, 0, 100, DateTime.Today.AddDays(10), "OBS");
//seleciono apenas o fornecedor 1
cotacaoItemFornecedor1.Selecionar(200);
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processoDeCotacao);
var consultaProcesso = ObjectFactory.GetInstance <IConsultaProcessoDeCotacaoDeMaterial>();
IList <FornecedorCotacaoVm> cotacoes = consultaProcesso.CotacoesDetalhadaDosFornecedores(processoDeCotacao.Id, processoDeCotacaoItem.Id);
Assert.AreEqual(3, cotacoes.Count);
//asserts fornecedor 1
FornecedorCotacaoVm fornecedorCotacaoVm1 = cotacoes.Single(x => x.Codigo == fornecedor1.Codigo);
Assert.AreEqual(1000, fornecedorCotacaoVm1.PrecoInicial);
Assert.AreEqual(995, fornecedorCotacaoVm1.PrecoFinal);
Assert.IsTrue(fornecedorCotacaoVm1.Selecionada);
Assert.AreEqual(200, fornecedorCotacaoVm1.QuantidadeAdquirida);
//Assert.AreEqual(2, fornecedorCotacaoVm1.Precos.Length);
Assert.AreEqual(2, fornecedorCotacaoVm1.Precos.Count());
Assert.AreEqual(1000, fornecedorCotacaoVm1.Precos[0]);
Assert.AreEqual(995, fornecedorCotacaoVm1.Precos[1]);
//asserts fornecedor 2
FornecedorCotacaoVm fornecedorCotacaoVm2 = cotacoes.Single(x => x.Codigo == fornecedor2.Codigo);
Assert.AreEqual(1200, fornecedorCotacaoVm2.PrecoInicial);
Assert.AreEqual(1200, fornecedorCotacaoVm2.PrecoFinal);
Assert.IsFalse(fornecedorCotacaoVm2.Selecionada);
Assert.AreEqual(0, fornecedorCotacaoVm2.QuantidadeAdquirida);
//Assert.AreEqual(1, fornecedorCotacaoVm2.Precos.Length);
Assert.AreEqual(1, fornecedorCotacaoVm2.Precos.Count());
Assert.AreEqual(1200, fornecedorCotacaoVm2.Precos[0]);
//asserts fornecedor 3
FornecedorCotacaoVm fornecedorCotacaoVm3 = cotacoes.Single(x => x.Codigo == fornecedor3.Codigo);
Assert.AreEqual(1010, fornecedorCotacaoVm3.PrecoInicial);
Assert.AreEqual(1000, fornecedorCotacaoVm3.PrecoFinal);
Assert.IsFalse(fornecedorCotacaoVm3.Selecionada);
Assert.AreEqual(0, fornecedorCotacaoVm3.QuantidadeAdquirida);
//Assert.AreEqual(2, fornecedorCotacaoVm3.Precos.Length);
Assert.AreEqual(2, fornecedorCotacaoVm3.Precos.Count());
Assert.AreEqual(1010, fornecedorCotacaoVm3.Precos[0]);
Assert.AreEqual(1000, fornecedorCotacaoVm3.Precos[1]);
}
public void NaoEPossivelAbrirOProcessoDeCotacaoSeNaoHouverFornecedoresVinculados()
{
ProcessoDeCotacaoDeMaterial processoDeCotacaoDeMaterial = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
processoDeCotacaoDeMaterial.Abrir(DefaultObjects.ObtemUsuarioPadrao());
}