public void NaoPermiteDiminuirAQuotaParaUmValorAbaixoDoQueJaEstaAgendado()
{
var quotaComAgendamento = DefaultObjects.ObtemQuotaDeCarregamento();
quotaComAgendamento.InformarAgendamento(new AgendamentoDeCarregamentoCadastroVm
{
Peso = 100,
Placa = "IQI3342"
});
_quotasMock.Setup(x => x.List()).Returns(new List <Quota>()
{
quotaComAgendamento
});
_quotasMock.Setup(x => x.Delete(It.IsAny <Quota>()));
_cadastroQuota.Salvar(DateTime.Today, new List <QuotaSalvarVm>
{
new QuotaSalvarVm
{
Data = quotaComAgendamento.Data,
CodigoTerminal = quotaComAgendamento.CodigoTerminal,
CodigoMaterial = (int)quotaComAgendamento.Material,
CodigoFornecedor = quotaComAgendamento.Fornecedor.Codigo,
Peso = 90
}
});
}
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 QuandoCriarCarregamentoSemInformarPesoDeveGerarExcecao()
{
Quota quota = DefaultObjects.ObtemQuotaDeCarregamento();
var factory = new AgendamentoDeCarregamentoFactory(0);
factory.Construir(quota, "IOQ5335");
}
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 ProcessoDeCotacaoItensServiceTests()
{
_unitOfWorkMock = CommonMocks.DefaultUnitOfWorkMock();
_requisicoesDeCompras = new List <RequisicaoDeCompra>
{
((ProcessoDeCotacaoDeMaterialItem)_processoDeCotacao.Itens.First()).RequisicaoDeCompra,
DefaultObjects.ObtemRequisicaoDeCompraComId(),
DefaultObjects.ObtemRequisicaoDeCompraComId()
};
_processosDeCotacaoMock = new Mock <IProcessosDeCotacao>(MockBehavior.Strict);
_processosDeCotacaoMock.Setup(x => x.BuscaPorId(It.IsAny <int>()))
.Returns(_processosDeCotacaoMock.Object);
_processosDeCotacaoMock.Setup(x => x.Single())
.Returns(_processoDeCotacao);
_processosDeCotacaoMock.Setup(x => x.Save(It.IsAny <ProcessoDeCotacao>()))
.Callback(
(ProcessoDeCotacao processoDeCotacao) => Assert.IsNotNull(processoDeCotacao));
_requisicoesDeCompraMock = new Mock <IRequisicoesDeCompra>(MockBehavior.Strict);
_requisicoesDeCompraMock.Setup(x => x.FiltraPorIds(It.IsAny <int[]>()))
.Returns((int[] ids) => _requisicoesDeCompras.Where(x => ids.Contains(x.Id)).ToList());
_requisicoesDeCompraMock.Setup(x => x.Save(It.IsAny <RequisicaoDeCompra>()))
.Callback(CommonGenericMocks <RequisicaoDeCompra> .DefaultSaveCallBack(_unitOfWorkMock));
_service = new ProcessoDeCotacaoDeMaterialItensService(_unitOfWorkMock.Object, _processosDeCotacaoMock.Object, _requisicoesDeCompraMock.Object);
}
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 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 QuandoInformarMaisDeUmAgendamentoDeDescarregamentoNaoRealizadoParaMesmaPlacaDeveGerarExcecao()
{
Quota quota = DefaultObjects.ObtemQuotaDeDescarregamento();
quota.InformarAgendamento(new AgendamentoDeDescarregamentoSalvarVm()
{
IdQuota = quota.Id,
IdAgendamento = 0,
Placa = "IMN2420",
NotasFiscais = new List <NotaFiscalVm>
{
DefaultObjects.ObtemNotaFiscalVmComPesoEspecifico(50),
DefaultObjects.ObtemNotaFiscalVmComPesoEspecifico(51)
}
});
quota.InformarAgendamento(new AgendamentoDeDescarregamentoSalvarVm()
{
IdQuota = quota.Id,
IdAgendamento = 0,
Placa = "IMn2420",
NotasFiscais = new List <NotaFiscalVm>
{
DefaultObjects.ObtemNotaFiscalVmComPesoEspecifico(52),
DefaultObjects.ObtemNotaFiscalVmComPesoEspecifico(53)
}
});
}
public override void ReadData(ESPReader reader, long dataEnd)
{
while (reader.BaseStream.Position < dataEnd)
{
string subTag = reader.PeekTag();
switch (subTag)
{
case "EDID":
if (EditorID == null)
{
EditorID = new SimpleSubrecord <String>();
}
EditorID.ReadBinary(reader);
break;
case "DATA":
if (DefaultObjects == null)
{
DefaultObjects = new DefaultObjects();
}
DefaultObjects.ReadBinary(reader);
break;
default:
throw new Exception();
}
}
}
public void PermiteAdicionarUmSegundoAgendamentoDeDescarregamentoParaMesmaPlacaSeOPrimeiroEstiverRealizado()
{
Quota quota = DefaultObjects.ObtemQuotaDeDescarregamento();
AgendamentoDeDescarregamento agendamentoDeDescarregamento = quota.InformarAgendamento(new AgendamentoDeDescarregamentoSalvarVm()
{
IdQuota = quota.Id,
IdAgendamento = 0,
Placa = "IMN2420",
NotasFiscais = new List <NotaFiscalVm>
{
DefaultObjects.ObtemNotaFiscalVmComPesoEspecifico(50),
DefaultObjects.ObtemNotaFiscalVmComPesoEspecifico(51)
}
});
agendamentoDeDescarregamento.Realizar();
quota.InformarAgendamento(new AgendamentoDeDescarregamentoSalvarVm()
{
IdQuota = quota.Id,
IdAgendamento = 0,
Placa = "IMN2420",
NotasFiscais = new List <NotaFiscalVm>
{
DefaultObjects.ObtemNotaFiscalVmComPesoEspecifico(52),
DefaultObjects.ObtemNotaFiscalVmComPesoEspecifico(53)
}
});
Assert.AreEqual(2, quota.Agendamentos.Count);
Assert.AreEqual(2, quota.Agendamentos.Count(x => x.Placa == "IMN2420"));
}
public void PermiteAdicionarUmSegundoAgendamentoDeCarregamentoParaMesmaPlacaSeOPrimeiroEstiverRealizado()
{
Quota quota = DefaultObjects.ObtemQuotaDeCarregamento();
AgendamentoDeCarregamento agendamentoDeDescarregamento = quota
.InformarAgendamento(new AgendamentoDeCarregamentoCadastroVm()
{
IdQuota = quota.Id,
IdAgendamento = 0,
Placa = "IMN2420",
Peso = 10
});
agendamentoDeDescarregamento.Realizar();
quota.InformarAgendamento(new AgendamentoDeCarregamentoCadastroVm()
{
IdQuota = quota.Id,
IdAgendamento = 0,
Placa = "IMN2420",
Peso = 20
});
Assert.AreEqual(2, quota.Agendamentos.Count);
Assert.AreEqual(2, quota.Agendamentos.Count(x => x.Placa == "IMN2420"));
}
public void QuandoBuscarUsuarioPorLoginComLoginExistenteDeveRetornarUsuario()
{
Usuario usuarioNovo;
try
{
UnitOfWorkNh.BeginTransaction();
usuarioNovo = DefaultObjects.ObtemUsuarioPadrao();
UnitOfWorkNh.Session.Save(usuarioNovo);
UnitOfWorkNh.Commit();
}
catch (Exception)
{
UnitOfWorkNh.RollBack();
throw;
}
var usuarios = ObjectFactory.GetInstance <IUsuarios>();
Usuario usuario = usuarios.BuscaPorLogin(usuarioNovo.Login);
Assert.IsNotNull(usuario);
Assert.AreEqual(usuarioNovo.Login, usuario.Login);
}
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 QuandoPersistoUmProdutoComSucessoConsigoConsultarPosteriormente()
{
Produto produto;
try
{
UnitOfWorkNh.BeginTransaction();
produto = DefaultObjects.ObtemProdutoPadrao();
UnitOfWorkNh.Session.Save(produto);
UnitOfWorkNh.Commit();
}
catch (Exception)
{
UnitOfWorkNh.RollBack();
throw;
}
UnitOfWorkNh.Session.Clear();
var produtos = ObjectFactory.GetInstance <IProdutos>();
Produto produtoConsultado = produtos.BuscaPeloCodigo(produto.Codigo);
Assert.IsNotNull(produtoConsultado);
Assert.AreEqual(produto.Codigo, produtoConsultado.Codigo);
Assert.AreEqual(produto.Descricao, produtoConsultado.Descricao);
}
public void NaoEPossivelAbrirOProcessoDeCotacaoSeADataLimiteDeRetornoNaoEstiverPreenchida()
{
RequisicaoDeCompra requisicaoDeCompra = DefaultObjects.ObtemRequisicaoDeCompraPadrao();
ProcessoDeCotacaoDeMaterial processoDeCotacaoDeMaterial = requisicaoDeCompra.GerarProcessoDeCotacaoDeMaterial();
processoDeCotacaoDeMaterial.Abrir(DefaultObjects.ObtemUsuarioPadrao());
}
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 QuandoCrioUmProcessoDeCotacaoIniciaNoEstadoNaoIniciado()
{
var requisicaoDeCompra = DefaultObjects.ObtemRequisicaoDeCompraPadrao();
var processoDeCotacao = requisicaoDeCompra.GerarProcessoDeCotacaoDeMaterial();
Assert.AreEqual(Enumeradores.StatusProcessoCotacao.NaoIniciado, processoDeCotacao.Status);
}
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 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 QuandoCriaUmaSenhaEstaEAlterada()
{
var usuario = DefaultObjects.ObtemUsuarioPadrao();
usuario.CriarSenha("vetoa1051067");
Assert.AreEqual("vetoa1051067", usuario.Senha);
}
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 QuandoAdicionoUmPerfilOUsuarioPassaAContarEstePerfil()
{
Usuario usuario = DefaultObjects.ObtemUsuarioPadrao();
usuario.AdicionarPerfil(Enumeradores.Perfil.CompradorLogistica);
Assert.AreEqual(1, usuario.Perfis.Count(x => x == Enumeradores.Perfil.CompradorLogistica));
}
public void QuandoCriarUmAgendamentoSemNotaDeveGerarExcecao()
{
Quota quota = DefaultObjects.ObtemQuotaDeDescarregamento();
var factory = new AgendamentoDeDescarregamentoFactory();
factory.Construir(quota, "IOQ5338");
}
public void QuandoBloqueioUsuarioFicaComStatusBloqueado()
{
Usuario usuario = DefaultObjects.ObtemUsuarioPadrao();
usuario.Bloquear();
Assert.AreEqual(Enumeradores.StatusUsuario.Bloqueado, usuario.Status);
}
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 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 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 QuandoBloqueioRequisicaoDeCompraPassaParaEstadoBloqueado()
{
RequisicaoDeCompra requisicaoDeCompra = DefaultObjects.ObtemRequisicaoDeCompraPadrao();
requisicaoDeCompra.Bloquear();
Assert.AreEqual(Enumeradores.StatusRequisicaoCompra.Bloqueado, requisicaoDeCompra.Status);
}
public void ConsigoPersistirEConsultarUmaRequisicaoDeCompraSemInformarRequisitanteEFornecedorPretendido()
{
var requisicaoDeCompra = DefaultObjects.ObtemRequisicaoDeCompraSemRequisitanteEFornecedor();
DefaultPersistedObjects.PersistirRequisicaoDeCompra(requisicaoDeCompra);
UnitOfWorkNh.Session.Clear();
RequisicaoDeCompra requisicaoConsultada = _requisicoesDeCompra.BuscaPeloId(requisicaoDeCompra.Id);
Assert.IsNotNull(requisicaoConsultada);
Assert.AreEqual(requisicaoDeCompra.Criador.Login, requisicaoConsultada.Criador.Login);
Assert.IsNull(requisicaoConsultada.Requisitante);
Assert.IsNull(requisicaoConsultada.FornecedorPretendido);
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("REQ0001", requisicaoConsultada.Numero);
Assert.AreEqual("00001", requisicaoConsultada.NumeroItem);
}
public void NaoPermiteExcluirUmaQuotaQueJaPossuiAgendamento()
{
var quotaSemAgendamento = DefaultObjects.ObtemQuotaDeCarregamento();
var quotaComAgendamento = DefaultObjects.ObtemQuotaDeCarregamento();
quotaComAgendamento.InformarAgendamento(new AgendamentoDeCarregamentoCadastroVm
{
Peso = 10,
Placa = "IQI3342"
});
_quotasMock.Setup(x => x.List()).Returns(new List <Quota>()
{
quotaComAgendamento, quotaSemAgendamento
});
_quotasMock.Setup(x => x.Delete(It.IsAny <Quota>()));
_cadastroQuota.Salvar(DateTime.Today, new List <QuotaSalvarVm>
{
new QuotaSalvarVm
{
Data = DateTime.Today,
CodigoTerminal = "1000",
CodigoMaterial = (int)Enumeradores.MaterialDeCarga.Soja,
CodigoFornecedor = _fornecedor1.Codigo,
Peso = 100
}
});
}
