public void SalvarVariosModulosParaUmProjeto()
        {
            /**
             * Cenário 8: Será criado um projeto com 300 pontos.
             * Após isso, será criado um módulo cujo esforço será de 50% do valor dos pontos.
             * O sistema deverá colocar o valor de 150 para o esforço.
             */

            Projeto projeto1 = ProjetoFactory.Criar(SessionTest, 10, "", true);
            Modulo  modulo   = ModuloFactory.Criar(SessionTest, projeto1, "", true);

            modulo.NbEsforcoPlanejado = 10;

            Assert.AreEqual((UInt32)10, modulo.NbEsforcoPlanejado);

            Modulo modulo2 = ModuloFactory.Criar(SessionTest, projeto1, "", true);

            modulo2.NbEsforcoPlanejado = 10;

            Assert.AreEqual((UInt32)10, modulo2.NbEsforcoPlanejado);

            Modulo modulo3 = ModuloFactory.Criar(SessionTest, projeto1, "", true);

            modulo3.NbEsforcoPlanejado = 10;

            Assert.AreEqual((UInt32)10, modulo3.NbEsforcoPlanejado);
        }
Ejemplo n.º 2
0
        public void DeletarUmResultadoEsperado()
        {
            /**
             * Cenário 4: Serão criados 3 resultados esperados.
             * O resultado 2 deverá ser deletado e os outros dois devem ser reordenados para 1 e 2 respectivamente.
             */

            Projeto        projeto1       = ProjetoFactory.Criar(SessionTest, 0, "", true);
            Modulo         modulo1        = ModuloFactory.Criar(SessionTest, projeto1, "", true);
            Requisito      requisito1     = RequisitoFactory.Criar(SessionTest, modulo1, "nome", "descricao", "link", true);
            CasoTeste      casoteste1     = CasoTesteFactory.Criar(SessionTest, requisito1, "passos", "sumário", "precondicoes", true);
            CasoTestePasso casoTestePasso = CasoTestePassoFactory.Criar(SessionTest, casoteste1, "", true);

            CasoTestePassoResultadoEsperado casoTestePassoResultadoEsperado1 = CasoTestePassoResultadoEsperadoFactory.Criar(SessionTest, casoTestePasso, "", true);

            Assert.AreEqual(1, casoTestePassoResultadoEsperado1.NbSequencia, "A sequência deveria ser 1");

            CasoTestePassoResultadoEsperado casoTestePassoResultadoEsperado2 = CasoTestePassoResultadoEsperadoFactory.Criar(SessionTest, casoTestePasso, "", true);

            Assert.AreEqual(2, casoTestePassoResultadoEsperado2.NbSequencia, "A sequência deveria ser 2");

            CasoTestePassoResultadoEsperado casoTestePassoResultadoEsperado3 = CasoTestePassoResultadoEsperadoFactory.Criar(SessionTest, casoTestePasso, "", true);

            Assert.AreEqual(3, casoTestePassoResultadoEsperado3.NbSequencia, "A sequência deveria ser 3");

            casoTestePassoResultadoEsperado2.Delete();

            Assert.AreEqual(1, casoTestePassoResultadoEsperado1.NbSequencia, "A sequência deveria ser 1");
            Assert.AreEqual(2, casoTestePassoResultadoEsperado3.NbSequencia, "A sequência deveria ser 2");
        }
        public void AdicionarInformação()
        {
            /**
             * Cenário 5: Serão criadas 3 informações adicionais para uma pré-condição.
             * O sistema deverá informar quantas informações estão cadastradas no sistema.
             */

            Projeto              projeto1              = ProjetoFactory.Criar(SessionTest, 0, "", true);
            Modulo               modulo1               = ModuloFactory.Criar(SessionTest, projeto1, "", true);
            Requisito            requisito1            = RequisitoFactory.Criar(SessionTest, modulo1, "nome", "descricao", "link", true);
            CasoTeste            casoteste1            = CasoTesteFactory.Criar(SessionTest, requisito1, "passos", "sumário", "precondicoes", true);
            CasoTestePreCondicao casotestePreCondicao1 = CasoTestePreCondicaoFactory.Criar(SessionTest, casoteste1, "", true);

            CasoTestePreCondicaoInformacaoAdicional casoTestePreCondicaoInfoAdicional1 = CasoTestePreCondicaoInformacaoAdicionalFactory.Criar(SessionTest, casotestePreCondicao1, true);

            Assert.AreEqual(1, casoTestePreCondicaoInfoAdicional1.NbSequencia, "A sequência deveria ser 1");

            CasoTestePreCondicaoInformacaoAdicional casoTestePreCondicaoInfoAdicional2 = CasoTestePreCondicaoInformacaoAdicionalFactory.Criar(SessionTest, casotestePreCondicao1, true);

            Assert.AreEqual(2, casoTestePreCondicaoInfoAdicional2.NbSequencia, "A sequência deveria ser 2");

            CasoTestePreCondicaoInformacaoAdicional casoTestePreCondicaoInfoAdicional3 = CasoTestePreCondicaoInformacaoAdicionalFactory.Criar(SessionTest, casotestePreCondicao1, true);

            Assert.AreEqual(3, casoTestePreCondicaoInfoAdicional3.NbSequencia, "A sequência deveria ser 3");

            CasoTestePreCondicaoInformacaoAdicional casoTestePreCondicaoInfoAdicional4 = CasoTestePreCondicaoInformacaoAdicionalFactory.Criar(SessionTest, casotestePreCondicao1, true);

            Assert.AreEqual(4, casoTestePreCondicaoInfoAdicional4.NbSequencia, "A sequência deveria ser 3");

            casoTestePreCondicaoInfoAdicional3.Delete();

            Assert.AreEqual(3, casotestePreCondicao1._NbInformacoesAdicionais, "O valor deveria ser 3");
        }
        public void CriarSequenciaPreCondicao()
        {
            /**
             * Cenário 1: Serão criadas 3 informações adicionais para uma pré-condição.
             * O sistema deverá salvá-lo com a sequência correta
             */

            Projeto              projeto1              = ProjetoFactory.Criar(SessionTest, 0, "", true);
            Modulo               modulo1               = ModuloFactory.Criar(SessionTest, projeto1, "", true);
            Requisito            requisito1            = RequisitoFactory.Criar(SessionTest, modulo1, "nome", "descricao", "link", true);
            CasoTeste            casoteste1            = CasoTesteFactory.Criar(SessionTest, requisito1, "passos", "sumário", "precondicoes", true);
            CasoTestePreCondicao casotestePreCondicao1 = CasoTestePreCondicaoFactory.Criar(SessionTest, casoteste1, "", true);

            CasoTestePreCondicaoInformacaoAdicional casoTestePreCondicaoInfoAdicional1 = CasoTestePreCondicaoInformacaoAdicionalFactory.Criar(SessionTest, casotestePreCondicao1, true);

            Assert.AreEqual(1, casoTestePreCondicaoInfoAdicional1.NbSequencia, "A sequência deveria ser 1");

            CasoTestePreCondicaoInformacaoAdicional casoTestePreCondicaoInfoAdicional2 = CasoTestePreCondicaoInformacaoAdicionalFactory.Criar(SessionTest, casotestePreCondicao1, true);

            Assert.AreEqual(2, casoTestePreCondicaoInfoAdicional2.NbSequencia, "A sequência deveria ser 2");

            CasoTestePreCondicaoInformacaoAdicional casoTestePreCondicaoInfoAdicional3 = CasoTestePreCondicaoInformacaoAdicionalFactory.Criar(SessionTest, casotestePreCondicao1, true);

            Assert.AreEqual(3, casoTestePreCondicaoInfoAdicional3.NbSequencia, "A sequência deveria ser 3");
        }
        public void SalvarRequisitoJaExitenteEmUmProjeto()
        {
            Projeto projeto1 = ProjetoFactory.Criar(SessionTest, 0, "", true);
            Modulo  modulo1  = ModuloFactory.Criar(SessionTest, projeto1, "", true);

            /**
             * Cenário 2: Serão criados 3 requisitos para o projeto e em seguida será deletado o segundo requisito.
             * Após isso, será criado mais 1 modulo, que o wex deverá criar como RF_4.
             */

            Requisito requisito1 = RequisitoFactory.Criar(SessionTest, modulo1, "nome", "descricao", "link", true);

            Assert.AreEqual("RF_01.01", requisito1.TxID, "O ID do modulo deveria ser RF_01.01");

            requisito1 = RequisitoFactory.Criar(SessionTest, modulo1, "nome", "descricao", "link", true);

            Assert.AreEqual("RF_01.02", requisito1.TxID, "O ID do modulo deveria ser RF_01.02");

            Assert.AreEqual("RF_01.03", RequisitoFactory.Criar(SessionTest, modulo1, "nome", "descricao", "link", true).TxID, "O ID do modulo deveria ser RF_01.03");

            //Criar o delete Rf_1.2

            requisito1.Delete();

            Assert.AreEqual("RF_01.04", RequisitoFactory.Criar(SessionTest, modulo1, "nome", "descricao", "link", true).TxID, "O ID do modulo deveria ser RF_01.04");
        }
        public void SalvarModuloQueJaPossuiModulosEmCodigo()
        {
            /**
             * Cenário 2: Serão criados 3 modulos para o projeto e em seguida será deletado o segundo modulo.
             * Após isso, será criado mais 1 modulo, que o wex deverá criar como RF_4.
             */

            Projeto projeto1 = ProjetoFactory.Criar(SessionTest);
            Modulo  modulo   = ModuloFactory.Criar(SessionTest, projeto1, "", true);

            Assert.AreEqual("01", modulo.TxID, "O ID do modulo deveria ser 1");

            Modulo modulo1 = ModuloFactory.Criar(SessionTest, projeto1, "", true);

            Assert.AreEqual("02", modulo1.TxID, "O ID do modulo deveria ser 2");

            Modulo modulo2 = ModuloFactory.Criar(SessionTest, projeto1, "", true);

            Assert.AreEqual("03", modulo2.TxID, "O ID do modulo deveria ser 3");

            //Criar o delete Rf_2

            modulo1.Delete();

            Modulo modulo4 = ModuloFactory.Criar(SessionTest, projeto1, "", true);

            Assert.AreEqual("04", modulo4.TxID, "O ID do modulo deveria ser 4");
        }
Ejemplo n.º 7
0
        public void SalvarEstoriaComMaisDeTrezePontos()
        {
            /*
             * Cenario 1 - Criar um projeto01 incluir um ciclo a esse projeto
             * tentar incluir uma estória com mais de 13 pontos no ciclo - CT_3.02.01
             */

            //PASSO 1

            Projeto projeto = ProjetoFactory.Criar(SessionTest, 100, "Nome");

            projeto.DtInicioPlan           = new DateTime(2011, 04, 25);
            projeto.DtInicioReal           = new DateTime(2011, 08, 25);
            projeto.NbCicloTotalPlan       = 1;
            projeto.NbCicloDuracaoDiasPlan = 10;
            projeto.NbCicloDiasIntervalo   = 1;
            projeto.Save();

            //PASSO 2

            Modulo      modulo      = ModuloFactory.Criar(SessionTest, projeto, "", true);
            Beneficiado beneficiado = BeneficiadoFactory.Criar(SessionTest, "TxDescricao", true);
            Estoria     estoria     = EstoriaFactory.Criar(SessionTest, modulo, "TxTitulo", "TxGostariaDe", "TxEntaoPoderei", beneficiado, "TxObservacoes", "TxReferencias", "TxDuvidas", true);

            estoria.NbTamanho = 8;
            estoria.Save();

            CicloDesenv        ciclo = projeto.Ciclos[0];
            CicloDesenvEstoria cicloDesenvEstoria = CicloDesenvEstoriaFactory.Criar(SessionTest, ciclo, estoria, true);
        }
        public void TestarRecuperarApenasModulosFilhos()
        {
            Projeto projeto = ProjetoFactory.Criar(SessionTest, 100, "projeto 01", true);
            Modulo  mod1    = ModuloFactory.Criar(SessionTest, projeto, "modulo 1", true);
            Modulo  mod2    = ModuloFactory.Criar(SessionTest, projeto, "modulo 2", true);
            Modulo  mod3    = ModuloFactory.Criar(SessionTest, projeto, "modulo 3", true);

            XPCollection <Modulo> modulos = Modulo.GetModuloPorProjeto(SessionTest, projeto.Oid);

            Assert.AreEqual(3, modulos.Count);

            Modulo mod1_1 = ModuloFactory.CriarModuloFilho(SessionTest, mod1, "modulo 1.1", true);
            Modulo mod2_1 = ModuloFactory.CriarModuloFilho(SessionTest, mod2, "modulo 2.1", true);
            Modulo mod3_1 = ModuloFactory.CriarModuloFilho(SessionTest, mod3, "modulo 3.1", true);

            modulos = Modulo.GetModuloPorProjeto(SessionTest, projeto.Oid);
            Assert.AreEqual(3, modulos.Count);

            ModuloFactory.CriarModuloFilho(SessionTest, mod1_1, "modulo 1.1", true);
            ModuloFactory.CriarModuloFilho(SessionTest, mod2_1, "modulo 2.1", true);
            ModuloFactory.CriarModuloFilho(SessionTest, mod3_1, "modulo 3.1", true);

            modulos = Modulo.GetModuloPorProjeto(SessionTest, projeto.Oid);
            Assert.AreEqual(3, modulos.Count);
        }
        public void TestarRecuperarModulosRaiz()
        {
            Projeto projeto = ProjetoFactory.Criar(SessionTest, 100, "projeto 01", true);
            Modulo  mod1    = ModuloFactory.Criar(SessionTest, projeto, "modulo 1", true);
            Modulo  mod2    = ModuloFactory.Criar(SessionTest, projeto, "modulo 2", true);
            Modulo  mod3    = ModuloFactory.Criar(SessionTest, projeto, "modulo 3", true);

            Modulo mod1_1 = ModuloFactory.CriarModuloFilho(SessionTest, mod1, "modulo 1.1", true);
            Modulo mod2_1 = ModuloFactory.CriarModuloFilho(SessionTest, mod2, "modulo 2.1", true);
            Modulo mod3_1 = ModuloFactory.CriarModuloFilho(SessionTest, mod3, "modulo 3.1", true);

            Modulo mod1_1_1 = ModuloFactory.CriarModuloFilho(SessionTest, mod1_1, "modulo 1.1.1", true);
            Modulo mod2_1_1 = ModuloFactory.CriarModuloFilho(SessionTest, mod2_1, "modulo 2.1.1", true);
            Modulo mod3_1_1 = ModuloFactory.CriarModuloFilho(SessionTest, mod3_1, "modulo 3.1.1", true);

            Modulo mod1_1_1_1 = ModuloFactory.CriarModuloFilho(SessionTest, mod1_1_1, "modulo 1.1.1.1", true);
            Modulo mod2_1_1_1 = ModuloFactory.CriarModuloFilho(SessionTest, mod2_1_1, "modulo 2.1.1.1", true);
            Modulo mod3_1_1_1 = ModuloFactory.CriarModuloFilho(SessionTest, mod3_1_1, "modulo 3.1.1.1", true);


            Assert.AreEqual(mod1, Modulo.RnRecuperarModuloRaiz(mod1_1));
            Assert.AreEqual(mod2, Modulo.RnRecuperarModuloRaiz(mod2_1));
            Assert.AreEqual(mod3, Modulo.RnRecuperarModuloRaiz(mod3_1));

            Assert.AreEqual(mod1, Modulo.RnRecuperarModuloRaiz(mod1_1_1));
            Assert.AreEqual(mod2, Modulo.RnRecuperarModuloRaiz(mod2_1_1));
            Assert.AreEqual(mod3, Modulo.RnRecuperarModuloRaiz(mod3_1_1));

            Assert.AreEqual(mod1, Modulo.RnRecuperarModuloRaiz(mod1_1_1_1));
            Assert.AreEqual(mod2, Modulo.RnRecuperarModuloRaiz(mod2_1_1_1));
            Assert.AreEqual(mod3, Modulo.RnRecuperarModuloRaiz(mod3_1_1_1));
        }
        public void MetodoTestaSalvarModuloSemProjeto()
        {
            Modulo modulo1 = ModuloFactory.Criar(SessionTest, null, "", true);

            Assert.AreEqual(ValidationState.Invalid, ValidationUtil.GetRuleState(modulo1,
                                                                                 "NaoPermitirSalvarModuloSeNaoTiverProjetoSelecionado", DefaultContexts.Save));
        }
        public void TestarCalcularPercentualComBasePontuacao()
        {
            //Passo 1
            Projeto projeto = ProjetoFactory.Criar(SessionTest, 100, "nome projeto", true);
            Modulo  modulo1 = ModuloFactory.Criar(SessionTest, projeto, "", true);
            Modulo  modulo2 = ModuloFactory.Criar(SessionTest, projeto, "", true);
            Modulo  modulo3 = ModuloFactory.Criar(SessionTest, projeto, "", true);

            modulo1.NbPontosTotal = 40;
            modulo2.NbPontosTotal = 40;
            modulo3.NbPontosTotal = 15;
            modulo1.Save();
            modulo2.Save();

            // (Total de pontos do módulo * 100) / Total de pontos do projeto
            Assert.AreEqual((UInt32)40, modulo1.NbEsforcoPlanejado, "deveria ser calculado o esforço com base número de pontos prlanejados");
            Assert.AreEqual((UInt32)40, modulo2.NbEsforcoPlanejado, "deveria ser calculado o esforço com base número de pontos prlanejados");
            //Passo 2

            modulo3.Save();
            Assert.AreEqual((UInt32)15, modulo3.NbEsforcoPlanejado, "deveria ser calculado o esforço com base número de pontos prlanejados");


            //Passo 3
            //teste do método RnVerificaTotalPontosUltrapassaProjeto()

            Modulo modulo4 = ModuloFactory.Criar(SessionTest, projeto, "", true);

            modulo4.NbPontosTotal = 10;

            Assert.AreEqual(ValidationState.Invalid, ValidationUtil.GetRuleState(modulo4,
                                                                                 "SalvarModulosProjetoSomaPontosPlanejadosMaiorTamanhoProjeto", DefaultContexts.Save));
        }
Ejemplo n.º 12
0
        public void CriarSequenciaResultadoEsperado()
        {
            /**
             * Cenário 1: Serão criados 3 resultados esperados para um passo.
             * O sistema deverá cria-los com a sequencia 1, 2, 3 respectivamente.
             */

            Projeto        projeto1       = ProjetoFactory.Criar(SessionTest, 0, "", true);
            Modulo         modulo1        = ModuloFactory.Criar(SessionTest, projeto1, "", true);
            Requisito      requisito1     = RequisitoFactory.Criar(SessionTest, modulo1, "nome", "descricao", "link", true);
            CasoTeste      casoteste1     = CasoTesteFactory.Criar(SessionTest, requisito1, "passos", "sumário", "precondicoes", true);
            CasoTestePasso casoTestePasso = CasoTestePassoFactory.Criar(SessionTest, casoteste1, "", true);

            CasoTestePassoResultadoEsperado casoTestePassoResultadoEsperado1 = CasoTestePassoResultadoEsperadoFactory.Criar(SessionTest, casoTestePasso, "", true);

            Assert.AreEqual(1, casoTestePassoResultadoEsperado1.NbSequencia, "A sequência deveria ser 1");

            CasoTestePassoResultadoEsperado casoTestePassoResultadoEsperado2 = CasoTestePassoResultadoEsperadoFactory.Criar(SessionTest, casoTestePasso, "", true);

            Assert.AreEqual(2, casoTestePassoResultadoEsperado2.NbSequencia, "A sequência deveria ser 2");

            CasoTestePassoResultadoEsperado casoTestePassoResultadoEsperado3 = CasoTestePassoResultadoEsperadoFactory.Criar(SessionTest, casoTestePasso, "", true);

            Assert.AreEqual(3, casoTestePassoResultadoEsperado3.NbSequencia, "A sequência deveria ser 3");
        }
        public void DeletarUmaPreCondicao()
        {
            /**
             * Cenário 4: Serão criadas 3 informações adicionais para uma pré-condição.
             * A informação adicional 2 deverá ser deletada e as outras duas devem ser reordenadas para 1 e 2 respectivamente.
             */

            Projeto              projeto1              = ProjetoFactory.Criar(SessionTest, 0, "", true);
            Modulo               modulo1               = ModuloFactory.Criar(SessionTest, projeto1, "", true);
            Requisito            requisito1            = RequisitoFactory.Criar(SessionTest, modulo1, "nome", "descricao", "link", true);
            CasoTeste            casoteste1            = CasoTesteFactory.Criar(SessionTest, requisito1, "passos", "sumário", "precondicoes", true);
            CasoTestePreCondicao casotestePreCondicao1 = CasoTestePreCondicaoFactory.Criar(SessionTest, casoteste1, "", true);

            CasoTestePreCondicaoInformacaoAdicional casoTestePreCondicaoInfoAdicional1 = CasoTestePreCondicaoInformacaoAdicionalFactory.Criar(SessionTest, casotestePreCondicao1, true);

            Assert.AreEqual(1, casoTestePreCondicaoInfoAdicional1.NbSequencia, "A sequência deveria ser 1");

            CasoTestePreCondicaoInformacaoAdicional casoTestePreCondicaoInfoAdicional2 = CasoTestePreCondicaoInformacaoAdicionalFactory.Criar(SessionTest, casotestePreCondicao1, true);

            Assert.AreEqual(2, casoTestePreCondicaoInfoAdicional2.NbSequencia, "A sequência deveria ser 2");

            CasoTestePreCondicaoInformacaoAdicional casoTestePreCondicaoInfoAdicional3 = CasoTestePreCondicaoInformacaoAdicionalFactory.Criar(SessionTest, casotestePreCondicao1, true);

            Assert.AreEqual(3, casoTestePreCondicaoInfoAdicional3.NbSequencia, "A sequência deveria ser 3");

            casoTestePreCondicaoInfoAdicional2.Delete();

            Assert.AreEqual(1, casoTestePreCondicaoInfoAdicional1.NbSequencia, "A sequência deveria ser 1");
            Assert.AreEqual(2, casoTestePreCondicaoInfoAdicional3.NbSequencia, "A sequência deveria ser 3");
        }
        public void ReordenarSequencia()
        {
            /**
             * Cenário 2: Serão criadoas 3 informações adicionais para um resultado esperado.
             * Em seguida  as sequências serão mudadas.
             * O sistema deverá reordenar corretamente
             */

            //Passo 1
            Projeto        projeto1        = ProjetoFactory.Criar(SessionTest, 0, "", true);
            Modulo         modulo1         = ModuloFactory.Criar(SessionTest, projeto1, "", true);
            Requisito      requisito1      = RequisitoFactory.Criar(SessionTest, modulo1, "nome", "descricao", "link", true);
            CasoTeste      casoteste1      = CasoTesteFactory.Criar(SessionTest, requisito1, "passos", "sumário", "precondicoes", true);
            CasoTestePasso casotestePasso1 = CasoTestePassoFactory.Criar(SessionTest, casoteste1, "", true);
            CasoTestePassoResultadoEsperado casoTestePassoResultadoEsperado1 = CasoTestePassoResultadoEsperadoFactory.Criar(SessionTest, casotestePasso1, "", true);

            CasoTestePassoResultadoEsperadoInformacaoAdicional casoTestePassoResultadoEsperadoInfoAdicional1 = CasoTestePassoResultadoEsperadoInformacaoAdicionalFactory.Criar(SessionTest,
                                                                                                                                                                               casoTestePassoResultadoEsperado1, true);

            Assert.AreEqual(1, casoTestePassoResultadoEsperadoInfoAdicional1.NbSequencia, "A sequência deveria ser 1");

            //Passo 2
            CasoTestePassoResultadoEsperadoInformacaoAdicional casoTestePassoResultadoEsperadoInfoAdicional2 = CasoTestePassoResultadoEsperadoInformacaoAdicionalFactory.Criar(SessionTest,
                                                                                                                                                                               casoTestePassoResultadoEsperado1, true);
            CasoTestePassoResultadoEsperadoInformacaoAdicional casoTestePassoResultadoEsperadoInfoAdicional3 = CasoTestePassoResultadoEsperadoInformacaoAdicionalFactory.Criar(SessionTest,
                                                                                                                                                                               casoTestePassoResultadoEsperado1, true);

            Assert.AreEqual(2, casoTestePassoResultadoEsperadoInfoAdicional2.NbSequencia, "A sequência deveria ser 2");
            Assert.AreEqual(3, casoTestePassoResultadoEsperadoInfoAdicional3.NbSequencia, "A sequência deveria ser 3");

            //Passo 3

            casoTestePassoResultadoEsperadoInfoAdicional1.NbSequencia = 2;
            Assert.AreEqual(1, casoTestePassoResultadoEsperadoInfoAdicional2.NbSequencia, "A sequência deveria ser 1");
            Assert.AreEqual(2, casoTestePassoResultadoEsperadoInfoAdicional1.NbSequencia, "A sequência deveria ser 2");
            Assert.AreEqual(3, casoTestePassoResultadoEsperadoInfoAdicional3.NbSequencia, "A sequência deveria ser 3");

            //Passo 4

            casoTestePassoResultadoEsperadoInfoAdicional2.NbSequencia = 3;
            Assert.AreEqual(1, casoTestePassoResultadoEsperadoInfoAdicional1.NbSequencia, "A sequência deveria ser 1");
            Assert.AreEqual(2, casoTestePassoResultadoEsperadoInfoAdicional3.NbSequencia, "A sequência deveria ser 2");
            Assert.AreEqual(3, casoTestePassoResultadoEsperadoInfoAdicional2.NbSequencia, "A sequência deveria ser 3");

            //Passo 5

            casoTestePassoResultadoEsperadoInfoAdicional2.NbSequencia = 2;
            Assert.AreEqual(1, casoTestePassoResultadoEsperadoInfoAdicional1.NbSequencia, "A sequência deveria ser 1");
            Assert.AreEqual(2, casoTestePassoResultadoEsperadoInfoAdicional2.NbSequencia, "A sequência deveria ser 2");
            Assert.AreEqual(3, casoTestePassoResultadoEsperadoInfoAdicional3.NbSequencia, "A sequência deveria ser 3");

            //Passo 6

            casoTestePassoResultadoEsperadoInfoAdicional3.NbSequencia = 1;
            Assert.AreEqual(1, casoTestePassoResultadoEsperadoInfoAdicional3.NbSequencia, "A sequência deveria ser 1");
            Assert.AreEqual(2, casoTestePassoResultadoEsperadoInfoAdicional1.NbSequencia, "A sequência deveria ser 2");
            Assert.AreEqual(3, casoTestePassoResultadoEsperadoInfoAdicional2.NbSequencia, "A sequência deveria ser 3");
        }
Ejemplo n.º 15
0
 public void DadoOModulo2_Escopo(string modulo)
 {
     ModulosDic.Add(modulo,
                    ModuloFactory.Criar(SessionTest,
                                        ProjetoFactory.Criar(SessionTest, 0, string.Format("Projeto - {0}", modulo), true),
                                        modulo,
                                        true)
                    );
 }
Ejemplo n.º 16
0
        public void TestarAlterarInicioRealDoProjetoQueJaPossuiCiclosConcluidos()
        {
            /**
             * Cenário 6: Será criado um projeto
             * Em seguida, será testado alterar o início real do projeto que ja possui ciclos concluídos
             */

            Projeto projetoA = ProjetoFactory.Criar(SessionTest, 30, "");
            Modulo  moduloA  = ModuloFactory.Criar(SessionTest, projetoA, "", false);

            moduloA.NbEsforcoPlanejado = 100;
            moduloA.Save();
            Beneficiado beneficiadoA = BeneficiadoFactory.Criar(SessionTest, "", true);
            Estoria     estoriaA     = EstoriaFactory.Criar(SessionTest, moduloA, "", "", "", beneficiadoA, "", "", "", true);

            projetoA.DtInicioPlan           = new DateTime(2011, 05, 01);
            projetoA.DtInicioReal           = new DateTime(2011, 05, 01);
            projetoA.DtTerminoPlan          = new DateTime(2011, 05, 31);
            projetoA.NbTamanhoTotal         = 30;
            projetoA.NbCicloTotalPlan       = 2;
            projetoA.NbCicloDuracaoDiasPlan = 10;
            projetoA.NbCicloDiasIntervalo   = 1;

            projetoA.Save();

            //Passo 1

            projetoA.Ciclos[0].CsSituacaoCiclo = CsSituacaoCicloDomain.Concluido;
            projetoA.Ciclos[0].Save();
            projetoA.DtInicioReal = new DateTime(2011, 06, 01);
            projetoA.Save();

            if (projetoA.Ciclos[0].CsSituacaoCiclo != CsSituacaoCicloDomain.Concluido)
            {
                Assert.AreEqual(new DateTime(2011, 06, 29), projetoA._DtTerminoReal, "A data do termino real deveria ser 29/06/2011");
            }
            else
            {
                Assert.AreEqual(new DateTime(2011, 05, 31), projetoA._DtTerminoReal, "A data do termino real deveria ser 31/05/2011");
            }


            //Passo 2


            projetoA.Ciclos[0].CsSituacaoCiclo = CsSituacaoCicloDomain.NaoPlanejado;
            projetoA.Ciclos[0].Save();

            projetoA.DtInicioReal = new DateTime(2011, 06, 01);
            projetoA.Save();

            Assert.AreEqual(new DateTime(2011, 06, 01), projetoA.Ciclos[0].DtInicio, "A data do termino real deveria ser 01/06/2011");
            Assert.AreEqual(new DateTime(2011, 06, 14), projetoA.Ciclos[0].DtTermino, "A data do termino real deveria ser 14/06/2011");

            Assert.AreEqual(new DateTime(2011, 06, 16), projetoA.Ciclos[1].DtInicio, "A data do termino real deveria ser 16/06/2011");
            Assert.AreEqual(new DateTime(2011, 06, 29), projetoA.Ciclos[1].DtTermino, "A data do termino real deveria ser 29/06/2011");
        }
Ejemplo n.º 17
0
        public void DescerSequenciaResultadoEsperado()
        {
            /**
             * Cenário 2: Serão criados 3 resultados esperados para um passo.
             * Em seguida  as sequências do resultado esperado serão mudadas.
             * O sistema deverá reordenar as sequências dos resultados restantes corretamente.
             */

            //Passo 1

            Projeto        projeto1       = ProjetoFactory.Criar(SessionTest, 0, "", true);
            Modulo         modulo1        = ModuloFactory.Criar(SessionTest, projeto1, "", true);
            Requisito      requisito1     = RequisitoFactory.Criar(SessionTest, modulo1, "nome", "descricao", "link", true);
            CasoTeste      casoteste1     = CasoTesteFactory.Criar(SessionTest, requisito1, "passos", "sumário", "precondicoes", true);
            CasoTestePasso casoTestePasso = CasoTestePassoFactory.Criar(SessionTest, casoteste1, "", true);

            CasoTestePassoResultadoEsperado casoTestePassoResultadoEsperado1 = CasoTestePassoResultadoEsperadoFactory.Criar(SessionTest, casoTestePasso, "", true);

            Assert.AreEqual(1, casoTestePassoResultadoEsperado1.NbSequencia, "A sequência deveria ser 1");

            //Passo 2

            CasoTestePassoResultadoEsperado casoTestePassoResultadoEsperado2 = CasoTestePassoResultadoEsperadoFactory.Criar(SessionTest, casoTestePasso, "", true);
            CasoTestePassoResultadoEsperado casoTestePassoResultadoEsperado3 = CasoTestePassoResultadoEsperadoFactory.Criar(SessionTest, casoTestePasso, "", true);

            Assert.AreEqual(2, casoTestePassoResultadoEsperado2.NbSequencia, "A sequência deveria ser 2");
            Assert.AreEqual(3, casoTestePassoResultadoEsperado3.NbSequencia, "A sequência deveria ser 3");

            //Passo 3

            casoTestePassoResultadoEsperado1.NbSequencia = 2;
            Assert.AreEqual(1, casoTestePassoResultadoEsperado2.NbSequencia, "A sequência deveria ser 1");
            Assert.AreEqual(2, casoTestePassoResultadoEsperado1.NbSequencia, "A sequência deveria ser 2");
            Assert.AreEqual(3, casoTestePassoResultadoEsperado3.NbSequencia, "A sequência deveria ser 3");

            //Passo 4

            casoTestePassoResultadoEsperado2.NbSequencia = 3;
            Assert.AreEqual(1, casoTestePassoResultadoEsperado1.NbSequencia, "A sequência deveria ser 1");
            Assert.AreEqual(2, casoTestePassoResultadoEsperado3.NbSequencia, "A sequência deveria ser 2");
            Assert.AreEqual(3, casoTestePassoResultadoEsperado2.NbSequencia, "A sequência deveria ser 3");

            //Passo 5

            casoTestePassoResultadoEsperado2.NbSequencia = 2;
            Assert.AreEqual(1, casoTestePassoResultadoEsperado1.NbSequencia, "A sequência deveria ser 1");
            Assert.AreEqual(2, casoTestePassoResultadoEsperado2.NbSequencia, "A sequência deveria ser 2");
            Assert.AreEqual(3, casoTestePassoResultadoEsperado3.NbSequencia, "A sequência deveria ser 3");

            //Passo 6

            casoTestePassoResultadoEsperado3.NbSequencia = 1;
            Assert.AreEqual(1, casoTestePassoResultadoEsperado3.NbSequencia, "A sequência deveria ser 1");
            Assert.AreEqual(2, casoTestePassoResultadoEsperado1.NbSequencia, "A sequência deveria ser 2");
            Assert.AreEqual(3, casoTestePassoResultadoEsperado2.NbSequencia, "A sequência deveria ser 3");
        }
        public void ReordenarSequencia()
        {
            /**
             * Cenário 2: Serão criados 3 pré-condições para um caso de teste.
             * Em seguida  as sequências serão mudadas.
             * O sistema deverá reordenar corretamente
             */

            //Passo 1

            Projeto   projeto1   = ProjetoFactory.Criar(SessionTest, 0, "", true);
            Modulo    modulo1    = ModuloFactory.Criar(SessionTest, projeto1, "", true);
            Requisito requisito1 = RequisitoFactory.Criar(SessionTest, modulo1, "nome", "descricao", "link", true);
            CasoTeste casoteste1 = CasoTesteFactory.Criar(SessionTest, requisito1, "passos", "sumário", "precondicoes", true);

            CasoTestePreCondicao casotestePreCondicao1 = CasoTestePreCondicaoFactory.Criar(SessionTest, casoteste1, "", true);

            Assert.AreEqual(1, casotestePreCondicao1.NbSequencia, "A sequência deveria ser 1");

            //Passo 2

            CasoTestePreCondicao casotestePreCondicao2 = CasoTestePreCondicaoFactory.Criar(SessionTest, casoteste1, "", true);
            CasoTestePreCondicao casotestePreCondicao3 = CasoTestePreCondicaoFactory.Criar(SessionTest, casoteste1, "", true);

            Assert.AreEqual(2, casotestePreCondicao2.NbSequencia, "A sequência deveria ser 2");
            Assert.AreEqual(3, casotestePreCondicao3.NbSequencia, "A sequência deveria ser 3");

            //Passo 3

            casotestePreCondicao1.NbSequencia = 2;
            Assert.AreEqual(1, casotestePreCondicao2.NbSequencia, "A sequência deveria ser 1");
            Assert.AreEqual(2, casotestePreCondicao1.NbSequencia, "A sequência deveria ser 2");
            Assert.AreEqual(3, casotestePreCondicao3.NbSequencia, "A sequência deveria ser 3");

            //Passo 4

            casotestePreCondicao2.NbSequencia = 3;
            Assert.AreEqual(1, casotestePreCondicao1.NbSequencia, "A sequência deveria ser 1");
            Assert.AreEqual(2, casotestePreCondicao3.NbSequencia, "A sequência deveria ser 2");
            Assert.AreEqual(3, casotestePreCondicao2.NbSequencia, "A sequência deveria ser 3");

            //Passo 5

            casotestePreCondicao2.NbSequencia = 2;
            Assert.AreEqual(1, casotestePreCondicao1.NbSequencia, "A sequência deveria ser 1");
            Assert.AreEqual(2, casotestePreCondicao2.NbSequencia, "A sequência deveria ser 2");
            Assert.AreEqual(3, casotestePreCondicao3.NbSequencia, "A sequência deveria ser 3");

            //Passo 6

            casotestePreCondicao3.NbSequencia = 1;
            Assert.AreEqual(1, casotestePreCondicao3.NbSequencia, "A sequência deveria ser 1");
            Assert.AreEqual(2, casotestePreCondicao1.NbSequencia, "A sequência deveria ser 2");
            Assert.AreEqual(3, casotestePreCondicao2.NbSequencia, "A sequência deveria ser 3");
        }
        public void SalvarModuloComModuloPai()
        {
            /**
             * Cenário 3: Será criado um módulo para o projeto.
             * Em seguida, será criado outro módulo, o qual selecionará o primeiro módulo como pai
             * O wex deverá salvar corretamente, respeitando a hierarquia da nomenclatura dos ID's
             */

            Projeto projeto1  = ProjetoFactory.Criar(SessionTest, 0, "", true);
            Modulo  modulo    = ModuloFactory.Criar(SessionTest, projeto1, "", true);
            Modulo  moduloPai = ModuloFactory.CriarModuloFilho(SessionTest, modulo, "", true);

            Assert.AreEqual("01.01", moduloPai.TxID, "O ID do modulo deveria ser 01.01");
        }
        public void CriarIdCasoTeste()
        {
            /**
             * Cenário 1: Serão criado 1 caso de teste para um requisito.
             * O sistema deverá salvá-lo com o ID CT_1.1.1
             */

            Projeto   projeto1   = ProjetoFactory.Criar(SessionTest, 0, "", true);
            Modulo    modulo1    = ModuloFactory.Criar(SessionTest, projeto1, "", true);
            Requisito requisito1 = RequisitoFactory.Criar(SessionTest, modulo1, "nome", "descricao", "link", true);
            CasoTeste casoteste1 = CasoTesteFactory.Criar(SessionTest, requisito1, "passos", "sumário", "precondicoes", true);

            Assert.AreEqual("CT_01.01.01", casoteste1.TxID, "O ID do caso de teste deveria ser CT_01.1.01");
        }
        /// <summary>
        /// Criar o Ciclo e as Estórias do Ciclo
        /// </summary>
        /// <param name="ciclo">Valor texto do Ciclo</param>
        /// <param name="estorias">Lista valores texto de Estórias do Ciclo</param>
        public static void CriarCicloEstoriasCiclo(Projeto projeto, string ciclo, List <string> estorias, Session session, ushort position = 1)
        {
            // Inserindo no dicionário
            if (!ciclosDic.ContainsKey(ciclo))
            {
                CicloDesenv cicloObj = CicloFactory.Criar(session, projeto, ciclo);
                cicloObj.NbCiclo = position;
                cicloObj.Save();

                ciclosDic.Add(ciclo, cicloObj);
            }

            foreach (string estoria in estorias)
            {
                string[] dados = estoria.Split(';');

                if (dados.Count() != 2)
                {
                    new Exception("O título e a situação da Estória devem vir separados por ';'");
                }

                string titulo   = dados[0]; // Título da Estória
                string situacao = dados[1]; // Situação da Estória

                // Se a chave já existir, continua o método
                if (estoriasDic.ContainsKey(titulo))
                {
                    continue;
                }

                Modulo      modulo      = ModuloFactory.Criar(session, projeto, string.Format("modulo - {0}", ciclo), true);
                Beneficiado beneficiado = BeneficiadoFactory.Criar(session, string.Format("beneficiado - {0}", ciclo), true);
                Estoria     estoriaObj  = EstoriaFactory.Criar(session, modulo, titulo, "gostaria de",
                                                               "então poderei", beneficiado, "observações", "referências", "dúvidas", true);

                estoriaObj.TxTitulo = titulo;
                estoriaObj.Save();

                // Estória no Ciclo
                CicloDesenvEstoria estoriaCiclo = CicloDesenvEstoriaFactory.Criar(session, ciclosDic[ciclo], estoriaObj, true);
                estoriaCiclo.CsSituacao = SituacaoEstoriaCicloByText(situacao);
                estoriaCiclo.Save();

                // Inserindo no dicionário
                estoriasDic.Add(titulo, estoriaCiclo);
            }

            ciclosDic[ciclo].IsExibirJanelaDestinoItensPendentes();
        }
        public void SalvarModuloTerceiroNivel()
        {
            /**
             * Cenário 5: Serão criados 4 módulos, sendo que sucessor sempre terá o antecessor como módulo pai.
             * O sistema deverá salvar o ultimo módulo com terceiro nivel de descêndencia.
             */

            Projeto projeto1   = ProjetoFactory.Criar(SessionTest, 0, "", true);
            Modulo  modulo     = ModuloFactory.Criar(SessionTest, projeto1, "", true);
            Modulo  moduloPai  = ModuloFactory.CriarModuloFilho(SessionTest, modulo, "", true);
            Modulo  moduloPai2 = ModuloFactory.CriarModuloFilho(SessionTest, moduloPai, "", true);
            Modulo  moduloPai3 = ModuloFactory.CriarModuloFilho(SessionTest, moduloPai2, "", true);

            Assert.AreEqual("01.01.01.01", moduloPai3.TxID, "O ID do modulo deveria ser 01.01.01.01");
        }
        public void SalvarSubModulo()
        {
            /**
             * Cenário 3: Será criado um requisito para um sub-módulo e o wex deverá salvar da forma correta. Ex: RF_1.1.2
             */

            Projeto   projeto1  = ProjetoFactory.Criar(SessionTest, 0, "", true);
            Modulo    modulo1   = ModuloFactory.Criar(SessionTest, projeto1, "", true);
            Modulo    moduloPai = ModuloFactory.CriarModuloFilho(SessionTest, modulo1, "", true);
            Requisito requisito = RequisitoFactory.Criar(SessionTest, moduloPai, "nome", "descricao", "link", true);

            Assert.AreEqual("RF_01.01.01", requisito.TxID, "O ID do modulo deveria ser RF_01.01.01");

            requisito = RequisitoFactory.Criar(SessionTest, moduloPai, "nome", "descricao", "link", true);
            Assert.AreEqual("RF_01.01.02", requisito.TxID, "O ID do modulo deveria ser RF_01.01.02");
        }
        /// <summary>
        /// método CriarUmNovoPassoComAcessoRapido
        /// </summary>
        //[TestMethod]
        public void CriarUmNovoPassoComAcessoRapido()
        {
            /**
             * Cenário 4: Será criado um passo para o caso de teste
             * O primeiro resultado esperado será inserido através do acesso rápido
             * O segundo resultado será criado através do detail de resultado esperado
             * O sistema deverá concatenar corretamente os valores dos resultados esperados
             */

            Projeto   projeto1   = ProjetoFactory.Criar(SessionTest, 0, "", true);
            Modulo    modulo1    = ModuloFactory.Criar(SessionTest, projeto1, "", true);
            Requisito requisito1 = RequisitoFactory.Criar(SessionTest, modulo1, "nome", "descricao", "link", true);
            CasoTeste casoteste1 = CasoTesteFactory.Criar(SessionTest, requisito1, "passos", "sumário", "precondicoes", true);

            CasoTestePasso casotestePasso1 = CasoTestePassoFactory.Criar(SessionTest, casoteste1, "", true);
        }
        public void SalvarEsforcoParaOModuloFilhoEExcluirOEsforcoDoModuloPai()
        {
            /**
             * Cenário 7: Será criado um módulo "A" com um esforço. Em seguida, será criado um módulo filho "B" que terá o seu proprio esforço.
             * O sistema deverá setar como nulo o esforço do módulo "A" e utilizar o esforço do módulo "B".
             */

            Projeto projeto1 = ProjetoFactory.Criar(SessionTest, 0, "", true);
            Modulo  modulo   = ModuloFactory.Criar(SessionTest, projeto1, "", true);

            modulo.NbEsforcoPlanejado = 10;

            Modulo moduloPai = ModuloFactory.CriarModuloFilho(SessionTest, modulo, "", true);

            moduloPai.NbEsforcoPlanejado = 50;
            Assert.AreEqual(modulo.NbEsforcoPlanejado, (UInt32)0);
        }
        public void SalvarRequisito()
        {
            Projeto projeto1 = ProjetoFactory.Criar(SessionTest, 0, "", true);
            Modulo  modulo1  = ModuloFactory.Criar(SessionTest, projeto1, "", true);

            /**
             * Cenário 1: Serão criados 2 requisitos para um projeto e o wex
             * deverá criar os IDs incrementados em sequencia.
             */

            Requisito requisito1 = RequisitoFactory.Criar(SessionTest, modulo1, "nome", "descricao", "link", true);

            Assert.AreEqual("RF_01.01", requisito1.TxID, "O ID do requisito deveria ser RF_01.01");

            requisito1 = RequisitoFactory.Criar(SessionTest, modulo1, "nome", "descricao", "link", true);

            Assert.AreEqual("RF_01.02", requisito1.TxID, "O ID do requisito deveria ser RF_01.02");
        }
        public static void DadoCiclo3DoProjetoProjeto01NaSituacaoConcluidoComAsEstorias(string ciclo, string projeto, string situacao, Table table)
        {
            string estoriaCol      = table.Header.ToList()[0];
            string situacaoCol     = table.Header.ToList()[1];
            string pontosCol       = table.Header.ToList()[2];
            string tipoCol         = table.Header.ToList()[3];
            string valorNegocioCol = table.Header.ToList()[4];

            Modulo modulo = ModuloFactory.Criar(SessionTest, ProjetosDic[projeto], string.Format("Módulo {0}", projeto), true);

            for (int position = 0; position < table.RowCount; position++)
            {
                string  estoriaRow      = table.Rows[position][estoriaCol];
                string  situacaoRow     = table.Rows[position][situacaoCol];
                string  pontosRow       = table.Rows[position][pontosCol];
                string  tipoRow         = table.Rows[position][tipoCol];
                string  valorNegocioRow = table.Rows[position][valorNegocioCol];
                Estoria estoria         = null;
                if (!StepEstoria.EstoriasDic.ContainsKey(estoriaRow))
                {
                    estoria           = EstoriaFactory.Criar(SessionTest, modulo, estoriaRow, "", "", BeneficiadoFactory.Criar(SessionTest, "bene 1" + estoriaRow, true), "", "", "", false);
                    estoria.NbTamanho = double.Parse(pontosRow);
                    StepEstoria.EstoriasDic.Add(estoriaRow, estoria);
                }
                else
                {
                    estoria = StepEstoria.EstoriasDic[estoriaRow];
                }
                PropertyInfo info = typeof(Estoria).GetProperty("CsTipo");
                info.SetValue(estoria, EnumUtil.ValueEnum(typeof(CsTipoEstoriaDomain), tipoRow), null);

                info = typeof(Estoria).GetProperty("CsValorNegocio");
                info.SetValue(estoria, EnumUtil.ValueEnum(typeof(CsValorNegocioDomain), valorNegocioRow), null);

                estoria.Save();

                CicloDesenvEstoria cicloDesenvEstoria = CicloDesenvEstoriaFactory.Criar(SessionTest, ProjetosDic[projeto].Ciclos[int.Parse(ciclo) - 1], estoria, false);
                info = typeof(CicloDesenvEstoria).GetProperty("CsSituacao");
                info.SetValue(cicloDesenvEstoria, EnumUtil.ValueEnum(typeof(CsSituacaoEstoriaCicloDomain), situacaoRow), null);
                cicloDesenvEstoria.Save();
            }
            DadoCiclo5DoProjetoProjeto01NaSituacaoNaoPlanejado(ciclo, projeto, situacao);
        }
        public void EditarModuloPai()
        {
            /**
             * Cenário 10: Será criado um módulo tendo um módulo pai e será salvo no sistema.
             * Em seguida será editado o módulo pai desse módulo e o sistema deverá mudar o ID do módulo de forma correta.
             */


            Projeto projeto1  = ProjetoFactory.Criar(SessionTest, 0, "", true);
            Modulo  modulo    = ModuloFactory.Criar(SessionTest, projeto1, "", true);
            Modulo  modulo2   = ModuloFactory.Criar(SessionTest, projeto1, "", true);
            Modulo  moduloPai = ModuloFactory.CriarModuloFilho(SessionTest, modulo, "", true);

            Assert.AreEqual("01.01", moduloPai.TxID, "O ID do módulo deveria ser 01.01");

            moduloPai = ModuloFactory.CriarModuloFilho(SessionTest, modulo2, "", true);

            Assert.AreEqual("02.01", moduloPai.TxID, "O ID do módulo deveria ser 02.01");
        }
        public void AdicionarAnexo()
        {
            /**
             * Cenário 1: Serão adicionados 3 anexos para uma pré-condição.
             * O sistema deverá informar quantos anexos estão adicionados no sistema.
             */

            Projeto              projeto1              = ProjetoFactory.Criar(SessionTest, 0, "", true);
            Modulo               modulo1               = ModuloFactory.Criar(SessionTest, projeto1, "", true);
            Requisito            requisito1            = RequisitoFactory.Criar(SessionTest, modulo1, "nome", "descricao", "link", true);
            CasoTeste            casoteste1            = CasoTesteFactory.Criar(SessionTest, requisito1, "passos", "sumário", "precondicoes", true);
            CasoTestePreCondicao casotestePreCondicao1 = CasoTestePreCondicaoFactory.Criar(SessionTest, casoteste1, "", true);

            CasoTestePreCondicaoAnexo casoTestePreCondicaoAnexo1 = CasoTestePreCondicaoAnexoFactory.Criar(SessionTest, casotestePreCondicao1, "", true);
            CasoTestePreCondicaoAnexo casoTestePreCondicaoAnexo2 = CasoTestePreCondicaoAnexoFactory.Criar(SessionTest, casotestePreCondicao1, "", true);
            CasoTestePreCondicaoAnexo casoTestePreCondicaoAnexo3 = CasoTestePreCondicaoAnexoFactory.Criar(SessionTest, casotestePreCondicao1, "", true);

            Assert.AreEqual(3, casotestePreCondicao1._NbAnexos, "O valor deveria ser 3");
        }
        public void GivenQueExistamOsSeguintesModulosParaOProjeto(string nomeProjeto, Table table)
        {
            Projeto projeto = ProjetoDao.Instancia.ConsultarProjetoPorNome(contexto, nomeProjeto);

            List <ModuloBindHelper> modulos = table.CreateSet <ModuloBindHelper>().ToList();

            for (int i = 0; i < modulos.Count; i++)
            {
                ModuloBindHelper bindHelper = modulos[i];
                if (string.IsNullOrWhiteSpace(bindHelper.ModuloPai))
                {
                    ModuloFactory.Criar(contexto, projeto, bindHelper.Nome, (uint)bindHelper.Tamanho);
                }
                else
                {
                    ModuloFactory.CriarModuloFilho(contexto, ModuloDAO.ConsultarModuloPorNome(contexto, bindHelper.ModuloPai), bindHelper);
                }
            }
        }