public void QuandoCadastroQuotasComSucessoOcorrePersistencia()
{
//caso de uso: para a data de hoje tenho duas quotas cadastradas:uma para o fornecedor1 e outra para o fornecedor3
//salvo as cotações informando os fornecedores 1 e 3. O resultado esperado é que a quota do fornecedor1 seja atualizada,
//a quota do fornecedor2 seja atualizada e a quota do fornecedor seja criada.
_cadastroQuota.Salvar(DateTime.Today, new List <QuotaSalvarVm>
{
new QuotaSalvarVm
{
Data = DateTime.Today,
CodigoTerminal = "1000",
CodigoMaterial = (int)Enumeradores.MaterialDeCarga.Soja,
CodigoFornecedor = _fornecedor1.Codigo,
Peso = 100
},
new QuotaSalvarVm
{
Data = DateTime.Today,
CodigoTerminal = "1000",
CodigoMaterial = (int)Enumeradores.MaterialDeCarga.Soja,
CodigoFornecedor = _fornecedor3.Codigo,
Peso = 150
}
});
_quotasMock.Verify(x => x.Save(It.IsAny <Quota>()), Times.Exactly(2));
_quotasMock.Verify(x => x.Delete(It.IsAny <Quota>()), Times.Once());
CommonVerifications.VerificaCommitDeTransacao(_unitOfWorkMock);
}
public void QuandoCadastraUmNovoIvaOcorrePersistencia()
{
_cadastroIva.AtualizarIvas(_listaIvas);
_ivasMock.Verify(x => x.Save(It.IsAny <Iva>()), Times.Once());
_ivasMock.Verify(x => x.BuscaListaPorCodigo(It.IsAny <string[]>()), Times.Once());
CommonVerifications.VerificaCommitDeTransacao(_unitOfWorkMock);
}
public void QuandoBloqueioRequisicaoDeCompraComSucessoOcorrePersistencia()
{
var alterador = new AlteradorDeRequisicaoDeCompra(_unitOfWorkMock.Object, _requisicoesDeCompraMock.Object, _processosDeCotacaoDeMaterialMock.Object);
alterador.Bloquear(10);
CommonVerifications.VerificaCommitDeTransacao(_unitOfWorkMock);
}
public void QuandoCadastraUmNovoIncotermOcorrePersistencia()
{
_cadastroIncoterm.AtualizarIncoterms(_listaIncoterms);
_incotermsMock.Verify(x => x.Save(It.IsAny <Incoterm>()), Times.Once());
_incotermsMock.Verify(x => x.FiltraPorListaDeCodigos(It.IsAny <string[]>()), Times.Once());
CommonVerifications.VerificaCommitDeTransacao(_unitOfWorkMock);
}
public void QuandoCadastroUmNovoProdutoEPersistidoNoBanco()
{
_cadastroProduto.Novo(_produtoPadrao);
_produtosMock.Verify(x => x.Save(It.IsAny <Produto>()), Times.Once());
_produtosMock.Verify(x => x.FiltraPorListaDeCodigos(It.IsAny <string[]>()), Times.Once());
CommonVerifications.VerificaCommitDeTransacao(_unitOfWorkMock);
}
public void QuandoCadastraUmNovaUnidadeDeMedidaOcorrePersistencia()
{
_cadastroUnidadeDeMedida.AtualizarUnidadesDeMedida(_listaunidadesDeMedida);
_unidadesDeMedidaMock.Verify(x => x.Save(It.IsAny <UnidadeDeMedida>()), Times.Once());
_unidadesDeMedidaMock.Verify(x => x.FiltraPorListaDeCodigosInternos(It.IsAny <string[]>()), Times.Once());
CommonVerifications.VerificaCommitDeTransacao(_unitOfWorkMock);
}
public void QuandoAtualizaProcessoOcorrePersistencia()
{
_processoDeCotacaoService.AtualizarProcesso(_atualizacaoDoProcessoDeCotacaoVm);
_processosDeCotacaoMock.Verify(x => x.Save(It.IsAny <ProcessoDeCotacao>()), Times.Once());
CommonVerifications.VerificaCommitDeTransacao(_unitOfWorkMock);
}
public void NaoDevePermtirBloquearUmaRequisicaDeCompraQueJaEstejaVinculadaComUmProcessoDeCotacaoDeMateriais()
{
//configuro count para retornar 1. Com isso consulta que verifica o número de processo vinculados a requisicaodecompra retorna 1.
_processosDeCotacaoDeMaterialMock.Setup(x => x.Count()).Returns(1);
var alterador = new AlteradorDeRequisicaoDeCompra(_unitOfWorkMock.Object, _requisicoesDeCompraMock.Object, _processosDeCotacaoDeMaterialMock.Object);
alterador.Bloquear(10);
_processosDeCotacaoDeMaterialMock.Verify(x => x.Count(), Times.Once());
CommonVerifications.VerificaRollBackDeTransacao(_unitOfWorkMock);
}
public void QuandoCadastroUmaNovaCondicaoDePagamentoOcorrePersistencia()
{
_cadastroCondicaoPagamento.AtualizarCondicoesDePagamento(new List <CondicaoDePagamentoCadastroVm>()
{
_condicaoPagamento01
});
_condicoesDePagamentoMock.Verify(x => x.Save(It.IsAny <CondicaoDePagamento>()), Times.Once());
_condicoesDePagamentoMock.Verify(x => x.FiltraPorListaDeCodigos(It.IsAny <string[]>()), Times.Once());
CommonVerifications.VerificaCommitDeTransacao(_unitOfWorkMock);
}
public void QuandoOsItensSaoAtualizadosComSucessoOcorrePersistencia()
{
_processosDeCotacaoMock.Setup(x => x.Save(It.IsAny <ProcessoDeCotacao>()))
.Callback((ProcessoDeCotacao processoDeCotacao) => Assert.IsNotNull(processoDeCotacao));
_service.AtualizarItens(1, new List <int> {
1, 2
});
_processosDeCotacaoMock.Verify(x => x.Save(It.IsAny <ProcessoDeCotacao>()), Times.Once());
CommonVerifications.VerificaCommitDeTransacao(_unitOfWorkMock);
}
public void QuandoOcorreAlgumaExcecaoFazRollback()
{
_usuariosMock.Setup(x => x.Save(It.IsAny <Usuario>())).Throws(new ExcecaoDeTeste("Ocorreu um erro ao cadastrar o usuário"));
try
{
_cadastroUsuario.Novo(_usuarioPadrao);
}
catch (ExcecaoDeTeste)
{
CommonVerifications.VerificaRollBackDeTransacao(_unitOfWorkMock);
}
}
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 QuandoOcorreAlgumExcecaoAoCadastrarUmProdutoFazRollback()
{
_produtosMock.Setup(x => x.Save(It.IsAny <Produto>())).Throws(new ExcecaoDeTeste("Ocorreu um erro ao cadastrar o produto"));
try
{
_cadastroProduto.Novo(_produtoPadrao);
Assert.Fail("Deveria ter gerado excessão");
}
catch (ExcecaoDeTeste)
{
CommonVerifications.VerificaRollBackDeTransacao(_unitOfWorkMock);
}
}
public void QuandoOcorreAlgumErroAoAtualizarProcessoEFeitoRollbackNaTransacao()
{
try
{
_processosDeCotacaoMock.Setup(x => x.BuscaPorId(It.IsAny <int>()))
.Throws(new ExcecaoDeTeste("Ocorreu um erro ao consultar o Processo de Cotação."));
_processoDeCotacaoService.AtualizarProcesso(_atualizacaoDoProcessoDeCotacaoVm);
Assert.Fail("Deveria ter gerado exceção");
}
catch (ExcecaoDeTeste)
{
CommonVerifications.VerificaRollBackDeTransacao(_unitOfWorkMock);
}
}
public void QuandoOcorreErroAoCriarSenhaOcorreRollbackNaTrasacao()
{
_usuariosMock.Setup(x => x.BuscaPorLogin(It.IsAny <string>()))
.Throws(new ExcecaoDeTeste("Erro ao consultar usuário"));
try
{
_gerenciadorUsuario.CriarSenha("USER001");
}
catch (ExcecaoDeTeste)
{
CommonVerifications.VerificaRollBackDeTransacao(_unitOfWorkMock);
}
}
public void QuandoOcorreErroAoFecharProcessoOcorreRollbackDaTransacao()
{
_processosDeCotacaoMock.Setup(x => x.BuscaPorId(It.IsAny <int>()))
.Throws(new ExcecaoDeTeste("Erro ao consultar Processo."));
try
{
_fechamentoDeProcessoDeCotacaoService.Executar(_processoDeCotacaoFechamentoVm);
Assert.Fail("Deveria ter gerado exceção");
}
catch (ExcecaoDeTeste)
{
CommonVerifications.VerificaRollBackDeTransacao(_unitOfWorkMock);
}
}
public void QuandoOcorreErroAoAtualizarOcorreRollback()
{
_processoCotacaoIteracoesUsuarioMock.Setup(x => x.BuscaPorIdParticipante(It.IsAny <int>()))
.Throws(new ExcecaoDeTeste("Ocorreu erro ao consultar a iteração do usuário"));
try
{
_atualizadorDeIteracaoDoUsuario.Atualizar(10);
}
catch (ExcecaoDeTeste)
{
CommonVerifications.VerificaRollBackDeTransacao(_unitOfWorkMock);
}
}
public void QuandoOcorrerAlgumErroAoAtualizarCotacaoDoFornecedorOcorreRollbackNaTransacao()
{
_processosDeCotacaoMock.Setup(x => x.BuscaPorId(It.IsAny <int>()))
.Throws(new ExcecaoDeTeste("Erro ao consultar Processo de Cotação"));
try
{
_atualizadorDeCotacao.AtualizarCotacao(_cotacaoAtualizarVm);
Assert.Fail("Deveria ter gerado exceção");
}
catch (ExcecaoDeTeste)
{
CommonVerifications.VerificaRollBackDeTransacao(_unitOfWorkMock);
}
}
public void QuandoOcorreErroAoSalvarQuotasFazRollback()
{
_quotasMock.Setup(x => x.FiltraPorData(It.IsAny <DateTime>()))
.Throws(new ExcecaoDeTeste("Ocorreu um erro ao consultar as quotas da data"));
try
{
_cadastroQuota.Salvar(DateTime.Today, new List <QuotaSalvarVm>());
Assert.Fail("Deveria ter gerado exceção");
}
catch (Exception)
{
CommonVerifications.VerificaRollBackDeTransacao(_unitOfWorkMock);
}
}
public void QuandoOcorreAlgumExcecaoNoCadastroDaUnidadeDeMedidaFazRollBackNaTransacao()
{
_unidadesDeMedidaMock.Setup(x => x.Save(It.IsAny <UnidadeDeMedida>()))
.Throws(new ExcecaoDeTeste("Ocorreu um erro ao cadastrar a Unidade de Medida"));
try
{
_cadastroUnidadeDeMedida.AtualizarUnidadesDeMedida(_listaunidadesDeMedida);
Assert.Fail("Deveria ter gerado exceção");
}
catch (ExcecaoDeTeste)
{
CommonVerifications.VerificaRollBackDeTransacao(_unitOfWorkMock);
}
}
public void QuandoOcorreAlgumExcecaoNoCadastroDoIncotermFazRollBackNaTransacao()
{
_incotermsMock.Setup(x => x.Save(It.IsAny <Incoterm>()))
.Throws(new ExcecaoDeTeste("Ocorreu um erro ao cadastrar o Iva"));
try
{
_cadastroIncoterm.AtualizarIncoterms(_listaIncoterms);
Assert.Fail("Deveria ter gerado exceção");
}
catch (ExcecaoDeTeste)
{
CommonVerifications.VerificaRollBackDeTransacao(_unitOfWorkMock);
}
}
public void QuandoOcorreAlgumaExcecaoEhRealizadoRollback()
{
_fornecedoresMock.Setup(x => x.Save(It.IsAny <Fornecedor>()))
.Throws(new ExcecaoDeTeste("Ocorreu um erro ao cadastrar o Fornecedor"));
try
{
_cadastroFornecedor.Novo(_fornecedorCadastroVm);
Assert.Fail("Deveria ter gerado excessão");
}
catch (ExcecaoDeTeste)
{
CommonVerifications.VerificaRollBackDeTransacao(_unitOfWorkMock);
}
}
public void QuandoOcorreAlgumErroDuranteProcessoDeAtualizacaoDeFornecedoresOcorreRollbackNaTransacao()
{
_processosDeCotacaoMock.Setup(x => x.BuscaPorId(It.IsAny <int>()))
.Throws(
new ExcecaoDeTeste(
"Ocorreu um erro ao consultar o processo de cotação de material"));
try
{
_processoDeCotacaoFornecedoresService.AtualizarFornecedores(_atualizacaoDosFornecedoresVm);
Assert.Fail("Deveria ter gerado excessão");
}
catch (ExcecaoDeTeste)
{
CommonVerifications.VerificaRollBackDeTransacao(_unitOfWorkMock);
}
}
public void QuandoOcorreAlgumErroAoBloquearRequisicaoDeCompraNaoOcorrePersistencia()
{
//faço disparar uma exceção no método save do repositório
_requisicoesDeCompraMock.Setup(x => x.Save(It.IsAny <RequisicaoDeCompra>()))
.Throws(new ExcecaoDeTeste("erro ao salvar requisição"));
try
{
var alterador = new AlteradorDeRequisicaoDeCompra(_unitOfWorkMock.Object, _requisicoesDeCompraMock.Object, _processosDeCotacaoDeMaterialMock.Object);
alterador.Bloquear(10);
Assert.Fail("Deveria ter gerado exceção");
}
catch (Exception)
{
CommonVerifications.VerificaRollBackDeTransacao(_unitOfWorkMock);
}
}
public ProcessoDeCotacaoFornecedoresServiceTests()
{
_unitOfWorkMock = CommonMocks.DefaultUnitOfWorkMock();
_processosDeCotacaoMock = new Mock <IProcessosDeCotacao>(MockBehavior.Strict);
_processosDeCotacaoMock.Setup(x => x.Save(It.IsAny <ProcessoDeCotacao>()))
.Callback(
(ProcessoDeCotacao processoDeCotacao) =>
{
Assert.IsNotNull(processoDeCotacao);
foreach (var fornecedorParticipante in processoDeCotacao.FornecedoresParticipantes)
{
Assert.IsNotNull(fornecedorParticipante);
}
});
ProcessoDeCotacaoDeMaterial processoDeCotacaoDeMaterial = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialNaoIniciado();
processoDeCotacaoDeMaterial.AdicionarFornecedor(new Fornecedor("FORNEC0001", "FORNECEDOR 0001", "*****@*****.**", "", "", "", false));
processoDeCotacaoDeMaterial.AdicionarFornecedor(new Fornecedor("FORNEC0002", "FORNECEDOR 0002", "*****@*****.**", "", "", "", false));
_processosDeCotacaoMock.Setup(x => x.BuscaPorId(It.IsAny <int>()))
.Returns(_processosDeCotacaoMock.Object);
_processosDeCotacaoMock.Setup(x => x.Single())
.Returns(processoDeCotacaoDeMaterial);
_fornecedoresMock = new Mock <IFornecedores>(MockBehavior.Strict);
_fornecedoresMock.Setup(x => x.BuscaListaPorCodigo(It.IsAny <string[]>()))
.Returns(_fornecedoresMock.Object);
_fornecedoresMock.Setup(x => x.List())
.Returns(new List <Fornecedor>()
{
new Fornecedor("FORNEC0003", "FORNECEDOR 0003", "*****@*****.**", "", "", "", false)
});
_atualizadorDeIteracaoDoUsuarioMock = new Mock <IAtualizadorDeIteracaoDoUsuario>(MockBehavior.Strict);
_atualizadorDeIteracaoDoUsuarioMock.Setup(x => x.Adicionar(It.IsAny <IList <FornecedorParticipante> >()))
.Callback((IList <FornecedorParticipante> fp) => CommonVerifications.VerificaCommitDeTransacao(_unitOfWorkMock));
_processoDeCotacaoFornecedoresService = new ProcessoDeCotacaoFornecedoresService(_unitOfWorkMock.Object, _processosDeCotacaoMock.Object,
_fornecedoresMock.Object, _atualizadorDeIteracaoDoUsuarioMock.Object);
_atualizacaoDosFornecedoresVm = new ProcessoDeCotacaoFornecedoresAtualizarVm()
{
IdProcessoCotacao = 1,
CodigoFornecedoresSelecionados = new[] { "FORNEC0001", "FORNEC0003" }
};
}
public void QuandoOcorreErroAoSalvarItensOcorreRollBack()
{
//força um erro em um dos métodos utilizados pelo serviço
_processosDeCotacaoMock.Setup(x => x.BuscaPorId(It.IsAny <int>()))
.Throws(new ExcecaoDeTeste("Ocorreu erro ao consultar o Processo de Cotação"));
try
{
_service.AtualizarItens(1, new List <int> {
2, 3
});
Assert.Fail("Deveria ter gerado excessão");
}
catch (ExcecaoDeTeste)
{
CommonVerifications.VerificaRollBackDeTransacao(_unitOfWorkMock);
}
}
public void QuandoOcorreErroAoAdicionarIteracaoDeUsuarioFazRollback()
{
_processoCotacaoIteracoesUsuarioMock.Setup(x => x.Save(It.IsAny <ProcessoCotacaoIteracaoUsuario>()))
.Throws(new ExcecaoDeTeste("Erro"));
IList <FornecedorParticipante> fornecedoresParticipantes = new List <FornecedorParticipante>();
try
{
ProcessoDeCotacao processoDeCotacao = DefaultObjects.ObtemProcessoDeCotacaoDeFrete();
fornecedoresParticipantes.Add(processoDeCotacao.AdicionarFornecedor(DefaultObjects.ObtemFornecedorPadrao()));
fornecedoresParticipantes.Add(processoDeCotacao.AdicionarFornecedor(DefaultObjects.ObtemFornecedorPadrao()));
_atualizadorDeIteracaoDoUsuario.Adicionar(fornecedoresParticipantes);
Assert.Fail("Deveria ter gerado exceção.");
}
catch (ExcecaoDeTeste)
{
_processoCotacaoIteracoesUsuarioMock.Verify(x => x.Save(It.IsAny <ProcessoCotacaoIteracaoUsuario>()), Times.Once());
CommonVerifications.VerificaRollBackDeTransacao(_unitOfWorkMock);
}
}
public void QuandoOProcessoEFechadoOcorrePersistencia()
{
_fechamentoDeProcessoDeCotacaoService.Executar(_processoDeCotacaoFechamentoVm);
_processosDeCotacaoMock.Verify(x => x.Save(It.IsAny <ProcessoDeCotacao>()), Times.Once());
CommonVerifications.VerificaCommitDeTransacao(_unitOfWorkMock);
}
public void QuandoAtualizoItemDaCotacaoDoFornecedorOcorrePersistencia()
{
_atualizadorDeCotacao.AtualizarItemDaCotacao(_cotacaoItemAtualizarVm);
_processosDeCotacaoMock.Verify(x => x.Save(It.IsAny <ProcessoDeCotacao>()), Times.Once());
CommonVerifications.VerificaCommitDeTransacao(_unitOfWorkMock);
}
public void QuandoAtualizaComSucessoOcorrePersistencia()
{
_atualizadorDeIteracaoDoUsuario.Atualizar(10);
_processoCotacaoIteracoesUsuarioMock.Verify(x => x.Save(It.IsAny <ProcessoCotacaoIteracaoUsuario>()), Times.Once());
CommonVerifications.VerificaCommitDeTransacao(_unitOfWorkMock);
}
