private bool ValidarControledeAcessoStub()
{
bool paginaDisponivel = Valor.Inativo;
try
{
Ambiente objAmbiente = SecuritySettings.Ambientes.Find(obj => obj.GUID == UsuarioCorrenteFacade.Environment);
objAmbiente.GetSuperGrupos().ForEach(sg =>
{
if (paginaDisponivel)
{
return;
}
sg.GetGrupos().ForEach(g =>
{
if (paginaDisponivel)
{
return;
}
g.GetFuncionalidades().ForEach(f =>
{
bool paginaLocalizada = !Checar.IsNull(f.GetItens().Find(obj => obj.UrlMapID == PAGINA_ID));
paginaDisponivel = paginaLocalizada && f.Habilitado;
if (paginaDisponivel)
{
return;
}
});
});
});
}
catch { paginaDisponivel = Valor.Inativo; }
return(paginaDisponivel);
}
public void CriandoeExcluindoPermissaoParaUmGrupo()
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
Swarm.Core.Library.Seguranca.Grupo objGrupo = GrupoController.Create();
objGrupo.Descricao = "Grupo de teste #1";
GrupoController.Manter(objGrupo, this.Usuario.Login, colecao);
GrupoUsuario objGrupoUsuario = GrupoUsuarioController.Create();
objGrupoUsuario.Usuario = this.Usuario;
objGrupoUsuario.Grupo = objGrupo;
GrupoUsuarioController.Manter(objGrupoUsuario, this.Usuario.Login, colecao);
Permissao objPermissao = PermissaoController.Create();
objPermissao.Grupo = objGrupoUsuario;
objPermissao.GUID = this.Ambiente.GUID;
PermissaoController.Manter(objPermissao, this.Usuario.Login, colecao);
PermissaoController.Excluir(objPermissao, colecao);
GrupoUsuarioController.Excluir(objGrupoUsuario, colecao);
GrupoController.Excluir(objGrupo, colecao);
colecao.Persistir();
Assert.IsTrue(Checar.MenorouIgual(objPermissao.ID));
}
public void CriandoUmaLigacao()
{
try
{
ColecaoPersistencia colecaoPersistencia = new ColecaoPersistencia();
this.Usuario.Tipo = EnumAutenticacao.TipodeUsuario.Usuario;
this.Usuario.Login = "******";
this.Usuario.Senha = "bnkGt/s/jhxjZsCRAFDllQ=="; // testes
UsuarioController.Manter(this.Usuario, colecaoPersistencia);
this.Grupo.Descricao = "Grupo #1 (Homologação)";
GrupoController.Manter(this.Grupo, this.Usuario.Login, colecaoPersistencia);
this.Ligacao.Usuario = this.Usuario;
this.Ligacao.Grupo = this.Grupo;
GrupoUsuarioController.Manter(this.Ligacao, this.Usuario.Login, colecaoPersistencia);
colecaoPersistencia.Persistir();
Assert.That(Checar.MaiorQue(this.Usuario.GetGrupos().Count), "Não há grupos associados ao usuário 'usuario.teste'");
Assert.That(Checar.MaiorQue(this.Grupo.GetUsuarios().Count), "Não há usuários associados ao grupo 'Grupo #1 (Homologação)'");
}
catch (Exception erro) { Assert.That(Valor.Inativo, erro.Message); }
}
public void CriandoCenariodeAcessoAnonimo()
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
// INÍCIO: A exclusão do ambiente irá efetuar o processo de limpeza automática dos registros associados (cascata)
SuperGrupo objSuperGrupo = new SuperGrupo();
objSuperGrupo.Titulo = "Administrativo (Homologação)";
objSuperGrupo.Habilitado = Valor.Ativo;
objSuperGrupo.Ambiente = this.AmbienteEnvolvido;
AcessoController.Manter(objSuperGrupo, "usuario.teste", colecao);
Grupo objGrupo = new Grupo();
objGrupo.Titulo = "Segurança (Homologação)";
objGrupo.Habilitado = Valor.Ativo;
objGrupo.SuperGrupo = objSuperGrupo;
AcessoController.Manter(objGrupo, "usuario.teste", colecao);
Funcionalidade objFuncionalidade = new Funcionalidade();
objFuncionalidade.Titulo = "Manutenção de Usuários (Homologação)";
objFuncionalidade.Habilitado = Valor.Ativo;
objFuncionalidade.Grupo = objGrupo;
AcessoController.Manter(objFuncionalidade, "usuario.teste", colecao);
// FIM: A exclusão do ambiente irá efetuar o processo de limpeza automática dos registros associados (cascata)
colecao.Persistir();
Assert.IsTrue(Checar.MaiorQue(this.AmbienteEnvolvido.ID));
}
public void PermitirMultiplosItensMapeadosQuandoFuncionalidade()
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
AcessoMap objFuncionalidadeMAP = new AcessoMap();
objFuncionalidadeMAP.Tipo = EnumAcesso.TipodeAcesso.Funcionalidade;
objFuncionalidadeMAP.IdAcesso = Valor.Um; // DEFAULT (ID SuperGrupo ou Grupo)
objFuncionalidadeMAP.UrlMapID = Valor.Um;
objFuncionalidadeMAP.Principal = Valor.Ativo;
AcessoController.Manter(objFuncionalidadeMAP, "usuario.teste", colecao);
AcessoMap objFuncionalidadeMAP_2 = new AcessoMap();
objFuncionalidadeMAP_2.Tipo = EnumAcesso.TipodeAcesso.Funcionalidade;
objFuncionalidadeMAP_2.IdAcesso = Valor.Um; // DEFAULT (ID SuperGrupo ou Grupo)
objFuncionalidadeMAP_2.UrlMapID = Valor.Dois;
objFuncionalidadeMAP_2.Principal = Valor.Inativo;
AcessoController.Manter(objFuncionalidadeMAP_2, "usuario.teste", colecao);
AcessoController.Excluir(objFuncionalidadeMAP, colecao);
AcessoController.Excluir(objFuncionalidadeMAP_2, colecao);
colecao.Persistir();
Assert.IsFalse(Checar.MaiorQue(objFuncionalidadeMAP.ID), "O registro 1 deveria ter sido removido.");
Assert.IsFalse(Checar.MaiorQue(objFuncionalidadeMAP_2.ID), "O registro 2 deveria ter sido removido.");
}
static void Main(string[] args)
{
Console.WriteLine("Ingresa el nombre: ");
string name = Console.ReadLine();
Checar.checador(name);
Console.WriteLine("Ingresa tu apellido: ");
string apellido = Console.ReadLine();
Checar.checador(apellido);
}
public void NaoPermiteoMapeamentoDeGruposOuSuperGrupos()
{
AcessoMap objGrupoMAP = new AcessoMap();
objGrupoMAP.Tipo = EnumAcesso.TipodeAcesso.Grupo; // *ERRO*
objGrupoMAP.IdAcesso = Valor.Um; // DEFAULT
objGrupoMAP.UrlMapID = Valor.Um;
objGrupoMAP.Principal = Valor.Ativo;
AcessoController.Manter(objGrupoMAP, "usuario.teste", null);
Assert.IsFalse(Checar.MaiorQue(objGrupoMAP.ID), "Não deveria permitir o mapeamento de Grupo ou SuperGrupo.");
}
public void PaginaControladoraDeveEstarMapeada()
{
UrlMap obj = UrlMap.Instance;
UrlMapItem objITEM = obj.Itens.Find(i => i.Key == Map.FrontController.Controller);
Assert.IsNotNull(objITEM);
Assert.IsTrue(Checar.MaiorouIgual(objITEM.ID));
Assert.IsNotNullOrEmpty(objITEM.Key);
Assert.IsNotNullOrEmpty(objITEM.Url);
//Assert.IsNotNullOrEmpty(objITEM.Titulo);
Assert.IsTrue(objITEM.Ocultar);
}
public void CriandoeExcluindoPermissaoParaUmUsuario()
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
Permissao objPermissao = PermissaoController.Create();
objPermissao.Usuario = this.Usuario;
objPermissao.GUID = this.Ambiente.GUID;
PermissaoController.Manter(objPermissao, this.Usuario.Login, colecao);
PermissaoController.Excluir(objPermissao, colecao);
colecao.Persistir();
Assert.IsTrue(Checar.MenorouIgual(objPermissao.ID));
}
public void RegistrandoeAlterandoUmaVersaoNoSistema()
{
this.ControledeVersao.Versao = "1.0.1b";
this.ControledeVersao.Notas = "Registro de versão para fins de testes unitários.";
this.ControledeVersao.LogdeInstalacao = DateTime.Now;
ControledeVersaoController.Manter(this.ControledeVersao, "usuario.testes", null);
Assert.That(Checar.MaiorQue(this.ControledeVersao.ID), "Não foi possível criar o registro solicitado.");
string versaoAlterada = "1.0.2b";
this.ControledeVersao.Versao = versaoAlterada;
ControledeVersaoController.Manter(this.ControledeVersao, "usuario.testes", null);
Assert.That(ControledeVersaoController.Get(this.ControledeVersao.ID).Versao == versaoAlterada, "Não foi possível efetuar a alteração solicitada.");
}
public void ValidarMapeamentos()
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
AcessoMap objAmbienteMAP = new AcessoMap();
objAmbienteMAP.Tipo = EnumAcesso.TipodeAcesso.Ambiente;
objAmbienteMAP.IdAcesso = this.AmbienteEnvolvido.ID;
objAmbienteMAP.UrlMapID = Valor.Um;
objAmbienteMAP.Principal = Valor.Ativo;
AcessoController.Manter(objAmbienteMAP, "usuario.teste", colecao);
AcessoController.Excluir(objAmbienteMAP, colecao);
colecao.Persistir();
Assert.That(Checar.MenorouIgual(objAmbienteMAP.ID), "Não foi possível concluir a operação de criação e exclusão de mapeamento.");
}
public void PermitirAlterarObjetoSemGerarNovoRegistro()
{
int tentativasPADRAO = this.Configuracao.TentativasdeAcesso;
this.Configuracao.TentativasdeAcesso++;
try { ConfiguracoesGeraisController.Manter(this.Configuracao, "usuario.testes", null); }
catch { /* Prevenção */ }
this.Configuracao = ConfiguracoesGeraisController.Get(); // Obtendo nova instância
Assert.That(this.Configuracao.TentativasdeAcesso != tentativasPADRAO, "Não houve a alteração esperada no objeto.");
this.Configuracao.TentativasdeAcesso = tentativasPADRAO;
try { ConfiguracoesGeraisController.Manter(this.Configuracao, "usuario.testes", null); }
catch { /* Prevenção */ }
Assert.That(Checar.MenorouIgual(this.GetTotaldeConfiguracoesExistenteStub(), Valor.Um), "Foi detectado mais de um registo de configuração cadastro, este comportamento é indevido.");
}
private bool ValidarPermissoesStub()
{
if (UsuarioCorrenteFacade.Instance.IsAdministrador)
{
return(Valor.Ativo);
}
bool possuiPermissao = Valor.Inativo;
try
{
Ambiente objAmbiente = SecuritySettings.Ambientes.Find(obj => obj.GUID == UsuarioCorrenteFacade.Environment);
string guidEnvolvido = objAmbiente.FindGUID(PAGINA_ID);
possuiPermissao = !Checar.IsNull(UsuarioCorrenteFacade.Instance.GetPermissoes().Find(obj => obj.GUID == guidEnvolvido));
}
catch { possuiPermissao = Valor.Inativo; }
return(possuiPermissao);
}
private bool ValidarPermissoesStub()
{
if (UsuarioCorrenteFacade.Instance.IsAdministrador)
{
return(Valor.Ativo);
}
bool possuiPermissao = Valor.Inativo;
try
{
List <Ambiente> objAmbientes = SecuritySettings.Ambientes.Where(obj => obj.CodigoInterno == EnumAcesso.CodigoInterno_Ambiente.Indefinido && obj.Restrito).ToList();
string guidEnvolvido = objAmbientes.Find(obj => obj.GetItemBase().UrlMapID == PAGINA_ID).GUID;
possuiPermissao = !Checar.IsNull(UsuarioCorrenteFacade.Instance.GetPermissoes().Find(obj => obj.GUID == guidEnvolvido));
}
catch { possuiPermissao = Valor.Inativo; }
return(possuiPermissao);
}
public void NaoPermitirMaisDeUmItemMapeadoNoMesmoAmbiente()
{
ColecaoPersistencia colecao = new ColecaoPersistencia();
AcessoMap objAmbienteMAP = new AcessoMap();
objAmbienteMAP.Tipo = EnumAcesso.TipodeAcesso.Ambiente;
objAmbienteMAP.IdAcesso = Valor.Um; // DEFAULT (ID Ambiente)
objAmbienteMAP.UrlMapID = Valor.Um;
objAmbienteMAP.Principal = Valor.Ativo;
AcessoController.Manter(objAmbienteMAP, "usuario.teste", colecao);
AcessoMap objAmbienteMAP_DUPLICADO = new AcessoMap();
objAmbienteMAP.Tipo = EnumAcesso.TipodeAcesso.Ambiente;
objAmbienteMAP.IdAcesso = Valor.Um; // DEFAULT (ID Ambiente)
objAmbienteMAP.UrlMapID = Valor.Dois;
objAmbienteMAP.Principal = Valor.Ativo;
AcessoController.Manter(objAmbienteMAP_DUPLICADO, "usuario.teste", colecao); // *ERRO*
colecao.Persistir();
Assert.IsFalse(Checar.MaiorQue(objAmbienteMAP_DUPLICADO.ID), "Não deveria permitir a duplicação de ligações quando Ambiente.");
}
static void Main(string[] args)
{
JalarTexto texto = new JalarTexto(@"C:\Users\Trece\source\repos\GitDemo\codeigo\codeigo\Texto\Texto.txt");
Checar.ChecarMod(texto.Elemento);
}
public void FoiGeradoCorretamenteGUID()
{
Assert.That(!Checar.IsCampoVazio(this.AmbienteEnvolvido.GUID), "Não foi gerado o GUID do ambiente.");
}
private bool ValidarAutenticacaoStub()
{
return(UsuarioCorrenteFacade.Instance.Autenticado && !Checar.IsCampoVazio(UsuarioCorrenteFacade.Environment));
}
public void PossuiItensMapeados()
{
Assert.That(Checar.MaiorQue(UrlMap.Instance.Itens.Count), "Não há itens de URL mapeados.");
}
public void ObjetoEnvolvidoNaoPodeSerNulo()
{
Assert.That(!Checar.IsNull(this.Configuracao), "A configuração envolvida está nula. Não foi possível instanciar o objeto solicitado.");
}
public void DeveExistirUmaConfiguracaoGeralCadastrada()
{
Assert.That(Checar.MaiorQue(this.Configuracao.ID), "Não foi possível localizar o registro padrão na base de dados.");
}
