public void FixtureSetUp()
        {
            _parcelaDesapropriada = ParcelaDesapropriadaBuilder.UmBuilder().Padrao().Build();
            var premioAnterior = PremioBuilder.Um().Padrao().ComTipoMovimento((short)TipoMovimentoEnum.Apropriacao).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(_parcelaDesapropriada).Result;
        }
        public void DadoUmaDesapropriacaoSemPremioDeveGerarErro()
        {
            _desapropriacaoPremio = ParcelaDesapropriadaBuilder.UmBuilder()
                                    .ComIdentificador(IdentificadoresPadrao.Identificador)
                                    .ComDataExecucaoEvento(DateTime.Now).Build();

            Assert.That(() => _desapropriacaoPremio.Validar(), GeraErro("Nenhum prêmio para Desapropriar."));
        }
        public void DadoUmContratoDesapropriacaoPremioComIdentificadorInvalidoDeveGerarErro()
        {
            _desapropriacaoPremio = ParcelaDesapropriadaBuilder.UmBuilder()
                                    .ComDataExecucaoEvento(DateTime.Now)
                                    .Build();

            Assert.That(() => _desapropriacaoPremio.Validar(), GeraErro("O Identificador não pode ser nulo."));
        }
        public static IEnumerable <PremioDesapropriado> ToEventoDesapropriacao(this IParcelaDesapropriada contrato)
        {
            var evento = new EventoDesapropriacaoPremio(contrato.Identificador, contrato.IdentificadorCorrelacao,
                                                        contrato.IdentificadorNegocio, contrato.DataExecucaoEvento);

            contrato.Parcelas.SafeForEach(premio => evento.AdicionarPremio(premio.ToPremioDesapropriado()));

            return(evento.Premios);
        }
        public static void ValidarDesapropriacao(this IParcelaDesapropriada contrato)
        {
            contrato.Validar();

            Assertion.NotNull(contrato.Parcelas, "Nenhum prêmio para Desapropriar.").Validate();

            contrato.Parcelas.Select(p => p.ValidarPremioDesapropriado())
            .Aggregate(Assertion.Neutral(), (x, y) => x.and(y)).Validate();
        }
        public new async Task FixtureSetUp()
        {
            _desapropriacaoPremio = ObterParcelaDesapropriada();

            GetInstance <DesapropriacaoPremioService>().Execute(_desapropriacaoPremio).Wait();

            _premios = GetInstance <IPremios>();

            _apropriacao = _desapropriacaoPremio.Parcelas.First();

            _premioDto = await _premios.ObterPorItemCertificado <PagamentoPremio>(long.Parse(_apropriacao.ParcelaId.IdentificadorExternoCobertura), (short)TipoMovimentoEnum.Desapropriacao, 12);
        }
Exemplo n.º 7
0
        public async Task <EventoPremio> Com(IParcelaDesapropriada message)
        {
            var evento = new EventoDesapropriacaoPremio(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 DadoUmaDesapropriacaoPremioDeveMapearOPremio()
        {
            _desapropriacaoPremio = ParcelaDesapropriadaBuilder.UmBuilder().Padrao().Build();

            var premio = GetInstance <EventoPremioFactory>().Fabricar(_desapropriacaoPremio).Premios.First();

            Assert.That(premio.ItemCertificadoApoliceId, Is.EqualTo(IdentificadoresPadrao.ItemCertificadoApoliceId));
            Assert.That(premio.InicioVigencia, Is.EqualTo(IdentificadoresPadrao.DataInicioVigencia));
            Assert.That(premio.FimVigencia, Is.EqualTo(IdentificadoresPadrao.DataFimVigencia));
            Assert.That(premio.ValorBeneficio, Is.EqualTo(IdentificadoresPadrao.ValorBeneficio));
            Assert.That(premio.ValorPremio, Is.EqualTo(IdentificadoresPadrao.ValorContribuicao));
            Assert.That(premio.Numero, Is.EqualTo(IdentificadoresPadrao.NumeroParcela));
            Assert.That(premio.ValorCapitalSegurado, Is.EqualTo(IdentificadoresPadrao.ValorCapitalSegurado));
            Assert.That(premio.ValorCarregamento, Is.EqualTo(IdentificadoresPadrao.ValorCarregamento));
        }
        public void DadoUmContratoDesapropriacaoPremioComDataExecucaoInvalidaDeveGerarErro()
        {
            _desapropriacaoPremio = ParcelaDesapropriadaBuilder.UmBuilder().ComIdentificador(Guid.NewGuid()).Build();

            Assert.That(() => _desapropriacaoPremio.Validar(), GeraErro("A Data de Execução não pode ser nula."));
        }
Exemplo n.º 10
0
 public void FixtureSetUp()
 {
     _parcelaDesapropriada = ParcelaDesapropriadaBuilder.UmBuilder().Padrao().Build();
 }
Exemplo n.º 11
0
 public DesapropriacaoPremioContext(IParcelaDesapropriada request) : base(request)
 {
 }
Exemplo n.º 12
0
        public static void Validar(this IParcelaDesapropriada premio)
        {
            premio.ValidarEvento();

            premio.Parcelas.ForEach(p => p.Validar());
        }