Verifique o elemento presente e o comando waitFor em Selenium

um gravado Selenium IDE O script clica e digita, mas por si só nunca decide se o aplicativo se comportou corretamente. Duas famílias de comandos fazem esse trabalho: verificar comandos, que verificam o estado da página, e esperar comandos, que retêm a execução até que a página esteja pronta para ser verificada.

⚠️ Uma observação sobre as versões: As capturas de tela abaixo são do original. Firefox-plugar Selenium IDE, que não é mais distribuída, e eles usam seus nomes Selenese em camelCase. A IDE atual é o Chrome, Firefox e Borda extensão do navegadorO comportamento descrito aqui ainda se aplica, mas vários nomes de comandos foram alterados — um mapaping A tabela aparece mais adiante neste artigo, e todos os comandos e capturas de tela originais são preservados exatamente como foram publicados.

Verifique a presença de um elemento

Podemos usar os dois comandos a seguir para verificar a presença de um elemento:

• verificarElementPresent – retorna TRUE se o elemento especificado foi ENCONTRADO na página; FALSO caso contrário
• verificarElementNotPresent – retorna TRUE se o elemento especificado NÃO FOI ENCONTRADO em nenhum lugar da página; FALSO se estiver presente.

Ambos os comandos recebem um elemento. localizador no Target campo — um id, um nome, um seletor CSS, um texto de link ou um XPath expressão — e nenhuma delas precisa de um valor.

O script de teste abaixo verifica se a caixa de texto Nome de usuário está presente dentro do Mercury Página inicial do Tours enquanto a caixa de texto do Primeiro Nome não é. A caixa de texto do Primeiro Nome é na verdade um elemento presente na página de Registro de Mercury Passeios, não na página inicial.

Porque estes são verificar comandos em vez de afirmar Se os comandos falharem, o erro é registrado no log, mas as etapas restantes continuam sendo executadas. Essa distinção será abordada em detalhes mais adiante.

Verifique a presença de um determinado texto no comando em Selenium

Verificar se um elemento existe nem sempre é suficiente — um teste geralmente precisa confirmar as palavras exibidas ao usuário. Dois comandos de texto resolvem esse problema.

• verificarTextPresent – retorna TRUE se a sequência de texto especificada foi ENCONTRADA em algum lugar da página; FALSO caso contrário
• verificarTextNotPresent – retorna TRUE se a sequência de texto especificada NÃO FOI ENCONTRADA em nenhum lugar da página; FALSO se foi encontrado

Lembre-se de que esses comandos diferenciam maiúsculas de minúsculas.

O registro abaixo mostra a mesma página verificada duas vezes com duas grafias diferentes da mesma frase.

No cenário acima, “Atlanta to Las Vegas” foi tratado de forma diferente de “atlanta to Las Vegas” porque a letra “A” de “Atlanta” estava em maiúscula no primeiro caso, enquanto em minúscula no segundo. Quando o comando verifyTextPresent foi usado em cada um deles, um foi aprovado, enquanto o outro falhou.

Verifique a posição específica de um elemento

Defeitos de layout raramente afetam um localizador, portanto, verificações de presença não os detectam. Os comandos de posição resolvem esse problema.

Selenium O IDE indica a posição de um elemento medindo (em pixels) a que distância ele está da borda esquerda ou superior da janela do navegador.

• verificarElementPositionLeft – verifica se o número especificado de pixels corresponde à distância do elemento à borda esquerda da página. Isso retornará FALSE se o valor especificado não corresponder à distância da borda esquerda.
• verificarElementPositionTop – verifica se o número especificado de pixels corresponde à distância do elemento da borda superior da página. Isso retornará FALSE se o valor especificado não corresponder à distância da borda superior.

O script abaixo registra os deslocamentos de pixel esperados na coluna Valor.

Trate esses dois comandos com cuidado. O deslocamento em pixels varia de acordo com o tamanho da janela, o nível de zoom e as fontes instaladas; portanto, um valor fixo que funciona em uma máquina pode falhar em outra.

Aguarde comandos em Selenium

Um comando de verificação só pode inspecionar o que já está na tela, portanto, uma verificação executada muito cedo falha, mesmo que o aplicativo esteja funcionando. Os comandos de espera resolvem esse problema de sincronização.

A seguir estão os tipos de comandos de espera em Selenium

Comandos andWait

Esses são comandos que aguardarão o carregamento de uma nova página antes de passar para o próximo comando.

Exemplos são

• clique e espere
• digiteAndWait
• selecioneAndWait

Cada um deles é um comando de ação comum com o sufixo AndWait anexado, como mostra a etapa gravada abaixo.

Comandos waitFor

Estes são comandos que esperam que uma condição especificada se torne verdadeira antes de prosseguir para o próximo comando (independentemente do carregamento de uma nova página). Esses comandos são mais apropriados para serem usados ​​em sites dinâmicos baseados em AJAX que alteram valores e elementos sem recarregar a página inteira. Exemplos incluem:

• espereForTitle
• waitForTextPresent
• espereForAlert

Considere o cenário do Facebook abaixo.

Podemos usar uma combinação de “click” e “waitForTextPresent” para verificar a presença do texto “Informando seu aniversário”.

Não podemos usar clickAndWait porque nenhuma página foi carregada ao clicar no link “Por que preciso informar minha data de nascimento?” link. Se fizermos isso, o teste falhará

A mesma regra se aplica a qualquer conteúdo injetado por script em vez de por navegação, e é por isso que Telas controladas por AJAX Quase sempre é necessário usar waitFor em vez de andWait.

Comandos Assert vs Verify vs waitFor em Selenium IDE

Iniciantes frequentemente escolhem a família errada e depois se perguntam por que um pacote de software para no primeiro defeito, ou por que relata vinte falhas que todos... trace voltamos ao um. Os três prefixos respondem a três perguntas diferentes.

Prefixo	O que ele faz	Em caso de falha	Melhor usado para
afirmar	Verifica uma condição imediatamente	Registra a falha e interrompe o caso de teste.	Pré-condições — um login que deve ser bem-sucedido antes que qualquer outra coisa faça sentido.
verificar	Verifica uma condição imediatamente	Registra a falha e continua com o próximo comando.	Verificações independentes, como várias etiquetas em uma página de confirmação.
aguarde	Realizar pesquisas até que a condição se torne verdadeira.	Registra a falha assim que o tempo limite expira e, em seguida, continua.	Qualquer coisa que apareça com atraso — respostas AJAX, indicadores de carregamento, diálogos.

Um padrão prático combina os três: verificar a página em que você chegou, aguardar o elemento que chega de forma assíncrona e, em seguida, verificar cada campo individualmente. Fazer isso nessa ordem significa que uma navegação quebrada interrompe o teste prematuramente, enquanto várias inconsistências visuais são relatadas em uma única execução. A mesma disciplina se aplica a Selenium testes escritos em código, onde os equivalentes são asserções rígidas, asserções flexíveis e esperas explícitas.

Comandos de verificação e espera no estado atual Selenium IDE

O FirefoxO plugin IDE que gerou as capturas de tela acima foi descontinuado e o conjunto de comandos foi reconstruído para a extensão de navegador atual. Vários nomes em Selenese permaneceram, alguns foram renomeados e outros foram removidos. A tabela abaixo mapeia os comandos usados ​​neste artigo para seus equivalentes atuais, retirados do manual oficial. Selenium Referência de comandos da IDE.

Comando Selenese Legado	Comando no IDE atual
verificarElementPresent	verificar elemento presente
verificarElementNotPresent	verificar elemento não presente
verificarTextPresent	Verificar texto (com escopo limitado a um localizador de elemento, não à página inteira)
verificarTextNotPresent	verificar se não é texto (com escopo para um localizador de elemento)
verificarTítulo	verificar título
verificarPosiçãoElementoEsquerda / verificarPosiçãoElementoSuperior	Não há equivalente — as afirmações de posição foram abandonadas.
Clique e espere, digite e espere, selecione e espere	Sem o sufixo AndWait — o comando open já aguarda o carregamento da página.
waitForElementPresent	Aguarde a presença do elemento, com um tempo de espera em milissegundos.
espereForAlert	Exibir alerta ou verificar texto de alerta após a exibição da caixa de diálogo

Duas diferenças são cruciais no trabalho diário. Primeiro, os comandos de espera atuais — aguardar elemento presente, aguardar elemento visível, aguardar elemento editável e seus inversos — exigem um tempo de espera explícito em milissegundos, de modo que uma etapa lenta não precisa mais compartilhar um tempo limite global. Segundo, a busca de texto em toda a página foi removida: verificar se o texto precisa de um localizador, o que geralmente produz uma verificação mais precisa.

Erros comuns com os comandos Verify e waitFor

A maioria dos problemas relatados com esses comandos não são defeitos da IDE. A lista abaixo abrange as falhas mais frequentes e suas respectivas soluções.

• O elemento existe, mas a verificação ainda falha. Presença e visibilidade são estados diferentes. Um elemento oculto por uma regra CSS ainda está presente no DOM, portanto, combine a verificação de presença com a espera até que o elemento esteja visível quando o teste depender de o usuário realmente vê-lo.
• A verificação de texto falha em expressões que parecem idênticas. Espaços não separáveis, espaços em branco à direita e apóstrofos curvos copiados de um documento de design impedem a correspondência exata. Digite novamente a sequência esperada manualmente em vez de colá-la.
• Um comando de espera expirou em uma página que claramente havia carregado. O elemento geralmente está dentro de um iframe. Execute `select frame` primeiro; caso contrário, o localizador será avaliado no documento errado.
• O clickAndWait trava em um aplicativo de página única. Nenhuma navegação ocorre, portanto não há nada para esperar. Substitua isso por um clique seguido do comando waitFor apropriado.
• A verificação de posição é bem-sucedida localmente, mas falha no servidor de compilação. O tamanho da tela e a renderização da fonte podem variar. Prefira uma verificação de presença ou de texto, ou defina um tamanho de janela explícito no início do teste.
• Todo o conjunto para na primeira incompatibilidade. Um comando assert foi registrado onde era esperado um comando verify. Altere o prefixo e a execução reportará todas as falhas em vez de apenas a primeira.

Uma vez que um roteiro sobreviva a essas armadilhas, o próximo passo geralmente é... Armazene valores de tempo de execução em variáveis. Assim, as verificações comparam com dados reais em vez de sequências de caracteres pré-definidas.

Perguntas Frequentes