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;
        }
Exemple #2
0
        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();
        }
Exemple #3
0
        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"));
        }
 private IParcelaEmitida ObterContratoEmissaoPremio()
 {
     return(ParcelaEmitidaBuilder.UmBuilder()
            .ComIdentificador(Guid.NewGuid())
            .ComIdentificadorNegocio(_proposta.IdentificadorNegocio)
            .ComDataExecucaoEvento(_proposta.DataExecucaoEvento)
            .Com(ParcelaBuilder.UmBuilder()
                 .Com(ParcelaIdBuilder.UmBuilder()
                      .ComIdentificadorExternoCobertura(cobertura.IdentificadorExterno)
                      .ComNumeroParcela(IdentificadoresPadrao.NumeroParcela))
                 .Com(ValorBuilder.UmBuilder().Padrao())
                 .Com(VigenciaBuilder.UmBuilder().Padrao()))
            .Build());
 }
Exemple #5
0
        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."));
        }
Exemple #6
0
        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));
        }
Exemple #7
0
        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."));
        }
Exemple #8
0
        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()));
        }
Exemple #9
0
 public void FixtureSetUp()
 {
     _premioEmitido = ParcelaEmitidaBuilder.UmBuilder().Padrao().Build();
 }
Exemple #10
0
        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."));
        }
Exemple #11
0
        public void DadoUmPremioComIdentificadorInvalidoDeveSerGeradoUmErro()
        {
            _emissaoPremio = ParcelaEmitidaBuilder.UmBuilder().ComIdentificador(default(Guid)).Build();

            Assert.That(() => GetInstance <EventoPremioFactory>().Fabricar(_emissaoPremio), GeraErro("O Identificador não pode ser nulo."));
        }