Beispiel #1
0
        public ActionResult Index(Guid?id, string nomeCronograma = null)
        {
            if (id.HasValue)
            {
                return(RetornarActionResult(CronogramaBo.ConsultarCronogramaPorOidDto(id.Value), JsonRequestBehavior.AllowGet));
            }

            if (!string.IsNullOrWhiteSpace(nomeCronograma))
            {
                using (WexDb contexto = ContextFactoryManager.CriarWexDb())
                {
                    return(RetornarActionResult(CronogramaBo.ConsultarCronogramaPorNomeDto(contexto, nomeCronograma), JsonRequestBehavior.AllowGet));
                }
            }
            return(RetornarActionResult(CronogramaBo.ConsultarCronogramasDto(), JsonRequestBehavior.AllowGet));
        }
Beispiel #2
0
        public void DeveRetornarOSomatorioDeHorasPlanejadasDoCronogramaQuandoHouverTarefasTest()
        {
            //TODO: MIGRAR TESTE PARA TarefaHistoricoEstimativaDao

            Cronograma cronograma = CronogramaBo.CriarCronogramaPadrao();

            CronogramaTarefaBo.CriarCronogramaTarefa(cronograma.Oid, "Tarefa 01", situacoesPlanejamento.FirstOrDefault(o => o.CsTipo == CsTipoPlanejamento.Planejamento), DateTime.MinValue, "", colaboradorPadrao.Usuario.UserName, out tarefasImpactadas, ref dataAcao, "Criar método", 3);
            CronogramaTarefaBo.CriarCronogramaTarefa(cronograma.Oid, "Tarefa 02", situacoesPlanejamento.FirstOrDefault(o => o.CsTipo == CsTipoPlanejamento.Planejamento), DateTime.MinValue, "", colaboradorPadrao.Usuario.UserName, out tarefasImpactadas, ref dataAcao, "Criar método", 3);
            CronogramaTarefaBo.CriarCronogramaTarefa(cronograma.Oid, "Tarefa 03", situacoesPlanejamento.FirstOrDefault(o => o.CsTipo == CsTipoPlanejamento.Planejamento), DateTime.MinValue, "", colaboradorPadrao.Usuario.UserName, out tarefasImpactadas, ref dataAcao, "Criar método", 3);
            CronogramaTarefaBo.CriarCronogramaTarefa(cronograma.Oid, "Tarefa 04", situacoesPlanejamento.FirstOrDefault(o => o.CsTipo == CsTipoPlanejamento.Planejamento), DateTime.MinValue, "", colaboradorPadrao.Usuario.UserName, out tarefasImpactadas, ref dataAcao, "Criar método", 3);
            CronogramaTarefaBo.CriarCronogramaTarefa(cronograma.Oid, "Tarefa 05", situacoesPlanejamento.FirstOrDefault(o => o.CsTipo == CsTipoPlanejamento.Planejamento), DateTime.MinValue, "", colaboradorPadrao.Usuario.UserName, out tarefasImpactadas, ref dataAcao, "Criar método", 3);

            double horasPlanejadas = TarefaHistoricoEstimativaDao.ConsultarTotalHorasPlanejadasCronograma(cronograma.Oid);

            Assert.AreEqual(15, horasPlanejadas.ToTimeSpan().Hours, "Deve ter 0 horas planejadas, pois não existem tarefas cadastradas.");
        }
        public void CriarTarefaQuandoTarefasForemImpactadasTest()
        {
            SituacaoPlanejamento situacaoPlanejamento = CronogramaFactoryEntity.CriarSituacaoPlanejamento(contexto, "S1", CsTipoSituacaoPlanejamento.Ativo, CsTipoPlanejamento.Execução, CsPadraoSistema.Sim, true);

            Cronograma cronograma1 = CronogramaFactoryEntity.CriarCronograma(contexto, "Cronograma 01", situacaoPlanejamento, new DateTime(), new DateTime(), true);

            Cronograma cronograma2 = CronogramaFactoryEntity.CriarCronograma(contexto, "Cronograma 02", situacaoPlanejamento, new DateTime(), new DateTime(), true);

            Colaborador colaborador1 = ColaboradorFactoryEntity.CriarColaborador(contexto, "anderson.lins", true);

            string responsaveis = colaborador1.NomeCompleto;

            //iníco tarefa
            DateTime dtInicio = new DateTime();

            List <CronogramaTarefa> tarefasImpactadas1;
            List <CronogramaTarefa> tarefasImpactadas2;
            DateTime dataHoraAcao = new DateTime();

            //cria tarefas cronograma1
            CronogramaBo.CriarTarefa(cronograma1.Oid, "Tarefa 01", situacaoPlanejamento.Oid.ToString(), dtInicio, colaborador1.Usuario.UserName, "Criar método", responsaveis, out tarefasImpactadas1, ref dataHoraAcao, 3, 0);

            List <CronogramaTarefa> lstCronoTarefa1 = contexto.CronogramaTarefa.Where(o => o.OidCronograma == cronograma1.Oid).ToList();

            CronogramaBo.CriarTarefa(cronograma1.Oid, "Tarefa 02", situacaoPlanejamento.Oid.ToString(), dtInicio, colaborador1.Usuario.UserName, "Criar método", responsaveis, out tarefasImpactadas1, ref dataHoraAcao, 3, lstCronoTarefa1[0].NbID);

            lstCronoTarefa1 = contexto.CronogramaTarefa.Where(o => o.OidCronograma == cronograma1.Oid).ToList();

            CronogramaBo.CriarTarefa(cronograma1.Oid, "Tarefa 03", situacaoPlanejamento.Oid.ToString(), dtInicio, colaborador1.Usuario.UserName, "Criar método", responsaveis, out tarefasImpactadas1, ref dataHoraAcao, 3, lstCronoTarefa1[0].NbID);

            lstCronoTarefa1 = contexto.CronogramaTarefa.Where(o => o.OidCronograma == cronograma1.Oid).ToList();

            CronogramaBo.CriarTarefa(cronograma2.Oid, "Tarefa 01", situacaoPlanejamento.Oid.ToString(), dtInicio, colaborador1.Usuario.UserName, "Criar método", responsaveis, out tarefasImpactadas2, ref dataHoraAcao, 3, 0);

            List <CronogramaTarefa> lstCronoTarefa2 = contexto.CronogramaTarefa.Where(o => o.OidCronograma == cronograma2.Oid).ToList();

            CronogramaBo.CriarTarefa(cronograma2.Oid, "Tarefa 02", situacaoPlanejamento.Oid.ToString(), dtInicio, colaborador1.Usuario.UserName, "Criar método", responsaveis, out tarefasImpactadas2, ref dataHoraAcao, 3, lstCronoTarefa2[0].NbID);

            lstCronoTarefa2 = contexto.CronogramaTarefa.Where(o => o.OidCronograma == cronograma2.Oid).ToList();

            Assert.IsNotNull(lstCronoTarefa1);
            Assert.AreEqual(3, lstCronoTarefa1.Count);
            Assert.AreEqual(2, tarefasImpactadas1.Count);

            Assert.IsNotNull(lstCronoTarefa2);
            Assert.AreEqual(2, lstCronoTarefa2.Count);
        }
Beispiel #4
0
        public ActionResult ExcluirCronograma(Guid?id)
        {
            bool respostaExclusao = false;

            using (WexDb contexto = ContextFactoryManager.CriarWexDb())
            {
                if (id.HasValue)
                {
                    respostaExclusao = CronogramaBo.ExcluirCronograma(contexto, id.Value);
                }
                else
                {
                    return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
                }
            }
            return(Json(respostaExclusao));
        }
        public void CriarCronogramaQuandoNaoHouverNomePadraoIgualNoBancoTest()
        {
            List <Cronograma> cronogramas = contexto.Cronograma.ToList();

            string TxDescricaoCronograma1 = "Wex Cronograma " + String.Format("{00:00}", (cronogramas.Count + 1));

            Cronograma cronogramaPadrao1 = CronogramaBo.CriarCronogramaPadrao();

            cronogramas = contexto.Cronograma.ToList();

            string TxDescricaoCronograma2 = "Wex Cronograma " + String.Format("{00:00}", (cronogramas.Count + 1));

            Cronograma cronogramaPadrao2 = CronogramaBo.CriarCronogramaPadrao(contexto);

            Assert.AreEqual(TxDescricaoCronograma1, cronogramaPadrao1.TxDescricao);
            Assert.AreEqual(TxDescricaoCronograma2, cronogramaPadrao2.TxDescricao);
        }
        public void ExcluirCronogramaQuandoCronogramaNaoPossuirTarefasEPossuirUltimaSelecaoTest()
        {
            SituacaoPlanejamento situacaoPlanejamento = CronogramaFactoryEntity.CriarSituacaoPlanejamento(contexto, "S1", CsTipoSituacaoPlanejamento.Ativo, CsTipoPlanejamento.Execução, CsPadraoSistema.Sim, true);

            Cronograma cronograma1 = CronogramaFactoryEntity.CriarCronograma(contexto, "Cronograma 01", situacaoPlanejamento, new DateTime(), new DateTime(), true);

            User usuario = CronogramaFactoryEntity.CriarUsuario(contexto, "anderson.lins", "Anderson", "Lins", "*****@*****.**", true);

            CronogramaUltimaSelecao ultimaSelecao = new CronogramaUltimaSelecao();

            ultimaSelecao.DataAcesso          = DateTime.Now;
            ultimaSelecao.Usuario             = usuario;
            ultimaSelecao.OidUltimoCronograma = cronograma1.Oid;
            ultimaSelecao.Cronograma          = cronograma1;

            bool cronogramaExcluido = CronogramaBo.ExcluirCronograma(contexto, cronograma1.Oid);

            Assert.IsTrue(cronogramaExcluido, "Deveria ser verdadeiro, pois o cronograma não possui tarefas associadas a ele.");
        }
        public void Inicializar()
        {
            SituacoesPlanejamento = new List <SituacaoPlanejamento>
            {
                CronogramaFactoryEntity.CriarSituacaoPlanejamento(contexto, "Não Iniciado",
                                                                  CsTipoSituacaoPlanejamento.Ativo, CsTipoPlanejamento.Planejamento, CsPadraoSistema.Sim),
                CronogramaFactoryEntity.CriarSituacaoPlanejamento(contexto, "Em Andamento"),
                CronogramaFactoryEntity.CriarSituacaoPlanejamento(contexto, "Cancelado",
                                                                  CsTipoSituacaoPlanejamento.Ativo, CsTipoPlanejamento.Cancelamento),
                CronogramaFactoryEntity.CriarSituacaoPlanejamento(contexto, "Impedimento",
                                                                  CsTipoSituacaoPlanejamento.Ativo, CsTipoPlanejamento.Impedimento),
                CronogramaFactoryEntity.CriarSituacaoPlanejamento(contexto, "Pronto", CsTipoSituacaoPlanejamento.Ativo,
                                                                  CsTipoPlanejamento.Encerramento)
            };
            Cronograma         = CronogramaBo.CriarCronogramaPadrao();
            _tarefasImpactadas = new List <CronogramaTarefa>();
            _dataAcao          = new DateTime();

            CriarTarefasNoCronograma();
        }
        public void ExcluirCronogramaQuandoCronogramaPossuirTarefasEUltimaSelecaoParaUmUsuarioTest()
        {
            SituacaoPlanejamento situacaoPlanejamento = CronogramaFactoryEntity.CriarSituacaoPlanejamento(contexto, "S1", CsTipoSituacaoPlanejamento.Ativo, CsTipoPlanejamento.Execução, CsPadraoSistema.Sim, true);

            Cronograma cronograma1 = CronogramaFactoryEntity.CriarCronograma(contexto, "Cronograma 01", situacaoPlanejamento, new DateTime(), new DateTime(), true);

            Colaborador colaborador = ColaboradorFactoryEntity.CriarColaborador(contexto, "anderson.lins", new DateTime(), "*****@*****.**", "Anderson", "", "Lins", "anderson.lins", null, true);

            CronogramaTarefa cronogramaTarefa = CronogramaFactoryEntity.CriarTarefa(contexto, 1, "Tarefa 01", "", situacaoPlanejamento, 0, new TimeSpan(), colaborador, cronograma1, null, true);

            CronogramaUltimaSelecao ultimaSelecao = new CronogramaUltimaSelecao();

            ultimaSelecao.DataAcesso          = DateTime.Now;
            ultimaSelecao.Usuario             = colaborador.Usuario;
            ultimaSelecao.OidUltimoCronograma = cronograma1.Oid;
            ultimaSelecao.Cronograma          = cronograma1;

            bool cronogramaExcluido = CronogramaBo.ExcluirCronograma(contexto, cronograma1.Oid);

            Assert.IsTrue(cronogramaExcluido, "Deveria ser true, pois o cronograma exclui quaisquer tarefas associadas a ele.");
        }
Beispiel #9
0
        public void ConsultarCronogramaColaboradorConfigTest()
        {
            Cronograma cronograma = CronogramaBo.CriarCronogramaPadrao(contexto);

            string[]                    logins            = new string[] { "gabriel.matos", "anderson.lins", "adriava.silva", "amanda.silva", "ana.marques" };
            List <Colaborador>          colaboradores     = new List <Colaborador>();
            Dictionary <string, string> dicionarioConfigs = new Dictionary <string, string>();
            string cor = null;

            for (int i = 0; i < logins.Length; i++)
            {
                colaboradores.Add(ColaboradorFactoryEntity.CriarColaborador(contexto, logins[i], true));
                cor = CronogramaColaboradorConfigBo.EscolherCorColaborador(logins[i], cronograma.Oid);
                dicionarioConfigs.Add(logins[i], cor);
            }

            List <CronogramaColaboradorConfig> configs = CronogramaColaboradorConfigDao.ConsultarCronogramaColaboradorConfig(logins.ToList(), cronograma.Oid);
            Dictionary <string, string>        resultadoListagemConfigs = configs.ToDictionary(o => o.Colaborador.Usuario.UserName, o => o.Cor.ToString());

            CollectionAssert.AreEquivalent(dicionarioConfigs, resultadoListagemConfigs);
        }
        public void EditarTarefaQuandoSalvarLinhaBaseTarefaTest()
        {
            //cria situação planejamento
            SituacaoPlanejamento situacaoPlanejamento = CronogramaFactoryEntity.CriarSituacaoPlanejamento(contexto, "S1",
                                                                                                          CsTipoSituacaoPlanejamento.Ativo, CsTipoPlanejamento.Execução,
                                                                                                          CsPadraoSistema.Sim, true);

            Cronograma cronogramaPadrao1 = CronogramaBo.CriarCronogramaPadrao(contexto);

            Colaborador colaborador1 = ColaboradorFactoryEntity.CriarColaborador(contexto, "anderson.lins", true);

            string responsaveis = colaborador1.NomeCompleto;

            //iníco tarefa
            DateTime dataInicio = DateTime.Now;

            List <CronogramaTarefa> tarefasImpactadas;
            DateTime         dataHoraAcao = new DateTime();
            CronogramaTarefa novaTarefa   = CronogramaTarefaBo.CriarCronogramaTarefa(cronogramaPadrao1.Oid, (string)"Tarefa 01", situacaoPlanejamento, dataInicio, responsaveis, colaborador1.Usuario.UserName, out tarefasImpactadas, ref dataHoraAcao, (string)"Criar método", 3, 0);

            //busca tarefa criada
            CronogramaTarefa tarefaCriada = CronogramaTarefaDao.ConsultarCronogramaTarefaPorOid(novaTarefa.Oid, o => o.Tarefa.SituacaoPlanejamento, o => o.Cronograma, o => o.Tarefa.AtualizadoPor.Usuario.Person, o => o.Tarefa);

            bool salvarLinhaBaseTarefa = true;

            TimeSpan estimativaRestante = TarefaDao.ConsultarTarefaPorOid((Guid)tarefaCriada.OidTarefa).EstimativaRestanteHora;

            string responsaveisTarefaEdicao = colaborador1.NomeCompleto;

            TarefaBo.EditarTarefa(tarefaCriada.Oid.ToString(), tarefaCriada.Tarefa.TxDescricao, tarefaCriada.Tarefa.SituacaoPlanejamento.Oid.ToString(), colaborador1.Usuario.UserName,
                                  tarefaCriada.Tarefa.TxObservacao, responsaveisTarefaEdicao, tarefaCriada.Tarefa.NbEstimativaInicial, estimativaRestante, new TimeSpan(0), salvarLinhaBaseTarefa, dataInicio);

            //busca tarefa criada
            CronogramaTarefa tarefaAlterada = CronogramaTarefaDao.ConsultarCronogramaTarefaPorOid(tarefaCriada.Oid, o => o.Tarefa.SituacaoPlanejamento, o => o.Cronograma, o => o.Tarefa.AtualizadoPor.Usuario.Person, o => o.Tarefa.LogsAlteracao, o => o.Tarefa.TarefaHistoricoTrabalhos, o => o.Tarefa.TarefaResponsaveis);

            Assert.AreEqual(salvarLinhaBaseTarefa, tarefaAlterada.Tarefa.CsLinhaBaseSalva, "Deveria ter salvo a linha de base");
            Assert.AreEqual(estimativaRestante, tarefaAlterada.Tarefa.NbEstimativaRestante.ToTimeSpan(), "Deveria ter mudado a estimativa restando, pois salvou a linha de base");
        }
        public void DeveSalvarOsNovosDadosDoCronogramaQuandoADataFinalForAlterada()
        {
            var cronograma = CronogramaBo.CriarCronogramaPadrao(contexto);

            var novaData = DateTime.Now.Date.AddDays(1);

            var dto = new CronogramaDto
            {
                Oid      = cronograma.Oid,
                DtInicio = cronograma.DtInicio,
                DtFinal  = novaData,
                OidSituacaoPlanejamento = cronograma.OidSituacaoPlanejamento,
                TxDescricao             = cronograma.TxDescricao
            };

            Assert.AreNotEqual(novaData, cronograma.DtFinal, "As datas devem ser inicialmente diferentes");
            Assert.IsTrue(CronogramaBo.EditarCronograma(dto), "Deveria ter salvo a edição do cronograma");

            contexto.Entry(cronograma).Reload();
            Assert.AreEqual(dto.TxDescricao, cronograma.TxDescricao, "Deveria ter salvo o nome do cronograma");
            Assert.AreEqual(dto.DtInicio, cronograma.DtInicio, "Deveria ter salvo a data de inicio do cronograma");
            Assert.AreEqual(dto.DtFinal, cronograma.DtFinal, "Deveria ter salvo a data de termino do cronograma");
        }
Beispiel #12
0
 public ActionResult NovoCronograma()
 {
     return(Json(CronogramaBo.DtoFactory(CronogramaBo.CriarCronogramaPadrao())));
 }
Beispiel #13
0
 public ActionResult EditarCronograma(CronogramaDto cronograma)
 {
     return(Json(CronogramaBo.EditarCronograma(cronograma)));
 }
        public void EditarTarefaQuandoOutroUsuarioAlterarTarefaTest()
        {
            //cria situação planejamento
            SituacaoPlanejamento situacaoPlanejamento = CronogramaFactoryEntity.CriarSituacaoPlanejamento(contexto, "S1",
                                                                                                          CsTipoSituacaoPlanejamento.Ativo, CsTipoPlanejamento.Execução,
                                                                                                          CsPadraoSistema.Sim, true);

            Cronograma cronogramaPadrao1 = CronogramaBo.CriarCronogramaPadrao(contexto);


            Colaborador colaborador1 = ColaboradorFactoryEntity.CriarColaborador(contexto, "anderson.lins", true);

            string responsaveis = colaborador1.NomeCompleto;

            //iníco tarefa
            DateTime dataInicio   = DateTime.Now;
            DateTime dataHoraAcao = new DateTime();
            List <CronogramaTarefa> tarefasImpactadas;

            CronogramaTarefa novaTarefa = CronogramaTarefaBo.CriarCronogramaTarefa(cronogramaPadrao1.Oid, (string)"Tarefa 01", situacaoPlanejamento, dataInicio, responsaveis, colaborador1.Usuario.UserName, out tarefasImpactadas, ref dataHoraAcao, (string)"Criar método", 3, 0);

            //busca tarefa criada
            CronogramaTarefa tarefaCriada = contexto.CronogramaTarefa.FirstOrDefault(o => o.Oid == novaTarefa.Oid);

            Colaborador colaborador2 = ColaboradorFactoryEntity.CriarColaborador(contexto, "pedro.lins", true);

            Colaborador colaborador3 = ColaboradorFactoryEntity.CriarColaborador(contexto, "joao.lins", true);

            List <Colaborador> responsaveisAlterados = new List <Colaborador>();

            responsaveisAlterados.Add(colaborador2);
            responsaveisAlterados.Add(colaborador3);

            //cria situação planejamento alterada
            SituacaoPlanejamento situacaoPlanejamento2 = CronogramaFactoryEntity.CriarSituacaoPlanejamento(contexto, "S2",
                                                                                                           CsTipoSituacaoPlanejamento.Ativo, CsTipoPlanejamento.Cancelamento,
                                                                                                           CsPadraoSistema.Sim, true);

            Colaborador colaborador4 = ColaboradorFactoryEntity.CriarColaborador(contexto, "gabriel.matos", true);

            string   txDescricaoAlterada           = "Tarefa 01 alterada";
            DateTime dataInicioAlterada            = new DateTime(2013, 12, 10);
            string   txObservacaoAlterada          = "Criar método alterado";
            Int16    EstimativaInicialHoraAlterada = 4;

            string responsaveisAlterado = colaborador1.NomeCompleto;

            TarefaBo.EditarTarefa(tarefaCriada.Oid.ToString(), txDescricaoAlterada, situacaoPlanejamento2.Oid.ToString(), colaborador2.Usuario.UserName,
                                  txObservacaoAlterada, responsaveisAlterado, EstimativaInicialHoraAlterada, new TimeSpan(0), new TimeSpan(0), false, DateTime.Now);

            //busca tarefa criada
            CronogramaTarefa tarefaAlterada = CronogramaTarefaDao.ConsultarCronogramaTarefaPorOid(tarefaCriada.Oid, o => o.Tarefa.SituacaoPlanejamento);

            DateUtil.CurrentDateTime = (DateTime)tarefaAlterada.Tarefa.DtAtualizadoEm;

            Assert.AreEqual(DateUtil.CurrentDateTime, tarefaAlterada.Tarefa.DtAtualizadoEm, "As datas devem ser iguais.");
            Assert.AreEqual(txDescricaoAlterada, tarefaAlterada.Tarefa.TxDescricao, "Devem ser as mesmas, pois a descrição foi alterada.");
            Assert.AreEqual(txObservacaoAlterada, tarefaAlterada.Tarefa.TxObservacao, "Devem ser as mesmas, pois a data foi alterada.");
            Assert.AreEqual(EstimativaInicialHoraAlterada, tarefaAlterada.Tarefa.NbEstimativaInicial, "Devem ser iguais, pois foi alterada");
            Assert.AreEqual(situacaoPlanejamento2.Oid, tarefaAlterada.Tarefa.OidSituacaoPlanejamento, "Devem ser iguais, pois foi alterada");
            Assert.AreEqual(colaborador2.Oid, tarefaAlterada.Tarefa.OidAtualizadoPor, "Deve ser o mesmo, pois foi outro usuário que alterou a tarefa");
        }
Beispiel #15
0
        public void ConsultarCronogramaTarefasPorOidTest()
        {
            SituacaoPlanejamento situacaoPlanejamento = CronogramaFactoryEntity.CriarSituacaoPlanejamento(contexto, "S1", CsTipoSituacaoPlanejamento.Ativo, CsTipoPlanejamento.Execução, CsPadraoSistema.Sim, true);

            Cronograma cronograma1 = CronogramaFactoryEntity.CriarCronograma(contexto, "Cronograma 01", situacaoPlanejamento, new DateTime(), new DateTime(), true);

            Colaborador colaborador1 = ColaboradorFactoryEntity.CriarColaborador(contexto, "anderson.lins", true);

            string responsaveis = colaborador1.NomeCompleto;

            DateTime dtInicio = DateTime.Now;

            List <Guid> oidTarefas = new List <Guid>();

            List <CronogramaTarefa> tarefasImpactadas;
            DateTime dataHoraAcao = new DateTime();

            CronogramaBo.CriarTarefa(cronograma1.Oid, "Tarefa 01", situacaoPlanejamento.Oid.ToString(), dtInicio, colaborador1.Usuario.UserName, "Criar método", responsaveis, out tarefasImpactadas, ref dataHoraAcao, 3, 0);

            List <CronogramaTarefa> lstCronoTarefas = CronogramaTarefaDao.ConsultarCronogramaTarefasPorOidCronograma(cronograma1.Oid,
                                                                                                                     o => o.Tarefa.SituacaoPlanejamento,
                                                                                                                     o => o.Tarefa.AtualizadoPor.Usuario.Person,
                                                                                                                     o => o.Cronograma);

            CronogramaBo.CriarTarefa(cronograma1.Oid, "Tarefa 02", situacaoPlanejamento.Oid.ToString(), dtInicio, colaborador1.Usuario.UserName, "Criar método", responsaveis, out tarefasImpactadas, ref dataHoraAcao, 3, lstCronoTarefas[0].NbID);

            lstCronoTarefas = CronogramaTarefaDao.ConsultarCronogramaTarefasPorOidCronograma(cronograma1.Oid,
                                                                                             o => o.Tarefa.SituacaoPlanejamento,
                                                                                             o => o.Tarefa.AtualizadoPor.Usuario.Person,
                                                                                             o => o.Cronograma);

            CronogramaBo.CriarTarefa(cronograma1.Oid, "Tarefa 03", situacaoPlanejamento.Oid.ToString(), dtInicio, colaborador1.Usuario.UserName, "Criar método", responsaveis, out tarefasImpactadas, ref dataHoraAcao, 3, lstCronoTarefas[1].NbID);

            lstCronoTarefas = CronogramaTarefaDao.ConsultarCronogramaTarefasPorOidCronograma(cronograma1.Oid,
                                                                                             o => o.Tarefa.SituacaoPlanejamento,
                                                                                             o => o.Tarefa.AtualizadoPor.Usuario.Person,
                                                                                             o => o.Cronograma);

            CronogramaBo.CriarTarefa(cronograma1.Oid, "Tarefa 04", situacaoPlanejamento.Oid.ToString(), dtInicio, colaborador1.Usuario.UserName, "Criar método", responsaveis, out tarefasImpactadas, ref dataHoraAcao, 3, lstCronoTarefas[2].NbID);

            lstCronoTarefas = CronogramaTarefaDao.ConsultarCronogramaTarefasPorOidCronograma(cronograma1.Oid,
                                                                                             o => o.Tarefa.SituacaoPlanejamento,
                                                                                             o => o.Tarefa.AtualizadoPor.Usuario.Person,
                                                                                             o => o.Cronograma);

            oidTarefas.Add(lstCronoTarefas[0].Oid);
            oidTarefas.Add(lstCronoTarefas[2].Oid);

            //realiza a busca pelas tarefas de acordo com a lista de oids passados e o cronograma.
            List <CronogramaTarefa> lstTarefasResult = CronogramaTarefaDao.ConsultarCronogramaTarefasPorOid(oidTarefas,
                                                                                                            o => o.Tarefa.SituacaoPlanejamento,
                                                                                                            o => o.Tarefa.AtualizadoPor.Usuario.Person,
                                                                                                            o => o.Cronograma);

            //verifica se as tarefas são as mesmas e a quantidade é a mesma.
            Assert.AreEqual(2, lstTarefasResult.Count);

            Assert.AreEqual(lstCronoTarefas[0].Oid, lstTarefasResult[0].Oid, "Deveria ser o mesmo CronogramaTarefa");
            Assert.AreEqual(lstCronoTarefas[0].OidCronograma, lstTarefasResult[0].OidCronograma, "Deveriam estar no mesmo cronograma");
            Assert.AreEqual(lstCronoTarefas[0].OidTarefa, lstTarefasResult[0].OidTarefa, "Deveriam estar relacionadas a mesma tarefa");
            Assert.AreEqual(lstCronoTarefas[0].NbID, lstTarefasResult[0].NbID, "Deveria estar com o mesmo NbId");
            Assert.AreEqual(lstCronoTarefas[0].CsExcluido, lstTarefasResult[0].CsExcluido, "Deveriam estar com o mesmo estado de exclusão");


            Assert.AreEqual(lstCronoTarefas[2].Oid, lstTarefasResult[1].Oid, "Deveria ser o mesmo CronogramaTarefa");
            Assert.AreEqual(lstCronoTarefas[2].OidCronograma, lstTarefasResult[1].OidCronograma, "Deveriam estar no mesmo cronograma");
            Assert.AreEqual(lstCronoTarefas[2].OidTarefa, lstTarefasResult[1].OidTarefa, "Deveriam estar relacionadas a mesma tarefa");
            Assert.AreEqual(lstCronoTarefas[2].NbID, lstTarefasResult[1].NbID, "Deveria estar com o mesmo NbId");
            Assert.AreEqual(lstCronoTarefas[2].CsExcluido, lstTarefasResult[1].CsExcluido, "Deveriam estar com o mesmo estado de exclusão");
        }