public void FixtureSetUp()
{
_apropriacaoPremio = ParcelaApropriadaBuilder.UmBuilder().Padrao()
.Com(ApropriacaoBuilder.UmBuilder()
.Com(PagamentoBuilder.UmBuilder().Padrao()))
.Build();
}
public void FixtureSetUp()
{
_parcelaApropriada = ParcelaApropriadaBuilder.UmBuilder().Padrao().Build();
var premioAnterior = PremioBuilder.Um().Padrao().ComTipoMovimento((short)TipoMovimentoEnum.Emissao).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(_parcelaApropriada).Result;
}
public static IEnumerable <PremioApropriado> ToEventoApropriacao(this IParcelaApropriada premioApropriado)
{
var evento = new EventoApropriacaoPremio(premioApropriado.Identificador, premioApropriado.IdentificadorCorrelacao, premioApropriado.IdentificadorNegocio, premioApropriado.DataExecucaoEvento);
premioApropriado.Parcelas.SafeForEach(premio => evento.AdicionarPremiosApropriados(premio.ToPremioApropriado()));
return(evento.Premios);
}
public static void ValidarApropriacao(this IParcelaApropriada evento)
{
evento.Validar();
Assertion.NotNull(evento.Parcelas, "Nenhum prêmio para Apropriar.").Validate();
evento.Parcelas.Select(p => p.ValidarPremioApropriado()).Aggregate(Assertion.Neutral(), (x, y) => x.and(y)).Validate();
}
public static void Validar(this IParcelaApropriada premio)
{
premio.ValidarEvento();
foreach (var parcela in premio.Parcelas)
{
parcela.Validar();
parcela.Pagamento.Validar(parcela.ParcelaId.IdentificadorExternoCobertura);
}
}
public async Task <EventoPremio> Com(IParcelaApropriada message)
{
var evento = new EventoApropriacaoPremio(message.Identificador, message.IdentificadorCorrelacao, message.IdentificadorNegocio, message.DataExecucaoEvento);
foreach (var parcela in message.Parcelas)
{
var premio = (await _premios.CriarPremio(_mapear.ToPremio(parcela), evento))
.ComPagamento(_mapear.ToPagamentoPremio(parcela.Pagamento));
evento.AdicionarPremio(premio);
}
return(evento);
}
public void DadoUmaApropriacaoPremioDeveMapearOPremio()
{
_apropriacaoPremio = ParcelaApropriadaBuilder.UmBuilder().Padrao().Build();
var premio = GetInstance <EventoPremioFactory>().Fabricar(_apropriacaoPremio).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));
}
public void SetUpFixture()
{
_apropriacao = ParcelaApropriadaBuilder.UmBuilder().Padrao().Build();
var lista = new List <PremioApropriado>
{
PremioApropriadoBuilder.Um().Padrao().Build()
};
_contexto = new ApropriacaoPremioContext(_apropriacao)
{
Premios = lista.AsEnumerable()
};
var pipeline = Pipe.New <ApropriacaoPremioContext>(cfg =>
{
cfg.AddFilter(() => MockingKernel.Get <ConversaoApropriacaoPremioFilter>());
});
pipeline.Send(_contexto);
}
public void ProcessarApropriacao()
{
_apropriacaoPremio = ObterContratoParcelaApropriada();
GetInstance <ApropriacaoPremioService>().Execute(_apropriacaoPremio).Wait();
}
public void DadoUmaApropriacaoSemPremioDeveGerarErro()
{
_apropriacaoPremio = ParcelaApropriadaBuilder.UmBuilder().ComIdentificador(IdentificadoresPadrao.Identificador).ComDataExecucaoEvento(DateTime.Now).Build();
Assert.That(() => _apropriacaoPremio.Validar(), GeraErro("Nenhum prêmio para Apropriar."));
}
public void DadoUmaApropriacaoComDataExcucaoInvalidaDeveGerarErro()
{
_apropriacaoPremio = ParcelaApropriadaBuilder.UmBuilder().Build();
Assert.That(() => _apropriacaoPremio.Validar(), GeraErro("A Data de Execução não pode ser nula."));
}
public void DadoUmaApropriacaoComIdentificadorInvalidaDeveGerarErro()
{
_apropriacaoPremio = ParcelaApropriadaBuilder.UmBuilder().Build();
Assert.That(() => _apropriacaoPremio.Validar(), GeraErro("O Identificador não pode ser nulo."));
}
public new void FixtureSetUp()
{
_apropriacaoPremio = ObterContratoParcelaApropriada();
GetInstance <ApropriacaoPremioService>().Execute(_apropriacaoPremio).Wait();
}
public ApropriacaoPremioContext(IParcelaApropriada request) : base(request)
{
}
