Menu

As 10 principais exceções ao selênio e como lidar com elas (código exato)

top 10 selenium exceptions

Experimente Nosso Instrumento Para Eliminar Problemas

Manipulando exceções do Selenium WebDriver usando a estrutura de tratamento de exceções - Selenium Tutorial nº 19

Obter uma exceção no código de automação é muito comum. ‘Exceção’, como a palavra indica, é um caso especial ou incomum.

A execução do código de automação geralmente pode não funcionar conforme o esperado devido a muitos fatores envolvidos na execução, como problemas de estabilidade da rede, problemas de Internet, estabilidade do servidor, etc. Podemos obter exceções devido ao tempo de espera insuficiente ou sintaxes, parâmetros incorretos etc.

Tratamento de exceções no Selenium 2

No último tutorial do WebDriver, aprendemos sobre 3 tipos diferentes de elementos importantes da web, como Tabelas da web, frames e elementos dinâmicos e seus mecanismos de manipulação em script de selênio

Antes de prosseguir com os tutoriais do Framework neste Treinamento selênio série, aqui neste tutorial vamos aprender sobre tipos de exceções e como lidar com exceções em scripts Java e Selenium . Os desenvolvedores / testadores usam a estrutura de tratamento de exceção para tratar uma exceção em scripts selenium.

O que você aprenderá:

O que é uma exceção?

Exceções são eventos devido aos quais o programa java termina abruptamente sem fornecer a saída esperada. Java fornece uma estrutura onde um usuário pode lidar com exceções.

O processo de tratamento de exceções é denominado Tratamento de exceções.

principais perguntas da entrevista c ++

As exceções precisam ser tratadas porque interrompem o fluxo normal de execução de um programa. Uma das intenções importantes do tratamento de exceções é evitar essa interrupção e continuar a execução do programa. Às vezes, você pode querer realizar algumas séries de ações ao ocorrer uma certa exceção.

Quando ocorre uma exceção, um objeto de exceção é criado, o qual é tecnicamente conhecido como ' Lançando uma exceção ' e nós adicionamos Experimente / pegue blocos como,

try { // Protected code } catch (ExceptionName e) { // Catch block }

# 1) O trecho de código que pode lançar uma exceção é adicionado dentro do bloco Try.

#dois) A instrução Catch captura a exceção e a considera como um parâmetro.

# 3) Quando nenhuma exceção é lançada, a instrução try é executada e não a instrução catch.

Exemplo : Quando o script de selênio falha devido ao localizador incorreto, o desenvolvedor deve ser capaz de entender o motivo da falha e isso pode ser feito facilmente se a exceção for tratada adequadamente no programa.

Na minha experiência, é melhor tentar evitar exceções do WebDriver sempre que possível e capturar casos verdadeiramente excepcionais. Use try / catch para lidar com coisas que dão errado e estão fora do meu controle.

Evite aqueles que eu posso pegar outros!

Esta é a melhor estratégia que funcionou para mim.

Por exemplo, considere uma página de teste que leva mais tempo do que o normal para carregar em um servidor de teste. Obteremos exceções frequentes ao realizar ações nesta página. Então, em vez de apenas pegar isso todas as vezes, podemos

  • Adicione um comando de espera e tente evitar uma exceção
  • Use ‘Try / Catch’ para lidar com o caso, caso tenha ocorrido um caso verdadeiramente excepcional

Reduzindo assim as chances de exceções.

Exceções no selênio webdriver

Vantagens e desvantagens da abordagem Evitar-Manipular

Vantagens

Desvantagens

1) Essa abordagem reduz as chances de obter exceções.1) Aumenta as linhas de códigos porque você adiciona código extra para evitar exceções
Se uma exceção ainda for detectada, 2) seria um caso verdadeiramente excepcional que vale a pena verificar2) Deve ter um melhor entendimento da API do driver da Web, comandos e exceções
Reduza o tempo de depuração. O código de automação se destina a encontrar bugs e você não quer ver muitas exceções 3) indesejadas e encontrar as razões por trás de cada uma delas
4) No bloco Catch, você lida com casos mais válidos
5) Reduzir falhas falsas
6) Relatório mais claro

Neste tutorial, discutiremos Evitar e manipular abordagem para as 10 exceções mais comuns no Selenium WebDriver. Antes disso, vamos obter uma compreensão básica do tratamento de exceções e dos blocos Try / Catch.

Tipos de exceções em Java e Selenium

Abaixo, descrevemos os tipos de exceções e as diferentes maneiras como podemos usar a estrutura de tratamento de exceções em scripts de selênio.

Existem três tipos de exceções:

  1. Exceção verificada
  2. Exceção não verificada
  3. Erro

A hierarquia de classes de exceção e erro:

Tratamento de exceções no selênio

# 1) Exceção verificada: A exceção verificada é tratada durante o tempo de compilação e dá o erro de compilação se não for detectada e tratada durante o tempo de compilação.

Exemplo : FileNotFoundException , IOException etc.

# 2) Exceção não verificada: No caso de exceção não verificada, um compilador não obriga a manipular. O compilador ignora durante o tempo de compilação.

Exemplo : ArrayIndexoutOfBoundException

# 3) Erro: Quando um cenário é fatal e o programa não pode se recuperar, a JVM gera um erro. Os erros não podem ser tratados pelo bloco try-catch. Mesmo se o usuário tentar lidar com o erro usando o bloco Try catch, ele não poderá se recuperar do erro.

Exemplo : Erro de afirmação , Erro de falta de memória etc.

Manipulação de exceção

Tente e pegue o bloco:

tentar pegar blocos geralmente são usados ​​para lidar com exceções. O tipo de exceções é declarado no bloco catch que é esperado. Quando uma exceção ocorre no bloco try, o controle imediatamente se move para o bloco catch.

Exemplo :

try { br = new BufferedReader(new FileReader('Data')); } catch(IOException ie) { ie.printStackTrace(); }

Pode haver vários blocos catch para um bloco try, dependendo do tipo de exceção.

Exemplo :

try { br = new BufferedReader(new FileReader('Data')); } catch(IOException ie) { ie.printStackTrace(); } catch(FileNotFoundException file){ file.printStackTrace(); }

lança Exceção:

lança palavra-chave em java é usada para lançar uma exceção em vez de tratá-la. Todas as exceções verificadas podem ser lançadas por métodos.

Exemplo :

public static void main(String() args) throws IOException { BufferedReader br=new BufferedReader(new FileReader('Data')); while ((line = br.readLine()) != null) { System.out.println(line); } }

finalmente quadra:

finalmente , o bloco é executado independentemente da execução do bloco try-catch e é executado imediatamente após a conclusão do bloco try / catch.

Basicamente, o fechamento do arquivo, a conexão do banco de dados etc. podem ser fechados no bloco finally.

Exemplo :

try { br = new BufferedReader(new FileReader('Data')); } catch(IOException ie) { ie.printStackTrace(); } Finally { br.close(); }

No exemplo acima, BufferReader o fluxo é fechado no bloco finally. br.close () sempre será executado independentemente da execução do bloco try e catch.

Observação : finalmente o bloco pode existir sem qualquer bloco catch. Não é necessário ter sempre um bloco catch.

Pode haver muitos blocos catch, mas apenas um bloco finally pode ser usado.

Lançável : Throwable é uma classe pai para erro e exceção. Geralmente, é difícil lidar com erros em java. Se um programador não tiver certeza sobre o tipo de erro e exceção, é aconselhável usar a classe Throwable, que pode capturar o erro e a exceção.

Exemplo :

try { br = new BufferedReader(new FileReader('Data')); } catch (Throwable t) { t.printStackTrace(); }

Exceções comuns no Selenium WebDriver

Selenium tem seu próprio conjunto de exceções. Ao desenvolver scripts de selênio, um programador precisa lidar ou lançar essas exceções.

Abaixo estão alguns exemplos de exceções no selênio:

Todas as classes de exceção de tempo de execução no Selenium WebDriver vêm sob a superclasse WebDriverException.

Exceções do Webdriver

Embora existam muitas classes Exception em WebDriverException, normalmente vemos as seguintes.

  • NoSuchElementException
  • NoSuchWindowException
  • NoSuchFrameException
  • NoAlertPresentException
  • InvalidSelectorException
  • ElementNotVisibleException
  • ElementNotSelectableException
  • TimeoutException
  • NoSuchSessionException
  • StaleElementReferenceException

Detalhes :

ElementNotVisibleException : Se o selênio tentar encontrar um elemento, mas o elemento não estiver visível na página

NoAlertPresentException : Se um usuário tentar controlar uma caixa de alerta, mas o alerta não estiver presente.

NoSuchAttributeException : Ao tentar obter o valor do atributo, mas o atributo não está disponível no DOM.

NoSuchElementException : Esta exceção se deve ao acesso a um elemento que não está disponível na página.

WebDriverException : A exceção surge quando um código não consegue inicializar o WebDriver.

Evitando e lidando com exceções comuns

Vamos discutir a abordagem de evitar e manipular para as exceções mencionadas acima:

# 1) org.openqa.selenium.NoSuchElementException

Esta classe de exceção comumente vista é uma subclasse de NotFoundException classe. A exceção ocorre quando o WebDriver não consegue encontrar e localizar elementos.

Normalmente, isso acontece quando o testador grava um localizador de elemento incorreto no método findElement (By, by).

Considere que no exemplo abaixo, o id correto para o campo de texto era ‘firstfield’, mas o testador o mencionou incorretamente como ‘fistfield’. Neste caso, o WebDriver não consegue localizar o elemento e org.openqa.selenium.NoSuchElementException será lançado

driver.findElement(By.id('submit')).click(); Exception Handling: try { driver.findElement(By.id('submit')).click(); } catch (NoSuchElementException e)

Nesse caso, a exceção é lançada mesmo se o elemento não for carregado.

Evitando e manipulando : Tente dar um comando de espera.

Exemplo: O comando de espera abaixo aguarda 10 segundos pela presença do elemento da web com id ‘enviar’. Em seguida, ele tenta clicar nele. Se o elemento estiver disponível, mas ainda assim o clique falhar, uma exceção será detectada.

Usar o tempo atrasado é uma prática comum na automação de teste para criar uma pausa entre as etapas. Ao adicionar um Try / Catch, garantimos que o programa continua, mesmo que a espera não possa ajudar.

try { WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromSeconds(10)); wait.Until(ExpectedConditions.presenceOfElementLocated(By.id('submit'))); try { driver.findElement(By.id('submit')).click(); } catch (WebDriverException e) { System.out.println(“An exceptional case.”); } } catch (TimeOutException e) { System.out.println(“WebDriver couldn’t locate the element”); }

# 2) org.openqa.selenium.NoSuchWindowException

NoSuchWindowException vem abaixo NotFoundException classe. Isso é lançado quando o WebDriver tenta alternar para uma janela inválida.

O código a seguir pode lançar org.openqa.selenium.NoSuchWindowException se o identificador da janela não existir ou não estiver disponível para alternar.

driver.switchTo (). window (handle_1);

Evitando e manipulando : Usaríamos alças de janela para obter o conjunto de janelas ativas e, em seguida, executar ações nas mesmas.

No exemplo abaixo, para cada identificador de janela, a mudança do driver para é executada. Portanto, as chances de passar um parâmetro de janela errado são reduzidas.

for (String handle : driver.getWindowHandles()) { try { driver.switchTo().window(handle); } catch (NoSuchWindowException e) { System.out.println(“An exceptional case”); } }

# 3) org.openqa.selenium.NoSuchFrameException

Quando o WebDriver está tentando alternar para um quadro inválido, NoSuchFrameException na classe NotFoundException é lançada.

O código a seguir pode lançar org.openqa.selenium.NoSuchFrameException se um frame “frame_11” não existir ou não estiver disponível.

driver.switchTo (). frame (“frame_11”);

Manipulação de exceção:

try { driver.switchTo().frame('frame_11'); } catch (NoSuchFrameException e)

Nesse caso, a exceção é lançada mesmo se o quadro não for carregado.

Evitando e manipulando : Tente dar um comando de espera.

No exemplo abaixo, o WebDriver espera 10 segundos para que o quadro esteja disponível. Se o quadro estiver disponível e ainda houver uma exceção, ele será capturado.

try { WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromSeconds(10)); wait.Until(ExpectedConditions.frameToBeAvaliableAndSwitchToIt(frame_11)); try { driver.switchTo().frame('frame_11'); } catch (WebDriverException e) { System.out.println(“An exceptional case”); } } catch (TimeOutException e) { System.out.println(“WebDriver couldn’t locate the frame”); }

# 4) org.openqa.selenium.NoAlertPresentException

NoAlertPresentException sob NotFoundException é acionado quando o WebDriver tenta mudar para um alerta, que não está disponível.

org.openqa.selenium.NoAlertPresentException será lançado se o código de automação abaixo chamar a operação accept () na classe Alert () quando um alerta ainda não estiver na tela.

driver.switchTo (). alert (). accept ();

Manipulação de exceção:

try { driver.switchTo().alert().accept(); } catch (NoSuchAlertException e)

Nesse caso, a exceção é lançada mesmo se o alerta não for carregado completamente.

Evitando e manipulando : Sempre use uma espera explícita ou fluente por um determinado momento em todos os casos em que um alerta é esperado. Se o alerta estiver disponível e ainda houver uma exceção, ele será detectado.

try { WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromSeconds(10)); wait.Until(ExpectedConditions.alertIsPresent()); try { driver.switchTo().alert().accept(); } catch (NoAlertPresentException e) { System.out.println(“An exceptional case”); } } catch (TimeOutException e) System.out.println(“WebDriver couldn’t locate the Alert”); }

# 5) org.openqa.selenium.InvalidSelectorException

Esta subclasse de NoSuchElementException classe ocorre quando um seletor está incorreto ou sintaticamente inválido. Essa exceção ocorre comumente quando o localizador XPATH é usado.

Considere o exemplo abaixo:

clickXPathButtonAndWait (“// botão (@ type =’ button ’) (100)”);

Isso lançaria uma InvalidSelectorExeption porque a sintaxe XPATH está incorreta.

Evitando e manipulando : Para evitar isso, devemos verificar o localizador usado porque ele provavelmente está incorreto ou a sintaxe está errada. Usar o Firebug para encontrar o xpath pode reduzir essa exceção.

O código abaixo mostra como lidar com isso usando Try / Catch

try { clickXPathButtonAndWait('//button(@type='button')'); } catch (InvalidSelectorException e) { }

# 6) org.openqa.selenium.ElementNotVisibleException

ElementNotVisibleException classe é uma subclasse de ElementNotInteractableException classe. Essa exceção é lançada quando o WebDriver tenta executar uma ação em um elemento da web invisível, com o qual não pode haver interação. Ou seja, o elemento da web está em um estado oculto.

Por exemplo, no código abaixo, se o tipo de botão com id ‘enviar’ estiver ‘oculto’ em HTML, org.openqa.selenium.ElementNotVisibleException será lançado.

driver.findElement(By.id('submit')).click(); Exception Handling: try { driver.findElement(By.id('submit')).click(); } catch (ElementNotVisibleException e)

Nesse caso, a exceção é lançada mesmo que a página não tenha sido carregada completamente.

Evitando e manipulando : Existem duas maneiras de fazer isso. Podemos usar esperar que o elemento fique completamente.

O código a seguir espera 10 segundos pelo elemento. Se o elemento estiver visível e ainda assim a exceção for lançada, ele será capturado.

try { WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromSeconds(10)); wait.Until(ExpectedConditions.visibilityOfElementLocated(By.id(”submit”)); try { driver.findElement(By.id('submit')).click(); } catch (WebDriverException e) { System.out.println(“Exceptional case”); } } catch (TimeOutException e) System.out.println(“WebDriver couldn’t find this element visible”); }

# 7) org.openqa.selenium.ElementNotSelectableException

Esta exceção vem em InvalidElementStateException classe . ElementNotSelectableException indica que o elemento da web está presente na página da web, mas não pode ser selecionado.

Por exemplo, o código abaixo pode lançar uma ElementNotSelectableException se o id “swift” estiver desabilitado.

Select dropdown = new Select (driver.findElement (By.id (“swift”)));

Manipulação de exceção:

tentar {
Select dropdown = new Select (driver.findElement (By.id (“swift”)));
} catch (ElementNotSelectableException e)

Nesse caso, a exceção é lançada mesmo se o elemento for habilitado após um tempo.

Evitando e manipulando : Podemos adicionar um comando de espera para esperar até que o elemento se torne clicável. Se ainda houver uma exceção, ela será detectada.

o que é teste de caixa preta com exemplo
try { WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromSeconds(10)); wait.Until(ExpectedConditions. elementToBeClickable(By.id(”swift”)); try { Select dropdown = new Select(driver.findElement(By.id('swift'))); } catch (WebDriverException e) { System.out.println(“Exceptional case”); } } catch (TimeOutException e) System.out.println(“WebDriver found that this element was not selectable.”); }

# 8) org.openqa.selenium .TimeoutException

Essa exceção ocorre quando a conclusão de um comando leva mais do que o tempo de espera. As esperas são usadas principalmente no WebDriver para evitar a exceção ElementNotVisibleException.

Às vezes, a página de teste pode não carregar completamente antes do próximo comando no programa. Se o WebDriver tentar encontrar um elemento na página da web antes que a página carregue completamente, a exceção ElementNotVisibleException será lançada. Para evitar essa exceção, são adicionados comandos de espera.

No entanto, se os componentes não carregam mesmo após a espera, a exceção org.openqa.selenium .TimeoutException será lançado.

driver.manage (). timeouts (). implicitlyWait (10, TimeUnit.SECONDS);

driver.get (“https://www.softwaretestinghelp.com”);

No programa acima, uma espera implícita de 10 segundos é adicionada. Se a página www.softwaretestinghelp.com não carrega em 10 segundos, então TimeoutException será lançado.

Evitando e manipulando : Para evitar isso, podemos verificar manualmente o tempo médio de carregamento de uma página e ajustar a espera

Ou podemos adicionar espera explícita usando o executor JavaScript até que a página seja carregada.

No exemplo abaixo, o executor JavaScript é usado. Após a navegação da página, chamamos de retorno de JavaScript document.readyState por 20 segundos até que “complete” seja retornado.

WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromSeconds(30)); wait.until(webDriver -> ((JavascriptExecutor)webDriver).executeScript('return document.readyState').equals('complete')); driver.get('https://www.softwaretestinghelp.com');

# 9) org.openqa.selenium.NoSuchSessionException

Essa exceção é lançada quando um método é chamado após sair do navegador por WebDriver.quit (). Isso também pode acontecer devido a problemas do navegador da web, como travamentos e o WebDriver não pode executar nenhum comando usando a instância do driver.

Para ver esta exceção, o código abaixo pode ser executado.

driver.quit ()

Select dropdown = new Select (driver.findElement (By.id (“swift”)));

Evitando e manipulando : Sempre escolha a versão estável mais recente do navegador para executar os casos de teste do Selenium Webdriver.

Essa exceção pode ser reduzida usando driver.quit () na conclusão de todos os testes. Não tente usá-los após cada caso de teste. Isso pode levar a problemas quando a instância do driver é nula e os próximos casos de teste tentam usá-lo sem inicializar.

O código a seguir cria uma instância WebDriver na anotação @BeforeSuite TestiNG e a destrói na anotação @AfterSuite TestiNG

@BeforeSuite public void setUp() throws MalformedURLException { WebDriver driver = new FirefoxDriver(); } @AfterSuite public void testDown() { driver.quit(); }

# 10) org.openqa.selenium.StaleElementReferenceException

Essa exceção diz que um elemento da web não está mais presente na página da web.

Este erro não é igual a ElementNotVisibleException.

StaleElementReferenceException é lançada quando um objeto para um determinado elemento da web foi criado no programa sem nenhum problema e, no entanto; este elemento não está mais presente na janela. Isso pode acontecer se houver um

  • Navegação para outra página
  • DOM foi atualizado
  • Uma moldura ou interruptor de janela

WebElement firstName = driver.findElement (By.id (“firstname”));

driver.switchTo (). window (Child_Window);

element.sendKeys (“Aaron”);

No código acima, o objeto firstName foi criado e a janela foi trocada. Em seguida, o WebDriver tenta digitar ‘Aaron’ no campo do formulário. Nesse caso, StaleElementReferenceException é lançada.

Evitando e manipulando : Confirme que estamos tentando fazer a ação na janela correta. Para evitar problemas devido à atualização do DOM, podemos usar Dynamic Xpath

Vamos discutir outro exemplo.

Diga 'id' de um campo de nome de usuário é 'username_1' e o XPath será // * (@ id = ’firstname_1?) . Quando você abre a página novamente, o ‘id’ pode mudar para ‘ 'primeiro nome _11 ’. Nesse caso, o teste falhará porque o WebDriver não conseguiu encontrar o elemento. Nesse caso, StaleElementReferenceException será lançado.

Neste caso, podemos usar um xpath dinâmico como,

try { driver.findElement(By.xpath(“//*(contains(@id,firstname’))”)).sendKeys(“Aaron”); } catch (StaleElementReferenceException e)

No exemplo acima, XPATH dinâmico é usado e se a exceção ainda for encontrada, ela será capturada.

Conclusão

O tratamento de exceções é a parte essencial de todo programa java, bem como do script selenium. Podemos construir um código robusto e ideal por lidar com uma exceção de maneira inteligente . E também é uma prática recomendada lidar com exceções em um script que fornecerá um relatório melhor quando um programa falhar por qualquer motivo.

Aqui, tentamos cobrir o processo e a estrutura de tratamento de exceções que devem ser implementados em scripts de selênio.

Lembre-se de que não é obrigatório sempre tratar a exceção em um tentar pegar quadra. Você também pode lançar uma exceção, dependendo do requisito em um script.

Uma exceção não deve ser ignorada, pois interrompe a execução do programa. Neste tutorial, passamos por diferentes exceções e maneiras de reduzir as chances de obtê-las por meio de verificações manuais e códigos.

Adicionar esperas pode controlar alguns casos como ‘NoSuchElementException’, ‘ElementNotFoundException‘, ‘ElementNotVisibleException‘.

Próximo Tutorial # 20 : No próximo tutorial, discutiremos o vários tipos de estruturas de teste disponíveis . Também estudaríamos os prós e os contras de usar uma abordagem de estrutura completa em testes de automação. Discutiríamos em detalhes sobre a estrutura baseada em dados de teste.

Por favor, poste suas dúvidas, relacionadas à manipulação de exceção no Selenium WebDriver, se você tiver alguma.

Leitura recomendada

^