コード例 #1
0
        public void CriarNotificacoesMudancaStatusProva_NaoCriarNotificacoesDemaisStatus_Zero()
        {
            var idProva       = 2;
            var idNotificacao = (int)Constants.Notificacoes.Recursos.StatusProvaFavoritos;
            var notificacao   = NotificacaoEntityTestData.GetNotificacaoSimulado();
            var mockNotif     = Substitute.For <INotificacaoData>();
            var mockExercicio = Substitute.For <IExercicioData>();

            mockNotif.Get(idNotificacao).Returns(new Notificacao {
                IdNotificacao = idNotificacao, Texto = string.Empty
            });

            var business = new NotificacaoRecursosBusiness(mockNotif, mockExercicio, null);

            var result = business.CriarNotificacoesMudancaStatusProva(idProva, ProvaRecurso.StatusProva.RecursosExpirados);

            Assert.AreEqual(0, result);

            result = business.CriarNotificacoesMudancaStatusProva(idProva, ProvaRecurso.StatusProva.Bloqueado);
            Assert.AreEqual(0, result);

            result = business.CriarNotificacoesMudancaStatusProva(idProva, ProvaRecurso.StatusProva.AguardandoInteração);
            Assert.AreEqual(0, result);

            result = business.CriarNotificacoesMudancaStatusProva(idProva, ProvaRecurso.StatusProva.SobDemanda);
            Assert.AreEqual(0, result);

            mockNotif.DidNotReceive().InserirNotificacoesPosEvento(Arg.Any <NotificacaoPosEventoDTO[]>());
            mockNotif.DidNotReceive().AtualizarNotificacoesPosEvento(Arg.Any <List <tblNotificacaoEvento> >());
        }
コード例 #2
0
        public void GetNotificacoesAluno_OrdenacaoNotificacoes_Decrescente()
        {
            var matricula     = 7;
            var notificacao   = NotificacaoEntityTestData.GetNotificacaoSimulado();
            var mockNotif     = Substitute.For <INotificacaoData>();
            var mockExercicio = Substitute.For <IExercicioData>();

            mockNotif.GetNotificacoesAlunoPosEvento(matricula, Aplicacoes.Recursos).Returns(new List <NotificacaoPosEventoDTO>
            {
                new NotificacaoPosEventoDTO
                {
                    IdNotificacao = 1,
                    Data          = DateTime.Now
                },
                new NotificacaoPosEventoDTO
                {
                    IdNotificacao = 2,
                    Data          = DateTime.Now.AddHours(1)
                }
            });

            var business = new NotificacaoRecursosBusiness(mockNotif, mockExercicio, null);
            var result   = business.GetNotificacoesAluno(matricula);

            Assert.AreEqual(2, result.ElementAt(0).IdNotificacao);
            Assert.AreEqual(1, result.ElementAt(1).IdNotificacao);
        }
コード例 #3
0
        public void NotificacaoPrimeiraAula_GetDevicesNotificacaoPrimeiraAula_DataParametrizada()
        {
            var notificacao = NotificacaoEntityTestData.GetNotificacaoPrimeiraAula();

            var parametros = new ParametrosPrimeiraAula
            {
                Data = new DateTime(2019, 01, 11)
            };


            var devices = new NotificacaoBusiness(new NotificacaoEntity(),
                                                  new AccessEntity(),
                                                  new AlunoEntity(),
                                                  new NotificacaoDuvidasAcademicasEntity(),
                                                  new MenuBusiness(new MenuEntity(), new PessoaEntity(), new BlackListEntity())
                                                  ).GetDevicesNotificacaoPrimeiraAula(notificacao, parametros);


            if (!devices.Any())
            {
                Assert.Inconclusive("Não há notificações a processar");
            }

            Assert.IsTrue(devices.All(x => x.Data.Date == parametros.Data.Date));
        }
コード例 #4
0
        public void NotificarMudancaRankingAcertos_TestaEnviaRankingLiberado_ChamaMetodoInclusao()
        {
            var idProva       = 2;
            var mockNotif     = Substitute.For <INotificacaoData>();
            var mockExercicio = Substitute.For <IExercicioData>();
            var mockQuestao   = Substitute.For <IQuestaoData>();
            var notificacao   = NotificacaoEntityTestData.GetNotificacaoSimulado();

            var business = new NotificacaoRecursosBusiness(mockNotif, mockExercicio, mockQuestao);

            mockExercicio.GetAlunosFavoritaramProva(idProva).Returns(new ProvaAlunosFavoritoDTO
            {
                MatriculasFavoritaram = new List <int> {
                    1, 2, 3
                },
                Prova = new ProvaConcursoDTO()
            });

            mockNotif.Get((int)Constants.Notificacoes.Recursos.RankingAcertosLiberado).Returns(notificacao);
            mockNotif.AtualizarNotificacoesPosEvento(Arg.Any <List <tblNotificacaoEvento> >()).Returns(3);
            var result = business.NotificarMudancaRankingAcertos(idProva, true);

            mockNotif.Received().AtualizarNotificacoesPosEvento(Arg.Any <List <tblNotificacaoEvento> >());
            mockNotif.Received().Get((int)Constants.Notificacoes.Recursos.RankingAcertosLiberado);

            Assert.IsTrue(result > 0);
        }
コード例 #5
0
        public void CriarNotificacoesMudancaStatusQuestao_NaoCriarNotificacoesDemaisStatus_Zero()
        {
            var idQuestao     = 2;
            var idNotificacao = (int)Constants.Notificacoes.Recursos.StatusQuestaoFavoritos;
            var notificacao   = NotificacaoEntityTestData.GetNotificacaoSimulado();
            var mockNotif     = Substitute.For <INotificacaoData>();
            var mockExercicio = Substitute.For <IExercicioData>();
            var mockQuestao   = Substitute.For <IQuestaoData>();

            mockNotif.Get(idNotificacao).Returns(new Notificacao {
                IdNotificacao = idNotificacao, Texto = string.Empty
            });

            var business = new NotificacaoRecursosBusiness(mockNotif, mockExercicio, mockQuestao);

            var result = business.CriarNotificacoesMudancaStatusQuestao(idQuestao, QuestaoRecurso.StatusQuestao.NaoExiste);

            Assert.AreEqual(0, result);

            result = business.CriarNotificacoesMudancaStatusQuestao(idQuestao, QuestaoRecurso.StatusQuestao.NaoSolicitado);
            Assert.AreEqual(0, result);

            result = business.CriarNotificacoesMudancaStatusQuestao(idQuestao, QuestaoRecurso.StatusQuestao.Invalido);
            Assert.AreEqual(0, result);

            mockNotif.DidNotReceive().InserirNotificacoesPosEvento(Arg.Any <NotificacaoPosEventoDTO[]>());
            mockNotif.DidNotReceive().AtualizarNotificacoesPosEvento(Arg.Any <List <tblNotificacaoEvento> >());
        }
コード例 #6
0
        public void StatusQuestaoNotificaAluno_TestaNotificaNaoCabeProvaRMais_True()
        {
            var mockNotif     = Substitute.For <INotificacaoData>();
            var mockExercicio = Substitute.For <IExercicioData>();
            var mockQuestao   = Substitute.For <IQuestaoData>();
            var notificacao   = NotificacaoEntityTestData.GetNotificacaoSimulado();

            var business = new NotificacaoRecursosBusiness(mockNotif, mockExercicio, mockQuestao);

            var result = business.StatusQuestaoNotificaAluno(QuestaoRecurso.StatusQuestao.NaoCabeRecurso, true);

            Assert.IsTrue(result);
        }
コード例 #7
0
        public void StatusQuestaoNotificaAluno_TestaNaoNotificaAnaliseProvaR1_False()
        {
            var mockNotif     = Substitute.For <INotificacaoData>();
            var mockExercicio = Substitute.For <IExercicioData>();
            var mockQuestao   = Substitute.For <IQuestaoData>();
            var notificacao   = NotificacaoEntityTestData.GetNotificacaoSimulado();

            var business = new NotificacaoRecursosBusiness(mockNotif, mockExercicio, mockQuestao);

            var result = business.StatusQuestaoNotificaAluno(QuestaoRecurso.StatusQuestao.EmAnalise, false);

            Assert.IsFalse(result);
        }
コード例 #8
0
        public void CriarNotificacoesAprovacaoAnaliseQuestao_NaoCriarNotificacoesReprovada_Zero()
        {
            var idQuestao     = 2;
            var notificacao   = NotificacaoEntityTestData.GetNotificacaoSimulado();
            var mockNotif     = Substitute.For <INotificacaoData>();
            var mockExercicio = Substitute.For <IExercicioData>();
            var mockQuestao   = Substitute.For <IQuestaoData>();

            var business = new NotificacaoRecursosBusiness(mockNotif, mockExercicio, mockQuestao);

            var result = business.CriarNotificacoesAprovacaoAnaliseQuestao(idQuestao, false);

            Assert.AreEqual(0, result);
        }
コード例 #9
0
        public void NotificarMudancaStatusQuestao_TestaNaoEnviaNaoCabeSeNecessitaAprovacao_Zero()
        {
            var idQuestao     = 2;
            var notificacao   = NotificacaoEntityTestData.GetNotificacaoSimulado();
            var mockNotif     = Substitute.For <INotificacaoData>();
            var mockExercicio = Substitute.For <IExercicioData>();
            var mockQuestao   = Substitute.For <IQuestaoData>();

            mockQuestao.IsQuestaoProvaRMais(idQuestao).Returns(false);

            var business = new NotificacaoRecursosBusiness(mockNotif, mockExercicio, mockQuestao);
            var result   = business.NotificarMudancaStatusQuestao(idQuestao, QuestaoRecurso.StatusQuestao.NaoCabeRecurso);

            Assert.AreEqual(0, result);
        }
コード例 #10
0
        public void NotificarQuestaoAlteradoBanca_TestaNaoEnviaStatusNaoMudou_NaoChamaMetodoInclusao()
        {
            var idQuestao     = 2;
            var mockNotif     = Substitute.For <INotificacaoData>();
            var mockExercicio = Substitute.For <IExercicioData>();
            var mockQuestao   = Substitute.For <IQuestaoData>();
            var notificacao   = NotificacaoEntityTestData.GetNotificacaoSimulado();

            var business = new NotificacaoRecursosBusiness(mockNotif, mockExercicio, mockQuestao);

            mockQuestao.ObterStatusRecursoBanca(idQuestao).Returns((int)QuestaoRecurso.StatusBancaAvaliadora.Sim);

            business.NotificarQuestaoAlteradoBanca(idQuestao, (int)QuestaoRecurso.StatusBancaAvaliadora.Sim);
            mockNotif.DidNotReceive().AtualizarNotificacoesPosEvento(Arg.Any <List <tblNotificacaoEvento> >());
        }
コード例 #11
0
        public void NotificacaoAvaliacao_MontaArrayInfoAdicional_ArrayConforme()
        {
            var temasAvaliacao = NotificacaoEntityTestData.GetTemasAvaliacaoUnicoAluno();

            var arrayInfo = new NotificacaoBusiness(new NotificacaoEntity(),
                                                    new AccessEntity(),
                                                    new AlunoEntity(),
                                                    new NotificacaoDuvidasAcademicasEntity(),
                                                    new MenuBusiness(new MenuEntity(), new PessoaEntity(), new BlackListEntity())).MontaArrayInfoAdicional(temasAvaliacao);


            Regex regex = new Regex(@"({.*?})");
            Match match = regex.Match(arrayInfo);

            Assert.IsTrue(match.Success);
        }
コード例 #12
0
        public void NotificacaoAvaliacao_SetNotificacoesAvaliacao_SeletivasMensagemTratada()
        {
            var parametros = new ParametrosAvaliacaoAula();

            var notificacao = NotificacaoEntityTestData.GetNotificacaoAvaliacao();
            var devices     = NotificacaoEntityTestData.GetDeviceNotificacoes();
            var hoje        = DateTime.Now.ToString("dd/MM");

            var seletivas = new NotificacaoBusiness(new NotificacaoEntity(),
                                                    new AccessEntity(),
                                                    new AlunoEntity(),
                                                    new NotificacaoDuvidasAcademicasEntity(),
                                                    new MenuBusiness(new MenuEntity(), new PessoaEntity(), new BlackListEntity())
                                                    ).SetNotificacoesAvaliacao(devices, notificacao, parametros);


            Assert.IsTrue(seletivas.All(x => !x.Mensagem.Contains("#DATA")));
            Assert.IsTrue(seletivas.All(x => x.Mensagem.Contains(hoje)));
        }
コード例 #13
0
        public void CriarNotificacoesAprovacaoAnaliseQuestao_NaoCriarNotificacoesAlteradoBanca_Zero()
        {
            var idQuestao     = 2;
            var notificacao   = NotificacaoEntityTestData.GetNotificacaoSimulado();
            var mockNotif     = Substitute.For <INotificacaoData>();
            var mockExercicio = Substitute.For <IExercicioData>();
            var mockQuestao   = Substitute.For <IQuestaoData>();

            mockQuestao.GetQuestaoConcursoById(idQuestao).Returns(new tblConcursoQuestoes
            {
                ID_CONCURSO_RECURSO_STATUS = (int)QuestaoRecurso.StatusQuestao.AlteradaPelaBanca
            });

            var business = new NotificacaoRecursosBusiness(mockNotif, mockExercicio, mockQuestao);

            var result = business.CriarNotificacoesAprovacaoAnaliseQuestao(idQuestao, true);

            Assert.AreEqual(0, result);
        }
コード例 #14
0
        public void NotificacaoPrimeiraAula_GetDevicesNotificacaoPrimeiraAula_DataSemParametro()
        {
            var notificacao = NotificacaoEntityTestData.GetNotificacaoPrimeiraAula();
            var parametros  = new ParametrosPrimeiraAula();

            var hoje = DateTime.Today;

            var devices = new NotificacaoBusiness(new NotificacaoEntity(),
                                                  new AccessEntity(),
                                                  new AlunoEntity(),
                                                  new NotificacaoDuvidasAcademicasEntity(),
                                                  new MenuBusiness(new MenuEntity(), new PessoaEntity(), new BlackListEntity())
                                                  ).GetDevicesNotificacaoPrimeiraAula(notificacao, parametros);


            if (!devices.Any())
            {
                Assert.Inconclusive("Não há notificações a processar");
            }

            Assert.IsTrue(devices.All(x => x.Data.Date == hoje.AddDays(Utilidades.NotificacaoPrimeiraAulaDiasAntecedenciaPadrao)));
        }
コード例 #15
0
        public void ConfiguraNotificacao_NotificacaoSimulado_NotificacoesSeparadasPeloLimiteDevices()
        {
            var parametros      = new NotificacaoPushRequest();
            var notificacao     = NotificacaoEntityTestData.GetNotificacaoSimulado();
            var devicesDataTest = NotificacaoEntityTestData.GetListDevicesNotificacao(5000);


            var notificacaoDataMock = Substitute.For <INotificacaoData>();

            notificacaoDataMock.GetDevicesNotificacaoFila(notificacao.IdNotificacao).Returns(devicesDataTest);


            var seletivas = new NotificacaoBusiness(notificacaoDataMock,
                                                    new AccessEntity(),
                                                    new AlunoEntity(),
                                                    new NotificacaoDuvidasAcademicasEntity(),
                                                    new MenuBusiness(new MenuEntity(), new PessoaEntity(), new BlackListEntity())
                                                    ).ConfiguraNotificacao(notificacao, parametros);


            Assert.IsTrue(seletivas.Count == 3);
        }
コード例 #16
0
        public void ConfiguraNotificacao_NotificacaoSimulado_NotificacoesComMesmaMensagem()
        {
            var parametros      = new NotificacaoPushRequest();
            var notificacao     = NotificacaoEntityTestData.GetNotificacaoSimulado();
            var devicesDataTest = NotificacaoEntityTestData.GetListDevicesNotificacao(5000);

            var notificacaoDataMock = Substitute.For <INotificacaoData>();

            notificacaoDataMock.GetDevicesNotificacaoFila(notificacao.IdNotificacao).Returns(devicesDataTest);


            var seletivas = new NotificacaoBusiness(notificacaoDataMock,
                                                    new AccessEntity(),
                                                    new AlunoEntity(),
                                                    new NotificacaoDuvidasAcademicasEntity(),
                                                    new MenuBusiness(new MenuEntity(), new PessoaEntity(), new BlackListEntity())
                                                    ).ConfiguraNotificacao(notificacao, parametros);


            Assert.IsTrue(seletivas.All(x => x.Mensagem == notificacao.Texto));
            Assert.IsTrue(seletivas.All(x => x.Titulo == notificacao.Titulo));
        }
コード例 #17
0
        public void CriarNotificacoesMudancaStatusQuestao_CriarNotificacaoAnaliseProvaRmais_LinhasAfetadas()
        {
            var idQuestaoRMais = 3;
            var idNotificacao  = (int)Constants.Notificacoes.Recursos.StatusQuestaoFavoritos;
            var notificacao    = NotificacaoEntityTestData.GetNotificacaoSimulado();
            var mockNotif      = Substitute.For <INotificacaoData>();
            var mockExercicio  = Substitute.For <IExercicioData>();
            var mockQuestao    = Substitute.For <IQuestaoData>();


            mockNotif.Get(idNotificacao).Returns(new Notificacao
            {
                IdNotificacao = idNotificacao, Texto = string.Empty,
                Titulo        = string.Empty
            });
            mockQuestao.IsQuestaoProvaRMais(idQuestaoRMais).Returns(true);
            mockQuestao.GetQuestaoConcursoById(idQuestaoRMais).Returns(new tblConcursoQuestoes());

            mockNotif.AtualizarNotificacoesPosEvento(Arg.Any <List <tblNotificacaoEvento> >()).Returns(3);
            mockNotif.InserirNotificacoesPosEvento(null);
            mockExercicio.GetAlunosFavoritaramProva(0).Returns(new ProvaAlunosFavoritoDTO
            {
                Prova = new ProvaConcursoDTO {
                    Nome = string.Empty
                },
                MatriculasFavoritaram = new List <int> {
                    1, 2, 3
                }
            });

            var business = new NotificacaoRecursosBusiness(mockNotif, mockExercicio, mockQuestao);

            var resultRMais = business.CriarNotificacoesMudancaStatusQuestao(idQuestaoRMais, QuestaoRecurso.StatusQuestao.EmAnalise);

            Assert.IsTrue(resultRMais > 0);

            mockNotif.Received().InserirNotificacoesPosEvento(Arg.Any <NotificacaoPosEventoDTO[]>());
            mockNotif.Received().AtualizarNotificacoesPosEvento(Arg.Any <List <tblNotificacaoEvento> >());
        }
コード例 #18
0
        public void GetInfoAdicionalSimuladoSerializado_NotificacaoSimulado_InfoAdicionalSerializado()
        {
            var notificacao     = NotificacaoEntityTestData.GetNotificacaoSimulado();
            var devicesDataTest = NotificacaoEntityTestData.GetListDevicesNotificacao(5000);

            var notificacaoDataMock = Substitute.For <INotificacaoData>();

            notificacaoDataMock.GetDevicesNotificacaoFila(notificacao.IdNotificacao).Returns(devicesDataTest);

            var infoAdicional = new NotificacaoBusiness(notificacaoDataMock,
                                                        new AccessEntity(),
                                                        new AlunoEntity(),
                                                        new NotificacaoDuvidasAcademicasEntity(),
                                                        new MenuBusiness(new MenuEntity(), new PessoaEntity(), new BlackListEntity())
                                                        ).GetInfoAdicionalSimuladoSerializado(notificacao);


            Assert.IsFalse(String.IsNullOrEmpty(infoAdicional));

            var obj = JsonConvert.DeserializeObject <NotificacaoInfoAdicional>(infoAdicional);

            Assert.AreNotEqual(obj.InfoAdicionalSimulado.TipoSimuladoId, default(int));
            Assert.AreNotEqual(obj.InfoAdicionalSimulado.SimuladoId, default(int));
        }
コード例 #19
0
        public void NotificacaoAvaliacao_SetNotificacoesAvaliacao_SeletivasMensagemTratadaDiaParametizado()
        {
            var notificacao = NotificacaoEntityTestData.GetNotificacaoAvaliacao();
            var devices     = NotificacaoEntityTestData.GetDeviceNotificacoes();

            var parametros = new ParametrosAvaliacaoAula();


            parametros.Data = new DateTime(2019, 01, 02);


            var data        = new DateTime(2019, 01, 02).ToString("yyyy-MM-dd");
            var dataTratada = new DateTime(2019, 01, 02).ToString("dd/MM/yyyy");

            var seletivas = new NotificacaoBusiness(new NotificacaoEntity(),
                                                    new AccessEntity(),
                                                    new AlunoEntity(),
                                                    new NotificacaoDuvidasAcademicasEntity(),
                                                    new MenuBusiness(new MenuEntity(), new PessoaEntity(), new BlackListEntity())).SetNotificacoesAvaliacao(devices, notificacao, parametros);


            Assert.IsTrue(seletivas.All(x => !x.Mensagem.Contains("#DATA")));
            Assert.IsTrue(seletivas.All(x => x.Mensagem.Contains(dataTratada)));
        }