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 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 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 QuandoPersistoUmIvaComSucessoConsigoConsultarPosteriormente()
{
UnitOfWorkNh.BeginTransaction();
var iva = DefaultObjects.ObtemIvaPadrao();
UnitOfWorkNh.Session.Save(iva);
UnitOfWorkNh.Commit();
var ivas = ObjectFactory.GetInstance <IIvas>();
Iva ivaConsultado = ivas.BuscaPeloCodigo(iva.Codigo);
Assert.IsNotNull(ivaConsultado);
Assert.AreEqual(iva.Codigo, ivaConsultado.Codigo);
Assert.AreEqual(iva.Descricao, ivaConsultado.Descricao);
}
public void QuandoPersistoUmItinerarioComSucessoConsigoConsultarPosteriormente()
{
UnitOfWorkNh.BeginTransaction();
Itinerario itinerario = DefaultObjects.ObtemItinerarioPadrao();
UnitOfWorkNh.Session.Save(itinerario);
UnitOfWorkNh.Commit();
UnitOfWorkNh.Session.Clear();
var itinerarios = ObjectFactory.GetInstance <IItinerarios>();
Itinerario itinerarioConsultado = itinerarios.BuscaPeloCodigo(itinerario.Codigo).Single();
Assert.IsNotNull(itinerarioConsultado);
Assert.AreEqual(itinerario.Codigo, itinerarioConsultado.Codigo);
Assert.AreEqual(itinerario.Descricao, itinerarioConsultado.Descricao);
}
public void ConsigoCadastrarUmItinerarioComAcentuacaoEspeciaisNaDescricao()
{
UnitOfWorkNh.BeginTransaction();
Itinerario itinerario = DefaultObjects.ObtemItinerarioPadrao();
itinerario.AtualizaDescricao("RS Rio Grande -> AL Olho D Água Das Flor");
UnitOfWorkNh.Session.Save(itinerario);
UnitOfWorkNh.Commit();
UnitOfWorkNh.Session.Clear();
var itinerarios = ObjectFactory.GetInstance <IItinerarios>();
Itinerario itinerarioConsultado = itinerarios.BuscaPeloCodigo(itinerario.Codigo).Single();
Assert.IsNotNull(itinerarioConsultado);
Assert.AreEqual(itinerario.Codigo, itinerarioConsultado.Codigo);
Assert.AreEqual(itinerario.Descricao, itinerarioConsultado.Descricao);
}
public void QuandoPersistoUmItinerarioComSucessoConsigoConsultarPosteriormente()
{
UnitOfWorkNh.BeginTransaction();
UnidadeDeMedida unidadeDeMedida = DefaultObjects.ObtemUnidadeDeMedidaPadrao();
UnitOfWorkNh.Session.Save(unidadeDeMedida);
UnitOfWorkNh.Commit();
UnitOfWorkNh.Session.Clear();
var unidadesDeMedida = ObjectFactory.GetInstance <IUnidadesDeMedida>();
UnidadeDeMedida unidadeDeMedidaConsultada = unidadesDeMedida.BuscaPeloCodigoInterno(unidadeDeMedida.CodigoInterno).Single();
Assert.IsNotNull(unidadeDeMedidaConsultada);
Assert.AreEqual(unidadeDeMedida.CodigoInterno, unidadeDeMedidaConsultada.CodigoInterno);
Assert.AreEqual(unidadeDeMedida.CodigoExterno, unidadeDeMedidaConsultada.CodigoExterno);
Assert.AreEqual(unidadeDeMedida.Descricao, unidadeDeMedidaConsultada.Descricao);
}
public void QuandoFiltroPorListaDeLoginTemQueRetornarUsuariosCorrespondenteAosLogins()
{
UnitOfWorkNh.BeginTransaction();
Usuario usuario1 = DefaultObjects.ObtemUsuarioPadrao();
Usuario usuario2 = DefaultObjects.ObtemUsuarioPadrao();
Usuario usuario3 = DefaultObjects.ObtemUsuarioPadrao();
UnitOfWorkNh.Session.Save(usuario1);
UnitOfWorkNh.Session.Save(usuario2);
UnitOfWorkNh.Session.Save(usuario3);
UnitOfWorkNh.Commit();
UnitOfWorkNh.Session.Clear();
var usuarios = ObjectFactory.GetInstance <IUsuarios>();
IList <Usuario> usuariosConsultados = usuarios.FiltraPorListaDeLogins(new[] { usuario1.Login, usuario2.Login }).List();
Assert.AreEqual(2, usuariosConsultados.Count);
Assert.AreEqual(1, usuariosConsultados.Count(x => x.Login == usuario1.Login));
Assert.AreEqual(1, usuariosConsultados.Count(x => x.Login == usuario2.Login));
}
public void QuandoFiltroPorListaDeCodigoTemQueRetornarProdutosCorrespondenteAosCodigos()
{
UnitOfWorkNh.BeginTransaction();
Produto produto1 = DefaultObjects.ObtemProdutoPadrao();
Produto produto2 = DefaultObjects.ObtemProdutoPadrao();
Produto produto3 = DefaultObjects.ObtemProdutoPadrao();
UnitOfWorkNh.Session.Save(produto1);
UnitOfWorkNh.Session.Save(produto2);
UnitOfWorkNh.Session.Save(produto3);
UnitOfWorkNh.Commit();
UnitOfWorkNh.Session.Clear();
var produtos = ObjectFactory.GetInstance <IProdutos>();
IList <Produto> produtosConsultados = produtos.FiltraPorListaDeCodigos(new[] { produto1.Codigo, produto2.Codigo }).List();
Assert.AreEqual(2, produtosConsultados.Count);
Assert.AreEqual(1, produtosConsultados.Count(x => x.Codigo == produto1.Codigo));
Assert.AreEqual(1, produtosConsultados.Count(x => x.Codigo == produto2.Codigo));
}
public void QuandoFiltroPorListaDeCodigoTemQueRetornarItinerariosCorrespondenteAosCodigos()
{
UnitOfWorkNh.BeginTransaction();
Itinerario itinerario1 = DefaultObjects.ObtemItinerarioPadrao();
Itinerario itinerario2 = DefaultObjects.ObtemItinerarioPadrao();
Itinerario itinerario3 = DefaultObjects.ObtemItinerarioPadrao();
UnitOfWorkNh.Session.Save(itinerario1);
UnitOfWorkNh.Session.Save(itinerario2);
UnitOfWorkNh.Session.Save(itinerario3);
UnitOfWorkNh.Commit();
UnitOfWorkNh.Session.Clear();
var itinerarios = ObjectFactory.GetInstance <IItinerarios>();
IList <Itinerario> itinerariosConsultados = itinerarios.FiltraPorListaDeCodigos(new[] { itinerario1.Codigo, itinerario2.Codigo }).List();
Assert.AreEqual(2, itinerariosConsultados.Count);
Assert.AreEqual(1, itinerariosConsultados.Count(x => x.Codigo == itinerario1.Codigo));
Assert.AreEqual(1, itinerariosConsultados.Count(x => x.Codigo == itinerario2.Codigo));
}
public void QuandoFiltroPorListaDeCodigoInternoTemQueRetornarUnidadesDeMedidaCorrespondentesAosCodigos()
{
UnitOfWorkNh.BeginTransaction();
UnidadeDeMedida unidadeDeMedida1 = DefaultObjects.ObtemUnidadeDeMedidaPadrao();
UnidadeDeMedida unidadeDeMedida2 = DefaultObjects.ObtemUnidadeDeMedidaPadrao();
UnidadeDeMedida unidadeDeMedida3 = DefaultObjects.ObtemUnidadeDeMedidaPadrao();
UnitOfWorkNh.Session.Save(unidadeDeMedida1);
UnitOfWorkNh.Session.Save(unidadeDeMedida2);
UnitOfWorkNh.Session.Save(unidadeDeMedida3);
UnitOfWorkNh.Commit();
UnitOfWorkNh.Session.Clear();
var unidadesDeMedida = ObjectFactory.GetInstance <IUnidadesDeMedida>();
IList <UnidadeDeMedida> unidadesDeMedidaConsultadas = unidadesDeMedida.FiltraPorListaDeCodigosInternos(new[] { unidadeDeMedida1.CodigoInterno, unidadeDeMedida2.CodigoInterno }).List();
Assert.AreEqual(2, unidadesDeMedidaConsultadas.Count);
Assert.AreEqual(1, unidadesDeMedidaConsultadas.Count(x => x.CodigoInterno == unidadeDeMedida1.CodigoInterno));
Assert.AreEqual(1, unidadesDeMedidaConsultadas.Count(x => x.CodigoInterno == unidadeDeMedida2.CodigoInterno));
}
public void QuandoFiltroPorListaDeCodigoTemQueRetornarIncotermsCorrespondenteAosCodigos()
{
UnitOfWorkNh.BeginTransaction();
Incoterm incoterm1 = DefaultObjects.ObtemIncotermPadrao();
Incoterm incoterm2 = DefaultObjects.ObtemIncotermPadrao();
Incoterm incoterm3 = DefaultObjects.ObtemIncotermPadrao();
UnitOfWorkNh.Session.Save(incoterm1);
UnitOfWorkNh.Session.Save(incoterm2);
UnitOfWorkNh.Session.Save(incoterm3);
UnitOfWorkNh.Commit();
UnitOfWorkNh.Session.Clear();
var incoterms = ObjectFactory.GetInstance <IIncoterms>();
IList <Incoterm> incotermsConsultados = incoterms.FiltraPorListaDeCodigos(new[] { incoterm1.Codigo, incoterm2.Codigo }).List();
Assert.AreEqual(2, incotermsConsultados.Count);
Assert.AreEqual(1, incotermsConsultados.Count(x => x.Codigo == incoterm1.Codigo));
Assert.AreEqual(1, incotermsConsultados.Count(x => x.Codigo == incoterm2.Codigo));
}
public void QuandoFiltroPorListaDeCodigoTemQueRetornarIncotermsCorrespondenteAosCodigos()
{
UnitOfWorkNh.BeginTransaction();
CondicaoDePagamento condicaoDePagamento1 = DefaultObjects.ObtemCondicaoDePagamentoPadrao();
CondicaoDePagamento condicaoDePagamento2 = DefaultObjects.ObtemCondicaoDePagamentoPadrao();
CondicaoDePagamento condicaoDePagamento3 = DefaultObjects.ObtemCondicaoDePagamentoPadrao();
UnitOfWorkNh.Session.Save(condicaoDePagamento1);
UnitOfWorkNh.Session.Save(condicaoDePagamento2);
UnitOfWorkNh.Session.Save(condicaoDePagamento3);
UnitOfWorkNh.Commit();
UnitOfWorkNh.Session.Clear();
var condicoesDePagamento = ObjectFactory.GetInstance <ICondicoesDePagamento>();
IList <CondicaoDePagamento> condicoesConsultadas = condicoesDePagamento.FiltraPorListaDeCodigos(new[] { condicaoDePagamento1.Codigo, condicaoDePagamento2.Codigo }).List();
Assert.AreEqual(2, condicoesConsultadas.Count);
Assert.AreEqual(1, condicoesConsultadas.Count(x => x.Codigo == condicaoDePagamento1.Codigo));
Assert.AreEqual(1, condicoesConsultadas.Count(x => x.Codigo == condicaoDePagamento2.Codigo));
}
public void QuandoPersistoUmaCondicaoDePagamentoComSucessoConsigoConsultarPosteriormente()
{
try
{
UnitOfWorkNh.BeginTransaction();
var condicaoDePagamento = new CondicaoDePagamento("C001", "CONDICAO 0001");
UnitOfWorkNh.Session.Save(condicaoDePagamento);
UnitOfWorkNh.Commit();
}
catch (Exception)
{
UnitOfWorkNh.RollBack();
throw;
}
var condicoesDePagamento = ObjectFactory.GetInstance <ICondicoesDePagamento>();
CondicaoDePagamento condicaoDePagamentoConsulta = condicoesDePagamento.BuscaPeloCodigo("C001");
Assert.IsNotNull(condicaoDePagamentoConsulta);
Assert.AreEqual("C001", condicaoDePagamentoConsulta.Codigo);
}
public void ConsigoConsultarDoisProdutosSeguidosPeloCodigoUtilizandoAMesmaInstanciaDoRepositorio()
{
UnitOfWorkNh.BeginTransaction();
Produto produto1 = DefaultObjects.ObtemProdutoPadrao();
Produto produto2 = DefaultObjects.ObtemProdutoPadrao();
UnitOfWorkNh.Session.Save(produto1);
UnitOfWorkNh.Session.Save(produto2);
UnitOfWorkNh.Commit();
UnitOfWorkNh.Session.Clear();
var produtos = ObjectFactory.GetInstance <IProdutos>();
Produto produto1Consultado = produtos.BuscaPeloCodigo(produto1.Codigo);
Produto produto2Consultado = produtos.BuscaPeloCodigo(produto2.Codigo);
Assert.AreEqual(produto1Consultado.Codigo, produto1.Codigo);
Assert.AreEqual(produto1Consultado.Descricao, produto1.Descricao);
Assert.AreEqual(produto1Consultado.Tipo, produto1.Tipo);
Assert.AreEqual(produto2Consultado.Codigo, produto2.Codigo);
Assert.AreEqual(produto2Consultado.Descricao, produto2.Descricao);
Assert.AreEqual(produto2Consultado.Tipo, produto2.Tipo);
}
public void QuandoPersistoUmProdutoComFornecedoresConsigoConsultarOsFornecedoresPosteriormente()
{
Produto produto;
try
{
UnitOfWorkNh.BeginTransaction();
produto = DefaultObjects.ObtemProdutoPadrao();
Fornecedor fornecedor1 = DefaultObjects.ObtemFornecedorPadrao();
Fornecedor fornecedor2 = DefaultObjects.ObtemFornecedorPadrao();
_fornecedores.Save(fornecedor1);
_fornecedores.Save(fornecedor2);
var fornecedores = new List <Fornecedor>()
{
fornecedor1, fornecedor2
};
produto.AdicionarFornecedores(fornecedores);
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.AreEqual(2, produtoConsultado.Fornecedores.Count);
}
public void ConsigoAlterarUmFornecedorCadastrado()
{
var fornecedor = DefaultObjects.ObtemFornecedorPadrao();
DefaultPersistedObjects.PersistirFornecedor(fornecedor);
var fornecedores = ObjectFactory.GetInstance <IFornecedores>();
UnitOfWorkNh.Session.Clear();
try
{
UnitOfWorkNh.BeginTransaction();
var fornecedorConsulta = fornecedores.BuscaPeloCodigo(fornecedor.Codigo);
fornecedorConsulta.Atualizar("FORNECEDOR ALTERADO", "*****@*****.**", "cnpj alterado", "municipio alterado", "uf", false);
fornecedores.Save(fornecedorConsulta);
UnitOfWorkNh.Commit();
}
catch (Exception)
{
UnitOfWorkNh.RollBack();
throw;
}
UnitOfWorkNh.Session.Clear();
var fornecedorConsultaAtualizacao = fornecedores.BuscaPeloCodigo(fornecedor.Codigo);
Assert.AreEqual(fornecedor.Codigo, fornecedorConsultaAtualizacao.Codigo);
Assert.AreEqual("FORNECEDOR ALTERADO", fornecedorConsultaAtualizacao.Nome);
Assert.AreEqual("*****@*****.**", fornecedorConsultaAtualizacao.Email);
Assert.AreEqual("cnpj alterado", fornecedorConsultaAtualizacao.Cnpj);
Assert.AreEqual("municipio alterado", fornecedorConsultaAtualizacao.Municipio);
Assert.AreEqual("uf", fornecedorConsultaAtualizacao.Uf);
}
public void ConsigoSalvarUmaIteracaoDoUsuarioNoProcessoDeCotacaoEConsultarPosteriormente()
{
var repositorio = ObjectFactory.GetInstance <IProcessoCotacaoIteracoesUsuario>();
var iteracaoUsuario = new ProcessoCotacaoIteracaoUsuario(10);
try
{
UnitOfWorkNh.BeginTransaction();
repositorio.Save(iteracaoUsuario);
UnitOfWorkNh.Commit();
}
catch (Exception)
{
UnitOfWorkNh.RollBack();
throw;
}
UnitOfWorkNh.Session.Clear();
ProcessoCotacaoIteracaoUsuario iteracaoUsuarioConsultada = repositorio.BuscaPorIdParticipante(iteracaoUsuario.IdFornecedorParticipante);
Assert.AreEqual(iteracaoUsuario.IdFornecedorParticipante, iteracaoUsuarioConsultada.IdFornecedorParticipante);
Assert.IsFalse(iteracaoUsuarioConsultada.VisualizadoPeloFornecedor);
}
