Verifique o elemento presente e o comando waitFor em Selenium

⚡ Resumo Inteligente

Verificar se o elemento está presente e aguardar comandos em Selenium O IDE confirma se uma página contém os elementos e o texto que um teste espera e pausa a reprodução até que uma condição dinâmica se torne verdadeira antes de executar a próxima etapa.

🔘 Verificações de elementos: verifyElementPresent retorna TRUE quando o localizador corresponde a algo na página, e verifyElementNotPresent é o seu inverso exato.
☑️ Verificações de texto: O verifyTextPresent pesquisa a página inteira e diferencia maiúsculas de minúsculas, portanto “Atlanta” nunca corresponde a “atlanta”.
✅ Verificações de posição: As funções `verifyElementPositionLeft` e `verifyElementPositionTop` comparam o deslocamento em pixels de um elemento em relação à borda da página.
🧪 Carregamento da página: Comandos como `clickAndWait` pausam o script até que uma nova página termine de carregar.
🛠️ Conteúdo dinâmico: Os comandos waitFor aguardam uma condição em vez de um carregamento de página, o que é adequado para telas AJAX que nunca são recarregadas.
📊 IDE atual: A extensão do navegador renomeia essas etapas e atribui a cada comando de espera seu próprio tempo limite em milissegundos.

Saiba Mais

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

A IDE legada compartilhava um tempo limite global em todas as etapas de espera (waitFor), alterado pelo comando setTimeout. A extensão atual define um tempo de espera explícito em milissegundos para cada comando wait, de modo que uma única tela lenta não força mais todas as outras etapas a esperarem pelo mesmo tempo.

Não. A pausa sempre aguarda o tempo total, então ela desperdiça tempo quando a página é rápida e ainda falha quando a página é lenta. Use-a apenas para demonstrar uma etapa durante uma demonstração, nunca em um conjunto de comandos que você pretende executar repetidamente.

Não. Presença significa que o nó existe no DOM, o que continua sendo verdade para elementos ocultos por CSS ou posicionados fora da tela. Quando o teste depende da visualização do elemento pelo usuário, adicione uma verificação de "esperar até que o elemento esteja visível" juntamente com a verificação de presença.

Sim, e a IDE atual exige isso. O comando de verificação de texto recebe um localizador de elemento mais a string esperada, o que é mais rigoroso do que a antiga busca em toda a página e impede que um item de menu não relacionado satisfaça uma verificação que nunca deveria ter sido feita para satisfazer.

Code O comando `export` transforma cada comando em uma instrução equivalente na linguagem de destino, de modo que uma etapa de espera se torna uma espera explícita do WebDriver. Leia o arquivo gerado antes de confiar nele, pois os tempos limite e o comportamento de falha (soft versus hard) nem sempre são preservados após a tradução.

Os modelos de aprendizado de máquina leem dados históricos de execução e sinalizam as etapas que falham intermitentemente, em vez de consistentemente, o que é característico de uma espera ausente. O reparo de localizadores assistido por IA aborda a outra causa comum, propondo um novo seletor quando a marcação é alterada.

Ele lida bem com a parte mecânica — transformando uma etapa de espera em um WebDriverWait com uma condição esperada. RevObserve o tempo limite escolhido e a condição selecionada, visto que uma condição de presença gerada muitas vezes precisa ser uma condição de visibilidade.

Os localizadores são avaliados em relação ao documento atualmente selecionado, e um iframe é considerado um documento separado. Execute primeiro o comando de seleção de frame, depois a verificação e, em seguida, retorne ao documento principal para que as etapas seguintes não sejam pesquisadas no contexto errado.