public void Test_Efi_13132()
{
/*
* Quando esse calendario é usado, o framework não faz a busca da data mais proxima, pois os campos são ambos inteiros;
* Para corrigir foi criada uma propriedade booleana que verifica se a data é permitida ou não
*/
//tentar cadastrar o dia 30/02
Calendario calendario = CalendarioFactory.CriarCalendarioPorDiaMes(SessionTest,
CsCalendarioDomain.Folga, 30, CsMesDomain.Fevereiro);
Assert.AreEqual(ValidationState.Invalid, ValidationUtil.GetRuleState(calendario,
"PlanCalendarioCoorp_NbDia_Validacao", DefaultContexts.Save));
//tentar -3/11
calendario = CalendarioFactory.CriarCalendarioPorDiaMes(SessionTest,
CsCalendarioDomain.Folga, -3, CsMesDomain.Novembro);
Assert.AreEqual(ValidationState.Invalid, ValidationUtil.GetRuleState(calendario,
"PlanCalendarioCoorp_NbDia_Validacao", DefaultContexts.Save));
//tentar 31/09 - data inválida
calendario = CalendarioFactory.CriarCalendarioPorDiaMes(SessionTest,
CsCalendarioDomain.Folga, 31, CsMesDomain.Setembro);
Assert.AreEqual(ValidationState.Invalid, ValidationUtil.GetRuleState(calendario,
"PlanCalendarioCoorp_NbDia_Validacao", DefaultContexts.Save));
//data válida - 29/01
calendario = CalendarioFactory.CriarCalendarioPorDiaMes(SessionTest,
CsCalendarioDomain.Trabalho, 29, CsMesDomain.Janeiro);
Assert.AreEqual(ValidationState.Valid, ValidationUtil.GetRuleState(calendario,
"PlanCalendarioCoorp_NbDia_Validacao", 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));
}
public void MetodoTestaSalvarModuloSemProjeto()
{
Modulo modulo1 = ModuloFactory.Criar(SessionTest, null, "", true);
Assert.AreEqual(ValidationState.Invalid, ValidationUtil.GetRuleState(modulo1,
"NaoPermitirSalvarModuloSeNaoTiverProjetoSelecionado", DefaultContexts.Save));
}
public void ConfiguracaoTest_002_TestarInserirQuantidadeMaximaDeFeriasComValorZero()
{
Configuracao configuracao = ConfiguracaoFactory.CriarConfiguracao(SessionTest, 10, 0, 12, false);
Assert.AreEqual(ValidationState.Invalid, ValidationUtil.GetRuleState(configuracao,
"Qtde máxima de férias", DefaultContexts.Save));
}
public void QuandoTentarExcluirOPaisPais01(string pais)
{
ValidationState state = ValidationUtil.GetRuleState(PaisesDict[pais],
"RuleIsReferenced_EmpresaInstituicaoPais", DefaultContexts.Delete);
MensagemPaisesDict.Add(pais, state);
}
public void ModalidadeFeriasTest_TestarCadastrarQuantidadeDiasMaiorValorMaximoDiasPodeVenderFerias()
{
ConfiguracaoFactory.CriarConfiguracao(SessionTest, 10, 30, 12);
ModalidadeFerias modalidade = ModalidadeFeriasFactory.CriarModalidadeFerias(
SessionTest, 11, true, CsSituacao.Inativo, false);
Assert.AreEqual(ValidationState.Invalid, ValidationUtil.GetRuleState(modalidade,
"ModalidadeFerias_RnVerificarDiasMaxVendaFerias", DefaultContexts.Save));
}
public void ConfiguracaoTest_004_TestarAlterarQuantidadeMaximoDiasFeriasConfiguracao()
{
Configuracao config = ConfiguracaoFactory.CriarConfiguracao(SessionTest, 10, 30, 12);
ModalidadeFeriasFactory.CriarModalidadeFerias(SessionTest, 8, true, CsSituacao.Ativo);
ModalidadeFeriasFactory.CriarModalidadeFerias(SessionTest, 6, false, CsSituacao.Ativo);
config.NbQtdeMaxFerias = 7;
Assert.AreEqual(ValidationState.Invalid, ValidationUtil.GetRuleState(config,
"Configuracao_RnVerificarDiasMaxFerias", DefaultContexts.Save));
}
public void MootivoCancelamentoTxDescricaoUnicos()
{
MotivoCancelamento modalidade = MotivoCancelamentoFactory.CriarMotivoCancelamento(
SessionTest, "modalidade1", CsStatusMotivoCancelamento.Ativo, true);
Assert.AreEqual(ValidationState.Valid, ValidationUtil.GetRuleState(modalidade,
"MotivoCancelamento_TxDescricao_Unique", DefaultContexts.Save));
MotivoCancelamento modalidade1 = MotivoCancelamentoFactory.CriarMotivoCancelamento(
SessionTest, "modalidade1", CsStatusMotivoCancelamento.Ativo, true);
Assert.AreEqual(ValidationState.Invalid, ValidationUtil.GetRuleState(modalidade1,
"MotivoCancelamento_TxDescricao_Unique", DefaultContexts.Save));
}
public void SalvarProjetoComDuracaoDeCiclosMenorQue10()
{
/**
* Cenário 3: Será criado um projeto A. Será informado que a duração de um ciclo (9).
* O sistema deverá retornar inválida a tentativa de salvar o projeto
*/
Projeto projetoA = ProjetoFactory.Criar(SessionTest, 300, "", true);
projetoA.NbCicloDuracaoDiasPlan = 0;
projetoA.Save();
Assert.AreEqual(ValidationState.Invalid, ValidationUtil.GetRuleState(projetoA,
"ValidarDuracaoCiclos", DefaultContexts.Save));
}
public void SalvarProjetoComNumeroDeCiclosMenorQue2()
{
/**
* Cenário 2: Será criado um projeto A. Será informado que a quantidade de ciclos do projeto será de 1.
* O sistema deverá retornar inválida a tentativa de salvar o projeto
*/
Projeto projetoA = ProjetoFactory.Criar(SessionTest, 300, "", true);
projetoA.NbCicloTotalPlan = 0;
projetoA.Save();
Assert.AreEqual(ValidationState.Invalid, ValidationUtil.GetRuleState(projetoA,
"ValidarNumeroCiclos", DefaultContexts.Save));
}
public void SalvarProjetoComDtTerminoMaiorQueDtInicio()
{
/**
* Cenário 1: Será criado um projeto A. Serão setadas as datas de inicio e fim do projeto.
* A data final não pode ser menor que a data inicial.
*/
Projeto projetoA = ProjetoFactory.Criar(SessionTest, 300, "", true);
projetoA.DtInicioPlan = new DateTime(2011, 02, 25);
projetoA.DtTerminoPlan = new DateTime(2011, 02, 26);
projetoA.Save();
Assert.AreEqual(ValidationState.Valid, ValidationUtil.GetRuleState(projetoA,
"NaoPermitirSalvarDtInicioMenorDtTermino", DefaultContexts.Save));
}
/// <summary>
/// Gerador de descrição
/// </summary>
private void GerarDescricaoTipoAfastamento()
{
int valornum = 2;
string valorbase = TxDescricao;
ValidationState state = ValidationUtil.GetRuleState(this,
"TipoAfastamento_TxDescricao_Unique", DefaultContexts.Save);
while (state == ValidationState.Invalid)
{
TxDescricao = string.Format("{0} {1}", valorbase, valornum);
valornum++;
state = ValidationUtil.GetRuleState(this,
"TipoAfastamento_TxDescricao_Unique", DefaultContexts.Save);
}
}
public void Test_eFi_Crono34()
{
CalendarioFactory.CriarCalendarioPorPeriodo(SessionTest, CsCalendarioDomain.Folga,
new DateTime(2010, 11, 15), new DateTime(2010, 11, 20), true);
Calendario calendario02 = CalendarioFactory.CriarCalendarioPorPeriodo(SessionTest,
CsCalendarioDomain.Folga, new DateTime(2010, 11, 10), new DateTime(2010, 11, 14));
Assert.AreEqual(ValidationState.Valid, ValidationUtil.GetRuleState(calendario02,
"CalendarioConflitante", DefaultContexts.Save));
Calendario calendario03 = CalendarioFactory.CriarCalendarioPorPeriodo(
SessionTest, CsCalendarioDomain.Trabalho, new DateTime(2010, 11, 21),
new DateTime(2010, 11, 22));
Assert.AreEqual(ValidationState.Valid, ValidationUtil.GetRuleState(calendario03,
"CalendarioConflitante", DefaultContexts.Save));
}
public void Test_eFi_Crono35()
{
const string RESTRICAO = "CalendarioConflitante";
Calendario calendario = CalendarioFactory.CriarCalendarioPorPeriodo(SessionTest, CsCalendarioDomain.Folga,
new DateTime(2010, 11, 15), new DateTime(2010, 11, 20));
calendario.CsSituacao = CsSituacaoDomain.Inativo;
calendario.Save();
calendario = CalendarioFactory.CriarCalendarioPorPeriodo(SessionTest,
CsCalendarioDomain.Folga, new DateTime(2010, 11, 15), new DateTime(2010, 11, 16));
Assert.AreEqual(ValidationState.Valid, ValidationUtil.GetRuleState(calendario,
RESTRICAO, DefaultContexts.Save));
calendario = CalendarioFactory.CriarCalendarioPorPeriodo(SessionTest,
CsCalendarioDomain.Trabalho, new DateTime(2010, 11, 20), new DateTime(2010, 11, 25));
Assert.AreEqual(ValidationState.Valid, ValidationUtil.GetRuleState(calendario,
RESTRICAO, DefaultContexts.Save));
calendario = CalendarioFactory.CriarCalendarioPorPeriodo(SessionTest,
CsCalendarioDomain.Trabalho, new DateTime(2010, 11, 16), new DateTime(2010, 11, 19));
Assert.AreEqual(ValidationState.Valid, ValidationUtil.GetRuleState(calendario,
RESTRICAO, DefaultContexts.Save));
calendario = CalendarioFactory.CriarCalendarioPorPeriodo(SessionTest,
CsCalendarioDomain.Trabalho, new DateTime(2010, 11, 14), new DateTime(2010, 11, 21));
Assert.AreEqual(ValidationState.Valid, ValidationUtil.GetRuleState(calendario,
RESTRICAO, DefaultContexts.Save));
calendario = CalendarioFactory.CriarCalendarioPorPeriodo(SessionTest,
CsCalendarioDomain.Trabalho, new DateTime(2010, 11, 15), new DateTime(2010, 11, 20));
Assert.AreEqual(ValidationState.Valid, ValidationUtil.GetRuleState(calendario,
RESTRICAO, DefaultContexts.Save));
}
public void SalvarModuloComEsforcoAcimaDe100()
{
/**
* Cenário 9: Será criado um projeto A. Em seguida serão criados 2 modulos: O Modulo A e o B.
* O Modulo A terá um esforço de 50% e o Modulo B terá um esforço de 51%.
* O sistema não poderá permitir que os modulos sejam salvos até que a somatória dos esforços seja <= 100.
*/
Projeto projeto1 = ProjetoFactory.Criar(SessionTest, 300, "", true);
Modulo moduloA = ModuloFactory.Criar(SessionTest, projeto1, "", true);
moduloA.NbEsforcoPlanejado = 50;
moduloA.Save();
Modulo moduloB = ModuloFactory.Criar(SessionTest, projeto1, "", true);
moduloB.NbEsforcoPlanejado = 51;
moduloB.Save();
Assert.AreEqual(ValidationState.Invalid, ValidationUtil.GetRuleState(moduloB,
"NaoPermitirSalvarSeOsModulosDoProjetoTiveremASomaDosEsforcosMaiorQue100", DefaultContexts.Save));
}
public void TesteAlterarSituacaoDoCiclo()
{
/**
* Cenário 8: Será criado um ciclo e associadas Estórias para ele.
* A situação do ciclo será alterada e a situação das associações deverá mudar de acordo ou impedir a mudança
*/
//Passo1
Projeto projeto01 = ProjetoFactory.Criar(SessionTest, 100, "");
projeto01.DtInicioPlan = new DateTime(2011, 04, 25);
projeto01.DtInicioReal = new DateTime(2011, 04, 25);
projeto01.NbCicloTotalPlan = 5;
projeto01.NbCicloDuracaoDiasPlan = 10;
projeto01.NbCicloDiasIntervalo = 1;
projeto01.Save();
ProjetoParteInteressada parteInteressada01 = ProjetoParteInteressadaFactory.Criar(SessionTest, projeto01, true);
Assert.AreEqual(CsSituacaoCicloDomain.NaoPlanejado, projeto01.Ciclos[0].CsSituacaoCiclo, "A situação do ciclo deveria ser 'Não Planejado'");
Assert.AreEqual(CsSituacaoCicloDomain.NaoPlanejado, projeto01.Ciclos[1].CsSituacaoCiclo, "A situação do ciclo deveria ser 'Não Planejado'");
Assert.AreEqual(CsSituacaoCicloDomain.NaoPlanejado, projeto01.Ciclos[2].CsSituacaoCiclo, "A situação do ciclo deveria ser 'Não Planejado'");
Assert.AreEqual(CsSituacaoCicloDomain.NaoPlanejado, projeto01.Ciclos[3].CsSituacaoCiclo, "A situação do ciclo deveria ser 'Não Planejado'");
Assert.AreEqual(CsSituacaoCicloDomain.NaoPlanejado, projeto01.Ciclos[4].CsSituacaoCiclo, "A situação do ciclo deveria ser 'Não Planejado'");
//Passo 2
Modulo modulo01 = ModuloFactory.Criar(SessionTest, projeto01, "", false);
modulo01.NbEsforcoPlanejado = 100;
modulo01.Save();
Beneficiado beneficiado01 = BeneficiadoFactory.Criar(SessionTest, "", true);
Projeto.SelectedProject = projeto01.Oid;
Estoria estoria01 = EstoriaFactory.Criar(SessionTest, modulo01, "Titulo1", "GostariaDe", "EntaoPoderei", beneficiado01, "Observacoes", "Referencias", "Duvidas");
estoria01.CsSituacao = CsEstoriaDomain.NaoIniciado;
//estoria01.NbPrioridade = 1;
estoria01.Save();
Estoria estoria02 = EstoriaFactory.Criar(SessionTest, modulo01, "Titulo2", "GostariaDe", "EntaoPoderei", beneficiado01, "Observacoes", "Referencias", "Duvidas");
estoria02.CsSituacao = CsEstoriaDomain.NaoIniciado;
//estoria02.NbPrioridade = 2;
estoria02.Save();
Estoria estoria03 = EstoriaFactory.Criar(SessionTest, modulo01, "Titulo3", "GostariaDe", "EntaoPoderei", beneficiado01, "Observacoes", "Referencias", "Duvidas");
estoria03.CsSituacao = CsEstoriaDomain.NaoIniciado;
//estoria03.NbPrioridade = 3;
estoria03.Save();
Estoria estoria04 = EstoriaFactory.Criar(SessionTest, modulo01, "Titulo4", "GostariaDe", "EntaoPoderei", beneficiado01, "Observacoes", "Referencias", "Duvidas");
estoria04.CsSituacao = CsEstoriaDomain.NaoIniciado;
//estoria04.NbPrioridade = 4;
estoria04.Save();
Estoria estoria05 = EstoriaFactory.Criar(SessionTest, modulo01, "Titulo5", "GostariaDe", "EntaoPoderei", beneficiado01, "Observacoes", "Referencias", "Duvidas");
estoria05.CsSituacao = CsEstoriaDomain.NaoIniciado;
//estoria05.NbPrioridade = 5;
estoria05.Save();
CicloDesenvEstoria cicloEstoriaDesenv01 = CicloDesenvEstoriaFactory.Criar(SessionTest, projeto01.Ciclos[0], estoria01, true);
CicloDesenvEstoria cicloEstoriaDesenv02 = CicloDesenvEstoriaFactory.Criar(SessionTest, projeto01.Ciclos[0], estoria02, true);
CicloDesenvEstoria cicloEstoriaDesenv03 = CicloDesenvEstoriaFactory.Criar(SessionTest, projeto01.Ciclos[0], estoria03, true);
CicloDesenvEstoria cicloEstoriaDesenv04 = CicloDesenvEstoriaFactory.Criar(SessionTest, projeto01.Ciclos[0], estoria04, true);
projeto01.Ciclos[0].Save();
Assert.AreEqual(CsSituacaoCicloDomain.Planejado, projeto01.Ciclos[0].CsSituacaoCiclo, "A situação do ciclo deveria ser 'Planejado'");
Assert.AreEqual(CsSituacaoCicloDomain.NaoPlanejado, projeto01.Ciclos[1].CsSituacaoCiclo, "A situação do ciclo deveria ser 'Não Planejado'");
Assert.AreEqual(CsSituacaoCicloDomain.NaoPlanejado, projeto01.Ciclos[2].CsSituacaoCiclo, "A situação do ciclo deveria ser 'Não Planejado'");
Assert.AreEqual(CsSituacaoCicloDomain.NaoPlanejado, projeto01.Ciclos[3].CsSituacaoCiclo, "A situação do ciclo deveria ser 'Não Planejado'");
Assert.AreEqual(CsSituacaoCicloDomain.NaoPlanejado, projeto01.Ciclos[4].CsSituacaoCiclo, "A situação do ciclo deveria ser 'Não Planejado'");
Assert.AreEqual(0, estoria01.NbPrioridade, "A prioridade da Estória deveria ser 0");
Assert.AreEqual(0, estoria02.NbPrioridade, "A prioridade da Estória deveria ser 0");
Assert.AreEqual(0, estoria03.NbPrioridade, "A prioridade da Estória deveria ser 0");
Assert.AreEqual(0, estoria04.NbPrioridade, "A prioridade da Estória deveria ser 0");
Assert.AreEqual(1, estoria05.NbPrioridade, "A prioridade da Estória deveria ser 1");
//Passo 03
cicloEstoriaDesenv01.CsSituacao = CsSituacaoEstoriaCicloDomain.EmDesenv;
cicloEstoriaDesenv01.Save();
cicloEstoriaDesenv02.CsSituacao = CsSituacaoEstoriaCicloDomain.NaoIniciado;
cicloEstoriaDesenv02.Save();
cicloEstoriaDesenv03.CsSituacao = CsSituacaoEstoriaCicloDomain.NaoIniciado;
cicloEstoriaDesenv03.Save();
cicloEstoriaDesenv04.CsSituacao = CsSituacaoEstoriaCicloDomain.NaoIniciado;
cicloEstoriaDesenv04.Save();
projeto01.Ciclos[0].CsSituacaoCiclo = CsSituacaoCicloDomain.Concluido;
projeto01.Ciclos[0].Save();
Assert.AreEqual(CsSituacaoEstoriaCicloDomain.Pronto, cicloEstoriaDesenv01.CsSituacao, "A situação do item do ciclo deveria ser 'Pronto'");
Assert.AreEqual(CsSituacaoEstoriaCicloDomain.Replanejado, cicloEstoriaDesenv02.CsSituacao, "A situação do item do ciclo deveria ser 'Replanejado'");
Assert.AreEqual(CsSituacaoEstoriaCicloDomain.Replanejado, cicloEstoriaDesenv03.CsSituacao, "A situação do item do ciclo deveria ser 'Replanejado'");
Assert.AreEqual(CsSituacaoEstoriaCicloDomain.Replanejado, cicloEstoriaDesenv04.CsSituacao, "A situação do item do ciclo deveria ser 'Replanejado'");
//Assert.AreEqual(1, estoria02.NbPrioridade, "A prioridade deveria ser 1");
//Assert.AreEqual(2, estoria03.NbPrioridade, "A prioridade deveria ser 2");
//Assert.AreEqual(3, estoria04.NbPrioridade, "A prioridade deveria ser 3");
//Assert.AreEqual(4, estoria05.NbPrioridade, "A prioridade deveria ser 4");
//Passo 4
//Sem RN
//Passo 5
cicloEstoriaDesenv02 = CicloDesenvEstoriaFactory.Criar(SessionTest, projeto01.Ciclos[1], estoria02, true);
cicloEstoriaDesenv03 = CicloDesenvEstoriaFactory.Criar(SessionTest, projeto01.Ciclos[1], estoria03, true);
cicloEstoriaDesenv04 = CicloDesenvEstoriaFactory.Criar(SessionTest, projeto01.Ciclos[1], estoria04, true);
cicloEstoriaDesenv02.CsSituacao = CsSituacaoEstoriaCicloDomain.EmDesenv;
cicloEstoriaDesenv02.Save();
cicloEstoriaDesenv03.CsSituacao = CsSituacaoEstoriaCicloDomain.NaoIniciado;
cicloEstoriaDesenv03.Save();
cicloEstoriaDesenv04.CsSituacao = CsSituacaoEstoriaCicloDomain.Pronto;
cicloEstoriaDesenv04.Save();
projeto01.Ciclos[1].CsSituacaoCiclo = CsSituacaoCicloDomain.Cancelado;
projeto01.Ciclos[1].Save();
Assert.AreEqual(CsSituacaoEstoriaCicloDomain.Replanejado, cicloEstoriaDesenv02.CsSituacao, "A Situação deveria ser 'Replanejado'");
Assert.AreEqual(CsSituacaoEstoriaCicloDomain.Replanejado, cicloEstoriaDesenv03.CsSituacao, "A Situação deveria ser 'Replanejado'");
Assert.AreEqual(CsSituacaoEstoriaCicloDomain.Pronto, cicloEstoriaDesenv04.CsSituacao, "A Situação deveria ser 'Pronto'");
//Passo 6
cicloEstoriaDesenv02 = CicloDesenvEstoriaFactory.Criar(SessionTest, projeto01.Ciclos[2], estoria02, true);
cicloEstoriaDesenv03 = CicloDesenvEstoriaFactory.Criar(SessionTest, projeto01.Ciclos[2], estoria03, true);
cicloEstoriaDesenv02.CsSituacao = CsSituacaoEstoriaCicloDomain.NaoIniciado;
cicloEstoriaDesenv02.Save();
cicloEstoriaDesenv03.CsSituacao = CsSituacaoEstoriaCicloDomain.EmDesenv;
cicloEstoriaDesenv03.Save();
projeto01.Ciclos[2].CsSituacaoCiclo = CsSituacaoCicloDomain.Planejado;
projeto01.Ciclos[2].Save();
Assert.AreEqual(CsSituacaoEstoriaCicloDomain.NaoIniciado, cicloEstoriaDesenv02.CsSituacao, "A Situação deveria ser 'Não Iniciado'");
Assert.AreEqual(CsSituacaoEstoriaCicloDomain.EmDesenv, cicloEstoriaDesenv03.CsSituacao, "A Situação deveria ser 'Não Iniciado'");
//Passo 7
projeto01.Ciclos[2].CsSituacaoCiclo = CsSituacaoCicloDomain.NaoPlanejado;
projeto01.Ciclos[2].Save();
Assert.AreEqual(ValidationState.Valid, ValidationUtil.GetRuleState(projeto01.Ciclos[2],
"ValidarCicloSemAssociacoes", DefaultContexts.Save));
}
public void TestarAlterarAsConfiguracoesDoProjetoQueJaPossuiCiclosConcluidos()
{
/**
* Cenário 9: Será testado alterar as configurações de um projeto que ja possua ciclos concluídos
* O sistema deverá proceder de forma correta
*/
Projeto projeto01 = ProjetoFactory.Criar(SessionTest, 100, "");
projeto01.DtInicioPlan = new DateTime(2011, 04, 25);
projeto01.DtInicioReal = new DateTime(2011, 04, 25);
projeto01.NbCicloTotalPlan = 5;
projeto01.NbCicloDuracaoDiasPlan = 10;
projeto01.NbCicloDiasIntervalo = 1;
projeto01.Save();
Assert.AreEqual(new DateTime(2011, 04, 25), projeto01.Ciclos[0].DtInicio, "A data de inicio do Ciclo 1 deveria ser 25/05/2011");
Assert.AreEqual(new DateTime(2011, 05, 06), projeto01.Ciclos[0].DtTermino, "A data de inicio do Ciclo 1 deveria ser 06/05/2011");
Assert.AreEqual(new DateTime(2011, 05, 10), projeto01.Ciclos[1].DtInicio, "A data de inicio do projeto deveria ser 10/05/2011");
Assert.AreEqual(new DateTime(2011, 05, 23), projeto01.Ciclos[1].DtTermino, "A data de inicio do projeto deveria ser 23/05/2011");
Modulo modulo01 = ModuloFactory.Criar(SessionTest, projeto01, "Nome", true);
Beneficiado beneficiado01 = BeneficiadoFactory.Criar(SessionTest, "Descricao", true);
Estoria estoria01 = EstoriaFactory.Criar(SessionTest, modulo01, "Titulo", "GostariaDe", "EntaoPoderei", beneficiado01, "Observacoes", "Referencias", "Duvidas", true);
Estoria estoria02 = EstoriaFactory.Criar(SessionTest, modulo01, "Titulo", "GostariaDe", "EntaoPoderei", beneficiado01, "Observacoes", "Referencias", "Duvidas", true);
Estoria estoria03 = EstoriaFactory.Criar(SessionTest, modulo01, "Titulo", "GostariaDe", "EntaoPoderei", beneficiado01, "Observacoes", "Referencias", "Duvidas", true);
CicloDesenvEstoria cicloDesenvEstoria01 = CicloDesenvEstoriaFactory.Criar(SessionTest, projeto01.Ciclos[0], estoria01);
cicloDesenvEstoria01.CsSituacao = CsSituacaoEstoriaCicloDomain.Pronto;
cicloDesenvEstoria01.Save();
CicloDesenvEstoria cicloDesenvEstoria02 = CicloDesenvEstoriaFactory.Criar(SessionTest, projeto01.Ciclos[1], estoria02);
cicloDesenvEstoria02.CsSituacao = CsSituacaoEstoriaCicloDomain.Pronto;
cicloDesenvEstoria02.Save();
CicloDesenvEstoria cicloDesenvEstoria03 = CicloDesenvEstoriaFactory.Criar(SessionTest, projeto01.Ciclos[2], estoria03);
cicloDesenvEstoria03.CsSituacao = CsSituacaoEstoriaCicloDomain.NaoIniciado;
cicloDesenvEstoria03.Save();
//Passo 1
projeto01.Ciclos[0].CsSituacaoCiclo = CsSituacaoCicloDomain.Concluido;
projeto01.Ciclos[0].Save();
projeto01.Ciclos[1].CsSituacaoCiclo = CsSituacaoCicloDomain.Concluido;
projeto01.Ciclos[1].Save();
projeto01.Ciclos[2].CsSituacaoCiclo = CsSituacaoCicloDomain.Planejado;
projeto01.Ciclos[2].Save();
projeto01.NbCicloDuracaoDiasPlan = 5;
projeto01.NbCicloDiasIntervalo = 2;
projeto01.Save();
Assert.AreEqual(new DateTime(2011, 04, 25), projeto01.Ciclos[0].DtInicio, "A data de inicio do Ciclo 1 deveria ser 25/05/2011");
Assert.AreEqual(new DateTime(2011, 05, 06), projeto01.Ciclos[0].DtTermino, "A data de inicio do Ciclo 1 deveria ser 06/05/2011");
Assert.AreEqual(new DateTime(2011, 05, 10), projeto01.Ciclos[1].DtInicio, "A data de inicio do projeto deveria ser 10/05/2011");
Assert.AreEqual(new DateTime(2011, 05, 23), projeto01.Ciclos[1].DtTermino, "A data de inicio do projeto deveria ser 23/05/2011");
Assert.AreEqual(new DateTime(2011, 05, 26), projeto01.Ciclos[2].DtInicio, "A data de inicio do projeto deveria ser 26/05/2011");
Assert.AreEqual(new DateTime(2011, 06, 01), projeto01.Ciclos[2].DtTermino, "A data de inicio do projeto deveria ser 25/05/2011");
//Passo 2
cicloDesenvEstoria03.CsSituacao = CsSituacaoEstoriaCicloDomain.Pronto;
cicloDesenvEstoria03.Save();
projeto01.Ciclos[2].Save();
projeto01.NbCicloTotalPlan = 1;
projeto01.Save();
Assert.AreEqual(ValidationState.Invalid, ValidationUtil.GetRuleState(projeto01,
"ValidarPermitirDeletarCiclos", DefaultContexts.Save));
//Passo 3
projeto01.NbCicloTotalPlan = 2;
projeto01.Save();
Assert.AreEqual(ValidationState.Invalid, ValidationUtil.GetRuleState(projeto01,
"ValidarPermitirDeletarCiclos", DefaultContexts.Save));
}
public void SolicitacaoOrcamentoTest_001()
{
#region Passo 1
DateTime dtPrazo = DateTime.Now.AddDays(1);
string emailCliente = "*****@*****.**";
// Colaborador
Colaborador colaborador = ColaboradorFactory.CriarColaborador(SessionTest, "000", DateTime.Now,
"*****@*****.**", "Solicitacao", "Orcamento", "Historico", "nome.completo");
// Situações
ConfiguracaoDocumentoSituacao situacaoNaoIniciado = ConfiguracaoDocumentoSituacaoFactory.CriarConfiguracaoDocumentoSituacao(
SessionTest, "Não Iniciado", "Green", CsColorDomain.System, true);
ConfiguracaoDocumentoSituacao situacaoEmAndamento = ConfiguracaoDocumentoSituacaoFactory.CriarConfiguracaoDocumentoSituacao(
SessionTest, "Em Andamento", "Red", CsColorDomain.System, true);
ConfiguracaoDocumentoSituacao situacaoConcluido = ConfiguracaoDocumentoSituacaoFactory.CriarConfiguracaoDocumentoSituacao(
SessionTest, "Concluído", "Blue", CsColorDomain.System, true);
// Cliente
EmpresaInstituicao cliente = EmpresaInstituicaoFactory.Criar(SessionTest, "Novo Cliente", "FPF",
emailCliente, "0000-0000", true);
// Solicitação de Orçamento
SolicitacaoOrcamento solicitacao = SolicitacaoOrcamentoFactory.CriarSolicitacaoOrcamento(SessionTest, colaborador,
situacaoNaoIniciado, CsPrioridade.Alta, "Teste1", dtPrazo, cliente);
solicitacao.Reload();
// Dados do cliente
Assert.AreEqual(cliente.TxNome, solicitacao.TxContatoCliente,
"O nome do cliente deveria ser o mesmo contato na Solicitação de Orçamento");
Assert.AreEqual(cliente.TxEmail, solicitacao.TxEmailContatoCliente,
"O email do cliente deveria ser o mesmo email do contato na Solicitação de Orçamento");
Assert.AreEqual(cliente.TxFoneFax, solicitacao.TxFone,
"O fone do cliente deveria ser o mesmo fone do contato na Solicitação de Orçamento");
// Emails
Assert.AreEqual(string.Empty, solicitacao.TxCc,
"A quantidade de emails para envio com cópia deveria ser 0, pois nenhum email foi cadastrado.");
Assert.AreEqual(string.Empty, solicitacao.TxCco,
"A quantidade de emails para envio com cópia oculta deveria ser 0, pois nenhum email foi cadastrado.");
#endregion
#region Passo 2
solicitacao.TxCc = "*****@*****.**"; // Adicionando email para envio
solicitacao.Save(); // Persistindo
// Verificação de envio de email
Assert.AreEqual(true, solicitacao._EmailEnviado,
"O email deveria ter sido enviado");
// Verificação das datas
Assert.AreEqual(solicitacao.DtEmissao.Date, solicitacao.DtConclusao.Date,
"A data de emissão deveria ser a mesma de conclusão");
// Verificação do código gerado
Assert.AreEqual("FPF.01/2012", solicitacao.TxCodigo,
"O código deveria estar de acordo com o padrão");
// Verificação da quantidade de dias gastos
Assert.AreEqual(1, solicitacao._DiasGastos,
"A quantidade de dias gastos deveria ser 1.");
#endregion
#region Passo 3
// Data prazo inválida
solicitacao.DtPrazo = DateTime.Now.AddDays(-1);
Assert.AreEqual(ValidationState.Valid, ValidationUtil.GetRuleState(solicitacao,
"ValidarDtPrazo", DefaultContexts.Save));
solicitacao.DtPrazo = dtPrazo; // Retornando à data anterior
#endregion
#region Passo 4
// Email inválido
solicitacao.TxEmailContatoCliente = "email";
Assert.AreEqual(ValidationState.Invalid, ValidationUtil.GetRuleState(solicitacao,
"ValidarEmailContatoCliente", DefaultContexts.Save));
solicitacao.TxEmailContatoCliente = emailCliente; // Retornando ao email anterior
#endregion
#region Passo 5
// Alteração dos dados do cliente
solicitacao.TxContatoCliente = "New Client";
solicitacao.TxEmailContatoCliente = "*****@*****.**";
solicitacao.TxFone = "1111-1111";
solicitacao.Save();
Assert.AreEqual("New Client", cliente.TxNome,
"O nome deveria ter mudado no objeto de EmpresaInstituicao");
Assert.AreEqual("*****@*****.**", cliente.TxEmail,
"O email deveria ter mudado no objeto de EmpresaInstituicao");
Assert.AreEqual("1111-1111", cliente.TxFoneFax,
"O fone/fax deveria ter mudado no objeto de EmpresaInstituicao");
#endregion
#region Passo 6
// [email protected] - Cc
ConfiguracaoDocumentoSituacaoEmailCc emailCcNaoIniciado =
ConfiguracaoDocumentoSituacaoEmailFactory.CriarEmailCc(SessionTest, "*****@*****.**",
situacaoNaoIniciado, true);
// [email protected] - Cco
ConfiguracaoDocumentoSituacaoEmailCco emailCcoNaoIniciado =
ConfiguracaoDocumentoSituacaoEmailFactory.CriarEmailCco(SessionTest, "*****@*****.**",
situacaoNaoIniciado, true);
// [email protected] - Cc
ConfiguracaoDocumentoSituacaoEmailCc emailCcEmAndamento =
ConfiguracaoDocumentoSituacaoEmailFactory.CriarEmailCc(SessionTest, "*****@*****.**",
situacaoEmAndamento, true);
// [email protected] - Cco
ConfiguracaoDocumentoSituacaoEmailCco emailCcoEmAndamento =
ConfiguracaoDocumentoSituacaoEmailFactory.CriarEmailCco(SessionTest, "*****@*****.**",
situacaoEmAndamento, true);
// [email protected] - Cc
ConfiguracaoDocumentoSituacaoEmailCc emailCcConcluido =
ConfiguracaoDocumentoSituacaoEmailFactory.CriarEmailCc(SessionTest, "*****@*****.**",
situacaoConcluido, true);
// [email protected] - Cco
ConfiguracaoDocumentoSituacaoEmailCco emailCcoConcluido =
ConfiguracaoDocumentoSituacaoEmailFactory.CriarEmailCco(SessionTest, "*****@*****.**",
situacaoConcluido, true);
situacaoNaoIniciado.ComCopia.Add(emailCcNaoIniciado);
situacaoNaoIniciado.ComCopiaOculta.Add(emailCcoNaoIniciado);
situacaoEmAndamento.ComCopia.Add(emailCcEmAndamento);
situacaoEmAndamento.ComCopiaOculta.Add(emailCcoEmAndamento);
situacaoConcluido.ComCopia.Add(emailCcConcluido);
situacaoConcluido.ComCopiaOculta.Add(emailCcoConcluido);
solicitacao.Situacao = situacaoEmAndamento; // Simular troca de situação
solicitacao.Situacao = situacaoNaoIniciado; // Selecionando a situação "Não Iniciado"
// Com Cópia
Assert.AreEqual(1, solicitacao.TxCc.Split(';').Length, "Deveria ter sido carregado apenas 1 email");
// Com Cópia Oculta
Assert.AreEqual(string.Empty, solicitacao.TxCco, "Deveria ter sido carregado nenhum email");
#endregion
#region Passo 7
solicitacao.Situacao = situacaoEmAndamento; // Selecionando a situação "Em Andamento"
// Com Cópia
/* Assert.AreEqual(1, solicitacao.ComCopia.Count, "Deveria ter sido carregado apenas 1 email");
* Assert.AreEqual(situacaoEmAndamento.ComCopia[0].TxEmail, solicitacao.ComCopia[0].TxEmail,
* "O email carregado deveria ser o mesmo email da situação");
*
* // Com Cópia Oculta
* Assert.AreEqual(1, solicitacao.ComCopiaOculta.Count, "Deveria ter sido carregado apenas 1 email");
* Assert.AreEqual(situacaoEmAndamento.ComCopiaOculta[0].TxEmail, solicitacao.ComCopiaOculta[0].TxEmail,
* "O email carregado deveria ser o mesmo email da situação");
*
#endregion
*
#region Passo 8
*
* solicitacao.Situacao = situacaoConcluido; // Selecionando a situação "Concluído"
*
* // Com Cópia
* Assert.AreEqual(1, solicitacao.ComCopia.Count, "Deveria ter sido carregado apenas 1 email");
* Assert.AreEqual(situacaoConcluido.ComCopia[0].TxEmail, solicitacao.ComCopia[0].TxEmail,
* "O email carregado deveria ser o mesmo email da situação");
*
* // Com Cópia Oculta
* Assert.AreEqual(1, solicitacao.ComCopiaOculta.Count, "Deveria ter sido carregado apenas 1 email");
* Assert.AreEqual(situacaoConcluido.ComCopiaOculta[0].TxEmail, solicitacao.ComCopiaOculta[0].TxEmail,
* "O email carregado deveria ser o mesmo email da situação");
*
* // Persistindo
* solicitacao.Save();
*
* // Verificação de envio de email
* Assert.AreEqual(true, solicitacao._EmailEnviado,
* "O email deveria ter sido enviado");
*
#endregion
*
#region Passo 9
*
* // Solicitação de Orçamento nova
* SolicitacaoOrcamento solicitacao02 = SolicitacaoOrcamentoFactory.CriarSolicitacaoOrcamento(SessionTest, colaborador,
* situacaoNaoIniciado, CsPrioridade.Alta, "Teste1", dtPrazo, cliente);
*
* Assert.AreEqual(ValidationState.Invalid, ValidationUtil.GetRuleState(solicitacao02,
* "SolicitacaoOrcamento_TxTitulo_Unique", DefaultContexts.Save));
*
#endregion
*
#region Passo 10
*
* solicitacao02 = SolicitacaoOrcamentoFactory.CriarSolicitacaoOrcamento(SessionTest, colaborador,
* situacaoNaoIniciado, CsPrioridade.Alta, "Teste2", dtPrazo, cliente);
*
* // Novas Solicitações de Orçamento
* SolicitacaoOrcamento solicitacao03 = SolicitacaoOrcamentoFactory.CriarSolicitacaoOrcamento(SessionTest, colaborador,
* situacaoNaoIniciado, CsPrioridade.Alta, "Teste3", dtPrazo, cliente);
*
* SolicitacaoOrcamento solicitacao04 = SolicitacaoOrcamentoFactory.CriarSolicitacaoOrcamento(SessionTest, colaborador,
* situacaoNaoIniciado, CsPrioridade.Alta, "Teste4", dtPrazo, cliente);
*
* // Persistência
* solicitacao02.Save();
* solicitacao03.Save();
* solicitacao04.Save();
*
* // Verificação dos códigos gerados
* Assert.AreEqual("FPF.02/2011", solicitacao02.TxCodigo,
* "O código deveria estar de acordo com o padrão");
*
* Assert.AreEqual("FPF.03/2011", solicitacao03.TxCodigo,
* "O código deveria estar de acordo com o padrão");
*
* Assert.AreEqual("FPF.04/2011", solicitacao04.TxCodigo,
* "O código deveria estar de acordo com o padrão");*/
#endregion
}
public void Test_eFi_Crono33()
{
const string RESTRICAO = "CalendarioConflitante";
CalendarioFactory.CriarCalendarioPorPeriodo(SessionTest, CsCalendarioDomain.Folga,
new DateTime(2010, 11, 15), new DateTime(2010, 11, 20), true);
/**
* Cenário1:
* Serão criados calendários conflitantes por período.
* O sistema deve rejeitá-los.
*/
Calendario calendario = CalendarioFactory.CriarCalendarioPorPeriodo(SessionTest,
CsCalendarioDomain.Folga, new DateTime(2010, 11, 15), new DateTime(2010, 11, 16));
Assert.AreEqual(ValidationState.Invalid, ValidationUtil.GetRuleState(calendario,
RESTRICAO, DefaultContexts.Save));
calendario = CalendarioFactory.CriarCalendarioPorPeriodo(SessionTest,
CsCalendarioDomain.Trabalho, new DateTime(2010, 11, 20), new DateTime(2010, 11, 25));
Assert.AreEqual(ValidationState.Invalid, ValidationUtil.GetRuleState(calendario,
RESTRICAO, DefaultContexts.Save));
calendario = CalendarioFactory.CriarCalendarioPorPeriodo(SessionTest,
CsCalendarioDomain.Trabalho, new DateTime(2010, 11, 16), new DateTime(2010, 11, 19));
Assert.AreEqual(ValidationState.Invalid, ValidationUtil.GetRuleState(calendario,
RESTRICAO, DefaultContexts.Save));
/**
* Cenário2:
* Será criado um calendário por dia do ano específico, conflitando
* com um calendário de período existente. O sistema deve rejeitar.
*/
calendario = CalendarioFactory.CriarCalendarioPorDiaMesAno(SessionTest,
CsCalendarioDomain.Trabalho, 20, CsMesDomain.Novembro, 2010);
Assert.AreEqual(ValidationState.Invalid, ValidationUtil.GetRuleState(calendario,
RESTRICAO, DefaultContexts.Save));
/**
* Cenário3:
* Será criado um calendário por dia do ano específico, não
* conflitante com o calendário de período existente mas conflitante
* com um calendario para um dia especifico. O sistema
* deve rejeitar.
*/
calendario = CalendarioFactory.CriarCalendarioPorDiaMesAno(SessionTest,
CsCalendarioDomain.Trabalho, 21, CsMesDomain.Novembro, 2010, true);
Assert.AreEqual(ValidationState.Valid, ValidationUtil.GetRuleState(calendario,
RESTRICAO, DefaultContexts.Save));
calendario = CalendarioFactory.CriarCalendarioPorDiaMesAno(SessionTest,
CsCalendarioDomain.Trabalho, 21, CsMesDomain.Novembro, 2010);
Assert.AreEqual(ValidationState.Invalid, ValidationUtil.GetRuleState(calendario,
RESTRICAO, DefaultContexts.Save));
/**
* Cenário4:
* - Será criado um calendário por dia e mês, não conflitante com os
* calendários existentes. O sistema deve aceitar.
* - Em seguida, será criado um outro calendário por dia e mês conflitante.
* O sistema deve rejeitar.
*/
calendario = CalendarioFactory.CriarCalendarioPorDiaMes(SessionTest,
CsCalendarioDomain.Trabalho, 23, CsMesDomain.Novembro);
Assert.AreEqual(ValidationState.Valid, ValidationUtil.GetRuleState(calendario,
RESTRICAO, DefaultContexts.Save));
calendario.Save();
calendario = CalendarioFactory.CriarCalendarioPorDiaMes(SessionTest,
CsCalendarioDomain.Trabalho, 23, CsMesDomain.Novembro);
Assert.AreEqual(ValidationState.Invalid, ValidationUtil.GetRuleState(calendario,
RESTRICAO, DefaultContexts.Save));
/**
* Cenário5:
* - Será criado um calendário por dia, mês e ano, conflitante com os
* calendários por dia e mês existente. O sistema deve aceitar pois dará
* prioridade ao calendário por dia mês e ano.
*/
calendario = CalendarioFactory.CriarCalendarioPorDiaMesAno(SessionTest,
CsCalendarioDomain.Trabalho, 23, CsMesDomain.Novembro, 2010);
Assert.AreEqual(ValidationState.Valid, ValidationUtil.GetRuleState(calendario,
RESTRICAO, DefaultContexts.Save));
calendario = CalendarioFactory.CriarCalendarioPorPeriodo(SessionTest,
CsCalendarioDomain.Trabalho, new DateTime(2010, 11, 23), new DateTime(2010, 11, 23));
Assert.AreEqual(ValidationState.Valid, ValidationUtil.GetRuleState(calendario,
RESTRICAO, DefaultContexts.Save));
}
