public void FixtureSetUp()
{
_parcelaEmitida = ParcelaEmitidaBuilder.UmBuilder().Padrao().Build();
var premioAnterior = PremioBuilder.Um().Padrao().ComTipoMovimento((short)TipoMovimentoEnum.Inexistente).Build();
var retornoCobertura = CoberturaContratadaBuilder.Uma().Padrao();
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(_parcelaEmitida).Result;
}
public void SetUpFixture()
{
var movimentoProvisao = MovimentoProvisaoBuilder.UmBuilder().Padrao().Build();
var cobertutaAtiva = CoberturaContratadaBuilder.Uma().ComStatus(StatusCoberturaEnum.Activa).ComRegimeFinanceiro((short)TipoRegimeFinanceiroEnum.ReparticaoSimples).Build();
_premio = ParcelaEmitidaBuilder.UmBuilder().Padrao().Build();
_contexto = new EmissaoPremioContext(_premio)
{
Premios = _premio.ToEventoPremio()
};
MockingKernel.GetMock <IPremios>()
.Setup(x => x.VerificarUltimoPremio(long.MinValue, short.MinValue, int.MinValue)).Returns(Task.FromResult(false));
MockingKernel.GetMock <ICoberturas>()
.Setup(x => x.ObterPorItemCertificado(It.IsAny <long>())).Returns(Task.FromResult(cobertutaAtiva));
MockingKernel.GetMock <ICalculadorProvisaoPremio>()
.Setup(c => c.CriarProvisao(It.IsAny <Premio>(), TipoEventoEnum.EmissaoPremio)).Returns(new List <MovimentoProvisao>()
{
movimentoProvisao
}.AsEnumerable());
var pipeline = GreenPipes.Pipe.New <EmissaoPremioContext>(cfg =>
{
cfg.AddFilter(() => MockingKernel.Get <EmissaoPremioFilter>());
});
pipeline.Send(_contexto).Wait();
}
public static void ValidarPremioEmitido(this IParcelaEmitida eventoEmissao)
{
eventoEmissao.Validar();
Assertion.NotNull(eventoEmissao.Parcelas, "Nenhum prêmio para ser emitido.").Validate();
eventoEmissao.Parcelas.Select(p => p.ValidarPremio()).Aggregate(Assertion.Neutral(), (x, y) => x.and(y)).Validate();
}
public static IEnumerable <Domain.Premio> ToEventoPremio(this IParcelaEmitida premioEmitido)
{
var evento = new EventoEmissaoPremio(premioEmitido.Identificador, premioEmitido.IdentificadorCorrelacao, premioEmitido.IdentificadorNegocio, premioEmitido.DataExecucaoEvento);
premioEmitido.Parcelas.SafeForEach(premio => evento.AdicionarPremiosEmitidos(premio.ToPremio <Domain.Premio>()));
return(evento.Premios);
}
protected new void FixtureSetUp()
{
ProcessarImplatacao(true, true);
_premios = GetInstance <IPremios>();
_emissaoPremio = ObterContratoEmissaoPremio();
GetInstance <EmissaoPremioService>().Execute(_emissaoPremio).Wait();
}
public async Task <EventoPremio> Com(IParcelaEmitida message)
{
var evento = new EventoEmissaoPremio(message.Identificador, message.IdentificadorCorrelacao, message.IdentificadorNegocio, message.DataExecucaoEvento);
foreach (var parcela in message.Parcelas)
{
evento.AdicionarPremio(await _premios.CriarPremio(_mapear.ToPremio(parcela), evento));
}
return(evento);
}
public void DadoUmPremioComItemCertificadoApoliceInvalidoDeveSerGeradoUmErro()
{
_emissaoPremio = ParcelaEmitidaBuilder.UmBuilder()
.ComIdentificador(IdentificadoresPadrao.Identificador)
.ComDataExecucaoEvento(IdentificadoresPadrao.DataExecucaoEvento)
.Com(ParcelaBuilder.UmBuilder()
.Com(ParcelaIdBuilder.UmBuilder().ComIdentificadorExternoCobertura(string.Empty))
.Com(ValorBuilder.UmBuilder().Padrao())
).Build();
Assert.That(() => GetInstance <EventoPremioFactory>().Fabricar(_emissaoPremio), GeraErro("O ItemCerficadoApolice não foi informado"));
}
public void DadoUmaEmissaoPremioOMesmoDeveSerMapeado()
{
_emissaoPremio = ParcelaEmitidaBuilder.UmBuilder().Padrao().Build();
var premio = GetInstance <EventoPremioFactory>().Fabricar(_emissaoPremio).Premios.First();
Assert.That(IdentificadoresPadrao.Competencia, Is.EqualTo(premio.Competencia));
Assert.That(IdentificadoresPadrao.DataInicioVigencia, Is.EqualTo(premio.InicioVigencia));
Assert.That(IdentificadoresPadrao.DataFimVigencia, Is.EqualTo(premio.FimVigencia));
Assert.That(IdentificadoresPadrao.ValorContribuicao, Is.EqualTo(premio.ValorPremio));
Assert.That(IdentificadoresPadrao.ValorCarregamento, Is.EqualTo(premio.ValorCarregamento));
Assert.That(IdentificadoresPadrao.ValorBeneficio, Is.EqualTo(premio.ValorBeneficio));
Assert.That(IdentificadoresPadrao.ValorCapitalSegurado, Is.EqualTo(premio.ValorCapitalSegurado));
}
public void DadoUmPremioComNumeroParcelaInvalidoDeveSerGeradoUmErro()
{
_emissaoPremio = ParcelaEmitidaBuilder.UmBuilder()
.ComIdentificador(IdentificadoresPadrao.Identificador)
.ComDataExecucaoEvento(IdentificadoresPadrao.DataExecucaoEvento)
.Com(ParcelaBuilder.UmBuilder()
.Com(VigenciaBuilder.UmBuilder().Padrao())
.Com(ValorBuilder.UmBuilder().Padrao())
.Com(ParcelaIdBuilder.UmBuilder()
.ComNumeroParcela(int.MinValue)))
.Build();
Assert.That(() => GetInstance <EventoPremioFactory>().Fabricar(_emissaoPremio), GeraErro("O número da Parcela não foi informado."));
}
public void DadoUmPremioComDataCompetenciaMenorQueADataDeInicioDaVigenciaDeveSerGeradoUmErro()
{
_emissaoPremio = ParcelaEmitidaBuilder.UmBuilder()
.ComIdentificador(IdentificadoresPadrao.Identificador)
.ComDataExecucaoEvento(IdentificadoresPadrao.DataExecucaoEvento)
.Com(ParcelaBuilder.UmBuilder()
.Com(ParcelaIdBuilder.UmBuilder())
.Com(ValorBuilder.UmBuilder().Padrao())
.Com(VigenciaBuilder.UmBuilder()
.ComCompetencia(new DateTime(2017, 03, 01))
.ComDataInicio(new DateTime(2017, 06, 01))
.ComDataFim(new DateTime(2017, 12, 01))))
.Build();
Assert.That(() => GetInstance <EventoPremioFactory>().Fabricar(_emissaoPremio), GeraErro("A data de competência inválida, a data não pode estar fora do período de Vigência."));
}
public void DadoUmaEmissaoPremioDeveAdicionarListaProvisoes()
{
_emissaoPremio = ParcelaEmitidaBuilder.UmBuilder()
.ComIdentificador(IdentificadoresPadrao.Identificador)
.ComIdentificadorNegocio(IdentificadoresPadrao.IdentificadorNegocio)
.ComDataExecucaoEvento(IdentificadoresPadrao.DataExecucaoEvento)
.Com(ParcelaBuilder.UmBuilder().Padrao())
.Build();
MovimentoProvisaoBuilder[] provisoes = { MovimentoProvisaoBuilder.UmBuilder().Padrao(), MovimentoProvisaoBuilder.UmBuilder().Padrao() };
_evento = EventoParcelaEmitidaBuilder.UmEvento()
.Com(PremioBuilder.Um().Padrao()
.Com(provisoes)).Build();
_emissaoPremio.Parcelas.ForEach(p => p.MovimentoToProvisao(_evento));
var parcela = _emissaoPremio.Parcelas.First();
Assert.That(provisoes.Count(), Is.EqualTo(_evento.Premios.First().MovimentosProvisao.Count()));
Assert.That(provisoes.Count(), Is.EqualTo(parcela.Provisoes.Count()));
}
public EmissaoPremioContext(IParcelaEmitida request) : base(request)
{
}
public void ProcessarEmissao()
{
_emissaoPremio = ObterContratoEmissaoPremio();
GetInstance <EmissaoPremioService>().Execute(_emissaoPremio).Wait();
}
public static void Validar(this IParcelaEmitida premio)
{
premio.ValidarEvento();
premio.Parcelas.ForEach(p => p.Validar());
}
public void FixtureSetUp()
{
_premioEmitido = ParcelaEmitidaBuilder.UmBuilder().Padrao().Build();
}
public static void AdicionarProvisoes(this IParcelaEmitida premioEmitido, EventoEmissaoPremio eventoPremio)
{
premioEmitido.Parcelas.SafeForEach(p => MovimentoToProvisao(p, eventoPremio));
}
public void DadoUmPremioComDataExecucaoInvalidaDeveSerGeradoUmErro()
{
_emissaoPremio = ParcelaEmitidaBuilder.UmBuilder().ComDataExecucaoEvento(DateTime.MinValue).Build();
Assert.That(() => GetInstance <EventoPremioFactory>().Fabricar(_emissaoPremio), GeraErro("A Data de Execução não pode ser nula."));
}
public void DadoUmPremioComIdentificadorInvalidoDeveSerGeradoUmErro()
{
_emissaoPremio = ParcelaEmitidaBuilder.UmBuilder().ComIdentificador(default(Guid)).Build();
Assert.That(() => GetInstance <EventoPremioFactory>().Fabricar(_emissaoPremio), GeraErro("O Identificador não pode ser nulo."));
}
