public void FixtureSetUp()
{
_portabilidade = PortabilidadeApropriadaBuilder.UmBuilder().Padrao().Build();
var premioAnterior = PremioBuilder.Um().Padrao().ComTipoMovimento((short)TipoMovimentoEnum.Inexistente).Build();
var retornoCobertura = CoberturaContratadaBuilder.Uma().Padrao().ComRegimeFinanceiro((short)TipoRegimeFinanceiroEnum.FundoAcumulacao);
var movimento = MovimentoProvisaoBuilder.UmBuilder().Padrao();
_retornoMovimento = new List <MovimentoProvisao>()
{
movimento.Build()
};
var retornoPremio = PremioBuilder.Um().Padrao()
.Com(movimento)
.Com(retornoCobertura)
.Build();
MockingKernel.GetMock <IPremioService>()
.Setup(x => x.CriarPremio(It.IsAny <Premio>(), It.IsAny <EventoPremio>())).Returns(Task.FromResult(retornoPremio));
MockingKernel.GetMock <ICoberturas>()
.Setup(x => x.ObterPorItemCertificado(It.IsAny <long>())).Returns(Task.FromResult(retornoCobertura.Build()));
MockingKernel.GetMock <ICalculadorProvisaoPremio>()
.Setup(x => x.CriarProvisao(It.IsAny <Premio>())).Returns(_retornoMovimento.AsEnumerable());
MockingKernel.GetMock <IPremios>()
.Setup(x => x.ObterPremioAnterior(It.IsAny <long>(), It.IsAny <int>())).Returns(Task.FromResult(premioAnterior));
_evento = MockingKernel.Get <EventoPremioFactory>().Fabricar(_portabilidade).Result;
}
public async Task DadoUmaPortabilidadeDeveRetornarOContrato()
{
var portabilidadePremio = PortabilidadeApropriadaBuilder.UmBuilder().Padrao().Build();
//MockingKernel.GetMock<IPipe<PortabilidadePremioContext>>()
// .Setup(x => x.Send(It.IsAny<PortabilidadePremioContext>()))
// .Returns(Task.FromResult(portabilidadePremio)).Verifiable();
var contrato = await MockingKernel.Get <PortabilidadePremioService>().Execute(portabilidadePremio);
Assert.That(contrato.Identificador, Is.EqualTo(portabilidadePremio.Identificador));
}
public void DadoUmaPortabilidadePremioDeveMapearOPremio()
{
_portabilidadePremio = PortabilidadeApropriadaBuilder.UmBuilder().Padrao().Build();
var premio = GetInstance <EventoPremioFactory>().Fabricar(_portabilidadePremio).Premios.First();
Assert.That(premio.Pagamento.DataPagamento, Is.EqualTo(IdentificadoresPadrao.DataPagamento));
Assert.That(premio.Pagamento.DataApropriacao, Is.EqualTo(IdentificadoresPadrao.DataApropriacao));
Assert.That(premio.Pagamento.ValorPago, Is.EqualTo(IdentificadoresPadrao.ValorPago));
Assert.That(premio.Pagamento.Desconto, Is.EqualTo(IdentificadoresPadrao.Desconto));
Assert.That(premio.Pagamento.Multa, Is.EqualTo(IdentificadoresPadrao.Multa));
Assert.That(premio.Pagamento.IOFARecolher, Is.EqualTo(IdentificadoresPadrao.IOFARecolher));
Assert.That(premio.Pagamento.IOFRetido, Is.EqualTo(IdentificadoresPadrao.IOFRetido));
Assert.That(premio.Pagamento.IdentificadorCredito, Is.EqualTo(IdentificadoresPadrao.IdentificadorCredito));
}
private IPortabilidadeApropriada ObterPortabilidadeApropriada()
{
var cobertura = _proposta.Produtos.First().Coberturas.First();
var aporte = PortabilidadeBuilder.UmBuilder()
.ComCodigoSusep(IdentificadoresPadrao.CodigoSusep)
.Com(PagamentoBuilder.UmBuilder().Padrao())
.ComValorBuilder(ValorBuilder.UmBuilder().Padrao())
.ComVigenciaBuilder(VigenciaBuilder.UmBuilder().Padrao())
.ComParcelaBuilder(ParcelaIdBuilder.UmBuilder()
.ComNumeroParcela(0).ComIdentificadorExternoCobertura(cobertura.IdentificadorExterno));
return(PortabilidadeApropriadaBuilder.UmBuilder()
.ComIdentificador(Guid.NewGuid())
.ComIdentificadorNegocio(_proposta.IdentificadorNegocio)
.ComDataExecucaoEvento(DateTime.Now)
.Com((PortabilidadeBuilder)aporte)
.Build());
}
public void DadoUmaPortabilidadeSemPremioDeveGerarErro()
{
_portabilidadePremio = PortabilidadeApropriadaBuilder.UmBuilder().ComIdentificador(IdentificadoresPadrao.Identificador).ComDataExecucaoEvento(DateTime.Now).Build();
Assert.That(() => _portabilidadePremio.Validar(), GeraErro("Nenhum prêmio informado."));
}
public void DadoUmaPortabilidadeComDataExcucaoInvalidaDeveGerarErro()
{
_portabilidadePremio = PortabilidadeApropriadaBuilder.UmBuilder().Build();
Assert.That(() => _portabilidadePremio.Validar(), GeraErro("A Data de Execução não pode ser nula."));
}
public void DadoUmPortabilidadeComIdentificadorInvalidaDeveGerarErro()
{
_portabilidadePremio = PortabilidadeApropriadaBuilder.UmBuilder().Build();
Assert.That(() => _portabilidadePremio.Validar(), GeraErro("O Identificador não pode ser nulo."));
}