7 razões para usar testes automatizados em Selenium, JUnit5 e Gauge Framework

Os testes automatizados podem ser executados em vários ambientes, vários navegadores, vários dispositivos e vários conjuntos de dados em paralelo.

Esses testes são menos propensos a erros humanos do que os testes manuais, o que pode ajudar a melhorar a precisão e a confiabilidade do processo de teste. Além disso, eles são repetíveis, consistentes e confiáveis, o que ajuda a reduzir falsos positivos e falsos negativos. Neste artigo, falarei sobre por que você deve usar testes automatizados em Selenium, JUnit5 e Gauge Framework.

1. Aumenta a Eficiência

   

   Os testes de automação podem ser executados mais rapidamente do que os testes manuais, permitindo que mais testes sejam executados em um período de tempo menor. Isso pode ajudar a identificar problemas e bugs mais rapidamente, economizando tempo e recursos a longo prazo. Os testes de automação podem ser executados em vários ambientes, vários navegadores, vários dispositivos e vários conjuntos de dados em paralelo, o que aumenta a eficiência geral do processo de teste.

   
   

    import com.thoughtworks.gauge.Step import org.openqa.selenium.By import org.openqa.selenium.WebDriver import org.openqa.selenium.chrome.ChromeDriver class AutomationTest { private lateinit var driver: WebDriver @Step("Open the browser and navigate to the website") fun openBrowser() { System.setProperty("webdriver.chrome.driver", "/path/to/chrome/driver") driver = ChromeDriver() driver.get("https://www.example.com") } @Step("Search for <searchTerm>") fun search(searchTerm: String) { driver.findElement(By.name("q")).sendKeys(searchTerm) driver.findElement(By.name("btnK")).click() } @Step("Close the browser") fun closeBrowser() { driver.quit() } }

   
   

   Este é um exemplo de script de automação de teste simples escrito em Kotlin que usa a biblioteca Selenium para interagir com uma página da Web e o framework Gauge para organizar e executar os testes. Esse script abre um navegador, navega para um site, realiza uma pesquisa e fecha o navegador.

   
   

   Como esse teste é automatizado, ele pode ser executado mais rapidamente do que se fosse executado manualmente.

   
   

   Este é apenas um exemplo simples, em um caso de uso do mundo real, você pode ter vários cenários, vários casos de teste e vários conjuntos de testes que podem ser automatizados e executados em paralelo, aumentando a eficiência geral do processo de teste.

   
   

   Vale lembrar que, se você estiver trabalhando com uma aplicação web, existem outros frameworks e ferramentas que podem ser usados em conjunto ou no lugar do Selenium, como Cypress, WebDriverIO e TestCafe, cada um com suas especificidades e vantagens .

   
   

2. Melhora a Precisão

   

   Os testes automatizados são menos propensos a erros humanos do que os testes manuais, o que pode ajudar a melhorar a precisão e a confiabilidade do processo de teste. Os testes automatizados são repetíveis, consistentes e confiáveis, o que ajuda a reduzir falsos positivos e falsos negativos.

   
   

    import com.thoughtworks.gauge.Step import org.openqa.selenium.By import org.openqa.selenium.WebDriver import org.openqa.selenium.chrome.ChromeDriver class AutomationTest { private lateinit var driver: WebDriver @Step("Open the browser and navigate to the website") fun openBrowser() { System.setProperty("webdriver.chrome.driver", "/path/to/chrome/driver") driver = ChromeDriver() driver.get("https://www.example.com") } @Step("Search for <searchTerm> and verify the result") fun search(searchTerm: String) { driver.findElement(By.name("q")).sendKeys(searchTerm) driver.findElement(By.name("btnK")).click() val searchResult = driver.findElement(By.xpath("//div[@class='g']")) assert(searchResult.text.contains(searchTerm)) } @Step("Close the browser") fun closeBrowser() { driver.quit() } }

   
   

   Neste exemplo, o script não apenas executa uma pesquisa, mas também verifica os resultados afirmando que os resultados da pesquisa retornados contêm o termo de pesquisa. Isso ajuda a garantir que o teste seja preciso e detectará quaisquer problemas que possam ocorrer com a funcionalidade de pesquisa.

   
   

   Como o script é automatizado, ele será executado da mesma maneira sempre que for executado com as mesmas entradas, garantindo que o teste seja repetível, consistente e confiável. Isso ajuda a reduzir falsos positivos e falsos negativos, que podem ocorrer com testes manuais.

   
   

   Além disso, você pode usar ferramentas de relatório de teste como Gauge report, Allure, TestNG, JUnit, etc. para rastrear os resultados do teste, permitindo que você veja se um teste falhou ou foi aprovado. Se falhou, revelará o motivo da falha, o que ajuda a identificar problemas no início do processo de desenvolvimento e evita que se tornem problemas mais sérios posteriormente.

   
   

   3. Permite testes frequentes

   

   Os testes automatizados podem ser executados regularmente, como sempre que são feitas alterações no código, o que pode ajudar a identificar problemas no início do processo de desenvolvimento e evitar que se tornem problemas mais sérios posteriormente. Isso ajuda a detectar bugs no início do ciclo de desenvolvimento e ajuda a reduzir o custo geral de correção de bugs.

   
   

    import com.thoughtworks.gauge.Step import org.openqa.selenium.By import org.openqa.selenium.WebDriver import org.openqa.selenium.chrome.ChromeDriver import org.junit.jupiter.api.Test import org.junit.jupiter.api.BeforeEach class AutomationTest { private lateinit var driver: WebDriver @BeforeEach fun openBrowser() { System.setProperty("webdriver.chrome.driver", "/path/to/chrome/driver") driver = ChromeDriver() driver.get("https://www.example.com") } @Test fun testSearch() { driver.findElement(By.name("q")).sendKeys("searchTerm") driver.findElement(By.name("btnK")).click() val searchResult = driver.findElement(By.xpath("//div[@class='g']")) assert(searchResult.text.contains("searchTerm")) } @AfterEach fun closeBrowser() { driver.quit() } }

   
   

   Este script usa a estrutura JUnit5 e a anotação @Test , que marca um método como um método de teste. Isso permite que o teste seja executado automaticamente como parte de um conjunto de testes. Além disso, o script usa as anotações @BeforeEach e @AfterEach que marcam um método a ser executado antes ou depois de cada método de teste.

   
   

   Você também pode usar um pipeline de CI/CD e integrar o teste de automação a ele, permitindo que os testes sejam executados automaticamente como parte de um processo de compilação e a cada alteração de código. Isso ajuda a garantir que as alterações de código sejam testadas e sejam de boa qualidade antes de serem implantadas na produção.
   

   4. Custo-benefício

   

   Os testes automatizados podem ser executados sem intervenção humana, o que reduz o custo dos testes ao longo do tempo. Os testes automatizados podem ser executados regularmente e podem ser programados para serem executados em um horário específico, o que reduz a necessidade de recursos humanos.

   
   

    import com.thoughtworks.gauge.Step import org.openqa.selenium.By import org.openqa.selenium.WebDriver import org.openqa.selenium.chrome.ChromeDriver import org.junit.jupiter.api.Test import org.junit.jupiter.api.BeforeEach class AutomationTest { private lateinit var driver: WebDriver @BeforeEach fun openBrowser() { System.setProperty("webdriver.chrome.driver", "/path/to/chrome/driver") driver = ChromeDriver() driver.get("https://www.example.com") } @Test fun testSearch() { driver.findElement(By.name("q")).sendKeys("searchTerm") driver.findElement(By.name("btnK")).click() val searchResult = driver.findElement(By.xpath("//div[@class='g']")) assert(searchResult.text.contains("searchTerm")) } @Test fun testSignUp() { driver.findElement(By.linkText("Sign Up")).click() driver.findElement(By.name("username")).sendKeys("myusername") driver.findElement(By.name("password")).sendKeys("mypassword") driver.findElement(By.name("submit")).click() val message = driver.findElement(By.xpath("//div[@class='message']")) assert(message.text.contains("Welcome myusername")) } @AfterEach fun closeBrowser() { driver.quit() } }

   
   

   Neste exemplo, temos dois casos de teste. O primeiro é para testar a funcionalidade de pesquisa e o segundo é para testar a funcionalidade de inscrição. Ao ter vários casos de teste em um único script, aumenta a eficiência geral do processo de teste, o que pode ajudar a reduzir o custo geral do teste.

   
   

   Além disso, você pode usar a parametrização de teste onde pode executar o mesmo caso de teste com várias entradas e conjuntos de dados. Isso aumenta a cobertura geral do teste e ajuda a encontrar mais bugs, reduzindo o custo geral do teste.

   
   

   Além disso, você pode usar ambientes de teste baseados em nuvem, como SauceLabs, BrowserStack e TestingBot, permitindo executar seus testes em vários navegadores e sistemas operacionais sem precisar manter sua própria infraestrutura de teste. Isso pode reduzir os custos associados à manutenção e dimensionamento da infraestrutura de teste.

   
   

   No geral, os testes automatizados podem ser econômicos, reduzindo a necessidade de recursos humanos, aumentando a eficiência do processo de teste e usando ambientes de teste baseados em nuvem.

   
   

   5. Aumenta a cobertura

   

   Os testes automatizados podem abranger uma ampla gama de cenários, entradas e casos de uso que são difíceis de cobrir manualmente, aumentando assim a cobertura geral do teste. Os testes automatizados podem abranger diferentes navegadores, diferentes dispositivos, diferentes versões do sistema operacional, diferentes conjuntos de dados e diferentes cenários, o que aumenta a cobertura geral do teste.

   
   

    import com.thoughtworks.gauge.Step import org.openqa.selenium.By import org.openqa.selenium.WebDriver import org.openqa.selenium.chrome.ChromeDriver import org.junit.jupiter.api.Test import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.params.ParameterizedTest import org.junit.jupiter.params.provider.CsvSource class AutomationTest { private lateinit var driver: WebDriver @BeforeEach fun openBrowser() { System.setProperty("webdriver.chrome.driver", "/path/to/chrome/driver") driver = ChromeDriver() driver.get("https://www.example.com") } @ParameterizedTest @CsvSource(value = ["searchTerm1, expectedResult1", "searchTerm2, expectedResult2", "searchTerm3, expectedResult3"]) fun testSearch(searchTerm: String, expectedResult: String) { driver.findElement(By.name("q")).sendKeys(searchTerm) driver.findElement(By.name("btnK")).click() val searchResult = driver.findElement(By.xpath("//div[@class='g']")) assert(searchResult.text.contains(expectedResult)) } @AfterEach fun closeBrowser() { driver.quit() } }

   
   

   Neste exemplo, estamos usando a anotação JUnit5 @ParameterizedTest e @CsvSource para executar o mesmo caso de teste com várias entradas, aumentando a cobertura geral do teste. O teste será executado três vezes com valores de entrada diferentes e, a cada vez, verificará se a saída corresponde ao resultado esperado.

   
   

   Dessa forma, você pode testar a mesma funcionalidade com vários conjuntos de dados, o que ajuda a encontrar mais bugs e aumenta a cobertura geral do teste. Além disso, você também pode usar estruturas de teste orientadas a dados como TestNG, JUnit5 etc. para executar os casos de teste com várias entradas, aumentando a cobertura geral do teste.

   
   

   6. Melhora a consistência Os testes automatizados são sempre executados da mesma maneira, garantindo que os mesmos problemas não sejam perdidos repetidamente. Os testes automatizados são repetíveis, consistentes e confiáveis, o que reduz falsos positivos e falsos negativos.

   
   

    import com.thoughtworks.gauge.Step import okhttp3.OkHttpClient import okhttp3.Request import okhttp3.Response class API_AutomationTest { @Step("GET request to <endpoint> and verify the response") fun testAPI(endpoint: String) { val client = OkHttpClient() val request = Request.Builder() .url(endpoint) .get() .build() val response = client.newCall(request).execute() val json = response.body()?.string() assert(json!!.contains("\"userId\": 1")) } }

   
   

   Este script usa a estrutura Gauge e a anotação @Step , que marca um método como uma etapa no cenário de teste. Isso permite que o cenário de teste seja escrito em um formato legível e compreensível, facilitando a compreensão do fluxo do teste.

   
   

   Você também pode usar o conceito do medidor de teste orientado por dados, onde você pode executar o mesmo cenário de teste com várias entradas, aumentando a cobertura geral do teste e potencialmente encontrando mais bugs.

   
   

   Além disso, você pode usar o recurso de relatório do medidor, que fornece um relatório claro e conciso dos cenários de teste, resultados de teste e tempo de execução do teste.

   
   

   7. Permite Integração Contínua e Entrega Contínua

   

   O teste automatizado é um facilitador essencial para integração e entrega contínuas, que é um aspecto crítico do desenvolvimento de software moderno. Os testes automatizados podem ser integrados ao pipeline de CI/CD e podem ser executados automaticamente em cada alteração de código, garantindo que as alterações de código sejam testadas e sejam de boa qualidade antes de serem implantadas na produção.

   
   

   Você pode usar um pipeline de CI/CD e integrar o script a ele, permitindo que os testes sejam executados automaticamente como parte de um processo de compilação e a cada alteração de código.

   
   

   Por exemplo, você pode usar Jenkins, Travis, CircleCI, etc. como uma ferramenta de CI/CD. Em seguida, você pode configurar o trabalho para criar o projeto, executar os casos de teste e implantar o aplicativo na produção se os testes forem aprovados.

   
   

   Este é um aspecto crítico do desenvolvimento de software moderno e ajuda a obter uma entrega de software mais rápida e confiável.

   
   

 pipeline { agent any stages { stage('Build') { steps { sh './gradlew build' } } stage('Test') { steps { sh 'gauge run specs/' } } stage('Deploy') { steps { sh './deploy.sh' } } } }

Este Jenkinsfile define um pipeline com três estágios: Build, Test e Deploy.

No estágio Build , o pipeline executa o comando './gradlew build'. Este comando construirá o projeto e gerará os artefatos necessários.

No estágio de teste , o pipeline executa o comando 'gauge run specs/'. Este comando executará todos os casos de teste de medidor na pasta de especificações.

No estágio Deploy , o pipeline executa o comando './deploy.sh'. Este comando implantará o aplicativo no ambiente de produção.

Você pode configurar o trabalho Jenkins para executar este arquivo Jenkins e ele irá construir, testar e implantar o aplicativo se os testes forem aprovados.

Com este exemplo, você pode ver como pode usar os testes Gauge em um Jenkinsfile para habilitar integração e entrega contínuas. Isso permite automatizar o processo de teste.

Pensamentos finais

• Aumenta a eficiência permitindo que vários casos de teste sejam executados em um único script.

• Melhora a precisão reduzindo o erro humano e fornecendo resultados consistentes.

• Permite testes frequentes, facilitando a execução de testes regularmente.

• É econômico, reduzindo o custo geral do teste e aumentando a cobertura do teste.

• Aumenta a cobertura permitindo que o mesmo caso de teste seja executado com várias entradas e conjuntos de dados.

• Melhora a consistência, garantindo que o software esteja funcionando conforme o esperado.

• Ativa a integração contínua e a entrega contínua, permitindo que os testes sejam executados automaticamente como parte de um processo de compilação e com cada alteração de código, garantindo que as alterações de código sejam testadas e sejam de boa qualidade antes de serem implantadas na produção.

  
  

No geral, o teste de automação ajuda a melhorar a qualidade geral do software, reduzindo o custo geral do teste, aumentando a cobertura do teste, melhorando a consistência e permitindo integração e entrega contínuas, o que resulta em entrega de software mais rápida e confiável.