7 razones para usar pruebas automatizadas en Selenium, JUnit5 y Gauge Framework

Las pruebas automatizadas se pueden ejecutar en múltiples entornos, múltiples navegadores, múltiples dispositivos y múltiples conjuntos de datos en paralelo.

Estas pruebas son menos propensas al error humano que las pruebas manuales, lo que puede ayudar a mejorar la precisión y confiabilidad del proceso de prueba. Además, son repetibles, coherentes y fiables, lo que ayuda a reducir los falsos positivos y los falsos negativos. En este artículo, hablaré sobre por qué debería usar pruebas automatizadas en Selenium, JUnit5 y Gauge Framework.

1. Aumenta la eficiencia

   

   Las pruebas de automatización se pueden ejecutar más rápido que las pruebas manuales, lo que permite ejecutar más pruebas en un período de tiempo más corto. Esto puede ayudar a identificar problemas y errores más rápidamente, ahorrando tiempo y recursos a largo plazo. Las pruebas de automatización pueden ejecutarse en múltiples entornos, múltiples navegadores, múltiples dispositivos y múltiples conjuntos de datos en paralelo, lo que aumenta la eficiencia general del proceso de prueba.

   
   

    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 es un ejemplo de un script de automatización de prueba simple escrito en Kotlin que utiliza la biblioteca Selenium para interactuar con una página web y el marco de trabajo de Gauge para organizar y ejecutar las pruebas. Este script abre un navegador, navega a un sitio web, realiza una búsqueda y luego cierra el navegador.

   
   

   Debido a que esta prueba está automatizada, puede ejecutarse más rápido que si se realizara manualmente.

   
   

   Este es solo un ejemplo simple, en un caso de uso del mundo real, puede tener múltiples escenarios, múltiples casos de prueba y múltiples conjuntos de pruebas que pueden automatizarse y ejecutarse en paralelo, lo que aumenta la eficiencia general del proceso de prueba.

   
   

   Vale la pena señalar que, si está trabajando con una aplicación web, existen otros marcos y herramientas que se pueden usar junto con o en lugar de Selenium, como Cypress, WebDriverIO y TestCafe, cada uno con sus propias características y ventajas específicas. .

   
   

2. Mejora la precisión

   

   Las pruebas automatizadas son menos propensas al error humano que las pruebas manuales, lo que puede ayudar a mejorar la precisión y confiabilidad del proceso de prueba. Las pruebas automatizadas son repetibles, consistentes y confiables, lo que ayuda a reducir los falsos positivos y 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() } }

   
   

   En este ejemplo, la secuencia de comandos no solo realiza una búsqueda, sino que también verifica los resultados al afirmar que los resultados de búsqueda devueltos contienen el término de búsqueda. Esto ayuda a garantizar que la prueba sea precisa y detectará cualquier problema que pueda ocurrir con la función de búsqueda.

   
   

   Debido a que el script está automatizado, se ejecutará de la misma manera cada vez que se ejecute con las mismas entradas, lo que garantiza que la prueba sea repetible, consistente y confiable. Esto ayuda a reducir los falsos positivos y los falsos negativos, que pueden ocurrir con las pruebas manuales.

   
   

   Además, puede usar herramientas de informes de prueba como el informe de calibre, Allure, TestNG, JUnit, etc. para realizar un seguimiento de los resultados de la prueba, lo que le permite ver si una prueba falló o pasó. Si ha fallado, revelará la razón detrás de la falla, lo que ayuda a identificar problemas al principio del proceso de desarrollo y evita que se conviertan en problemas más serios más adelante.

   
   

   3. Permite pruebas frecuentes

   

   Las pruebas automatizadas se pueden ejecutar de forma regular, como cada vez que se realizan cambios en el código, lo que puede ayudar a identificar problemas al principio del proceso de desarrollo y evitar que se conviertan en problemas más graves más adelante. Esto ayuda a detectar errores al principio del ciclo de desarrollo y ayuda a reducir el costo total de corregir errores.

   
   

    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 el marco JUnit5 y la anotación @Test , que marca un método como método de prueba. Esto permite que la prueba se ejecute automáticamente como parte de un conjunto de pruebas. Además, el script usa las anotaciones @BeforeEach y @AfterEach que marcan un método para que se ejecute antes o después de cada método de prueba.

   
   

   También puede usar una canalización de CI/CD e integrar la prueba de automatización con ella, lo que permite que las pruebas se ejecuten automáticamente como parte de un proceso de compilación y con cada cambio de código. Esto ayuda a garantizar que los cambios en el código se prueben y sean de buena calidad antes de implementarse en la producción.
   

   4. Rentable

   

   Las pruebas automatizadas pueden ejecutarse sin intervención humana, lo que reduce el costo de las pruebas con el tiempo. Las pruebas automatizadas se pueden ejecutar de forma regular y se pueden programar para que se ejecuten en un momento específico, lo que reduce la necesidad 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() } }

   
   

   En este ejemplo, tenemos dos casos de prueba. El primero es para probar la función de búsqueda y el segundo es para probar la función de registro. Al tener múltiples casos de prueba en un solo script, aumenta la eficiencia general del proceso de prueba, lo que puede ayudar a reducir el costo total de la prueba.

   
   

   Además, puede usar la parametrización de prueba donde puede ejecutar el mismo caso de prueba con múltiples entradas y conjuntos de datos. Esto aumenta la cobertura general de las pruebas y ayuda a encontrar más errores, lo que reduce el costo total de las pruebas.

   
   

   Además, puede usar entornos de prueba basados en la nube como SauceLabs, BrowserStack y TestingBot, lo que le permite ejecutar sus pruebas en una variedad de navegadores y sistemas operativos sin tener que mantener su propia infraestructura de prueba. Esto puede reducir los costos asociados con el mantenimiento y el escalado de la infraestructura de prueba.

   
   

   En general, las pruebas automatizadas pueden ser rentables al reducir la necesidad de recursos humanos, aumentar la eficiencia del proceso de prueba y usar entornos de prueba basados en la nube.

   
   

   5. Aumenta la cobertura

   

   Las pruebas automatizadas pueden cubrir una amplia gama de escenarios, entradas y casos de uso que son difíciles de cubrir manualmente, lo que aumenta la cobertura general de las pruebas. Las pruebas automatizadas pueden cubrir diferentes navegadores, diferentes dispositivos, diferentes versiones del sistema operativo, diferentes conjuntos de datos y diferentes escenarios, lo que aumenta la cobertura general de las pruebas.

   
   

    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() } }

   
   

   En este ejemplo, usamos la anotación JUnit5 @ParameterizedTest y @CsvSource para ejecutar el mismo caso de prueba con varias entradas, lo que aumenta la cobertura general de la prueba. La prueba se ejecutará tres veces con diferentes valores de entrada y cada vez verificará si la salida coincide con el resultado esperado.

   
   

   De esta manera, puede probar la misma funcionalidad con múltiples conjuntos de datos, lo que ayuda a encontrar más errores y aumenta la cobertura general de la prueba. Además, también puede usar marcos de prueba basados en datos como TestNG, JUnit5, etc. para ejecutar los casos de prueba con múltiples entradas, lo que aumenta la cobertura general de la prueba.

   
   

   6. Mejora la consistencia Las pruebas automatizadas se ejecutan de la misma manera cada vez, lo que garantiza que no se pasen por alto los mismos problemas repetidamente. Las pruebas automatizadas son repetibles, consistentes y confiables, lo que reduce los falsos positivos y 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 el marco de trabajo de Gauge y la anotación @Step , que marca un método como un paso en el escenario de prueba. Esto permite que el escenario de prueba se escriba en un formato legible y comprensible, lo que facilita la comprensión del flujo de la prueba.

   
   

   También puede usar el concepto de prueba basada en datos del indicador, donde puede ejecutar el mismo escenario de prueba con múltiples entradas, aumentando la cobertura general de la prueba y potencialmente encontrando más errores.

   
   

   Además, puede utilizar la capacidad de generación de informes del indicador, que proporciona un informe claro y conciso de los escenarios de prueba, los resultados de la prueba y el tiempo de ejecución de la prueba.

   
   

   7. Permite la integración continua y la entrega continua

   

   Las pruebas automatizadas son un habilitador clave para la integración y entrega continuas, que es un aspecto crítico del desarrollo de software moderno. Las pruebas automatizadas se pueden integrar con la canalización de CI/CD y se pueden ejecutar automáticamente en cada cambio de código, lo que garantiza que los cambios de código se prueben y sean de buena calidad antes de implementarlos en la producción.

   
   

   Puede usar una canalización de CI/CD e integrar el script con ella, lo que permite que las pruebas se ejecuten automáticamente como parte de un proceso de compilación y con cada cambio de código.

   
   

   Por ejemplo, puede utilizar Jenkins, Travis, CircleCI, etc. como herramienta de CI/CD. Luego puede configurar el trabajo para compilar el proyecto, ejecutar los casos de prueba e implementar la aplicación en la producción si se aprueban las pruebas.

   
   

   Este es un aspecto crítico del desarrollo de software moderno y ayuda a lograr una entrega de software más rápida y confiable.

   
   

 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 una canalización con tres etapas: compilación, prueba e implementación.

En la etapa de compilación , la canalización ejecuta el comando './gradlew build'. Este comando construirá el proyecto y generará los artefactos necesarios.

En la etapa de prueba , la canalización ejecuta el comando 'gauge run specs/'. Este comando ejecutará todos los casos de prueba de calibre en la carpeta de especificaciones.

En la etapa de implementación , la canalización ejecuta el comando './deploy.sh'. Este comando implementará la aplicación en el entorno de producción.

Puede configurar el trabajo de Jenkins para ejecutar este Jenkinsfile y compilará, probará e implementará la aplicación si se aprueban las pruebas.

Con este ejemplo, puede ver cómo puede usar las pruebas de calibre en un archivo Jenkins para habilitar la integración continua y la entrega continua. Esto le permite automatizar el proceso de prueba.

Pensamientos finales

• Aumenta la eficiencia al permitir que se ejecuten múltiples casos de prueba en un solo script.

• Mejora la precisión al reducir el error humano y proporcionar resultados consistentes.

• Permite realizar pruebas frecuentes al facilitar la ejecución de pruebas de forma regular.

• Es rentable al reducir el costo total de las pruebas y aumentar la cobertura de las pruebas.

• Aumenta la cobertura al permitir que se ejecute el mismo caso de prueba con múltiples entradas y conjuntos de datos.

• Mejora la consistencia al garantizar que el software funcione como se espera.

• Habilita la integración continua y la entrega continua al permitir que las pruebas se ejecuten automáticamente como parte de un proceso de compilación, y con cada cambio de código, garantiza que los cambios de código se prueben y sean de buena calidad antes de implementarlos en la producción.

  
  

En general, las pruebas de automatización ayudan a mejorar la calidad general del software, reduciendo el costo total de las pruebas, aumentando la cobertura de las pruebas, mejorando la consistencia y permitiendo la integración continua y la entrega continua, lo que da como resultado una entrega de software más rápida y confiable.