Ejecutando Pruebas de Automatización a Gran Escala Utilizando Playwright
En este artículo, aprendemos sobre Playwright, cómo funciona y por qué es una buena opción para la automatización web con Java.
En el mundo del desarrollo web, elegir el framework adecuado para las pruebas de automatización puede ser una tarea difícil. En un panorama tecnológico en constante evolución, tomar decisiones informadas es crucial al elegir frameworks de automatización de pruebas para competir con Selenium.
Playwright, un framework de Node.js, es uno de esos frameworks que ha ganado popularidad recientemente. Su popularidad se puede atribuir a la popularidad de Node, que ha ayudado a Playwright a atraer una gran base de usuarios. Playwright es un poderoso framework de código abierto desarrollado por Microsoft para automatizar aplicaciones web. Tiene un conjunto único de características y capacidades que lo convierten en un framework valioso para desarrolladores y testers.
En este artículo, exploraremos el mundo de Playwright con Java. Comenzaremos aprendiendo sobre Playwright y cómo se puede utilizar para ejecutar casos de prueba a gran escala. Para lo mismo, aprenderemos sobre la ejecución de pruebas en la nube en la plataforma LambdaTest, que puede ayudar en la ejecución acelerada y en un ciclo de retroalimentación más rápido.
Entonces, empecemos.
- ¿Qué es Playwright?
- ¿Por qué elegir Playwright con Java?
- Configuración del framework para Playwright y Java
- Escribiendo el primer caso de prueba usando Playwright Java
- Ejecución de pruebas paralelas usando Playwright en LambdaTest
- Conclusión
¿Qué es Playwright?
Playwright es un framework de automatización de código abierto creado por Microsoft para probar y automatizar aplicaciones web. Este framework es compatible con Windows, macOS y Linux, y admite pruebas de automatización en varios navegadores en Chromium (Google Chrome, Microsoft Edge), Mozilla Firefox y WebKit (Apple Safari).
Es ampliamente utilizado porque es compatible con Java, Python, C# .NET y Node.js. Esto significa que puede ser utilizado por desarrolladores con una variedad de lenguajes de programación, lo que lo convierte en un framework versátil. Playwright es más efectivo para realizar pruebas de compatibilidad entre navegadores y web scraping que otros frameworks similares (por ejemplo, Selenium, Cypress, etc.) porque proporciona una API unificada de alto nivel para automatizar aplicaciones web en varios navegadores. Los testers pueden utilizar estas APIs para navegar a URL, interactuar con elementos, realizar acciones como completar formularios y extraer datos.
Playwright, que fue lanzado por primera vez en enero de 2020, ha ganado rápidamente popularidad debido a su estabilidad, su naturaleza de código abierto y su soporte para múltiples lenguajes como C#, Java y Python. Este soporte facilita a los usuarios migrar de frameworks existentes a Playwright. Su creciente popularidad se refleja en los números actuales de Microsoft Playwright en GitHub.
Con más de 36,000 usuarios activos, más de 3,000 forks y 450+ colaboradores activos, su popularidad seguirá creciendo.
Ventajas de Playwright
La última versión de Playwright, 1.38, incluye todas las características versátiles que el framework tiene para ofrecer. Admite pruebas con múltiples pestañas, múltiples usuarios y iframes, así como esperas incorporadas y personalizadas para cualquier acción de localización.
Además, algunas de las principales ventajas de usar Playwright para la automatización de pruebas web en comparación con otros frameworks son.
Playwright también soporta todos los principales lenguajes de programación, como C#, Python, .NET y JavaScript/TypeScript, lo que facilita la automatización de pruebas y la adición de aserciones para una variedad de aplicaciones. Estos casos de prueba pueden incluir flujos de navegación web, completar formularios, etc.
Escalabilidad
La escalabilidad se vuelve crucial con aplicaciones complejas que tienen conjuntos de pruebas más grandes y la necesidad de pruebas paralelas. Playwright ofrece alta escalabilidad al admitir la ejecución de pruebas en paralelo en múltiples navegadores y plataformas, tanto en entornos locales como en la nube.
Te permite escalar tu infraestructura de pruebas utilizando la contenerización de forma horizontal y la ejecución distribuida de casos de prueba, lo que proporciona una gestión eficaz de recursos. También permite la escalabilidad de los datos de prueba al integrarse con bases de datos y otras fuentes para casos de prueba parametrizados para pruebas orientadas por datos.
Amplio soporte de integraciones
Playwright ofrece soporte de integración para varias herramientas y tecnologías. Puede integrarse con
- Herramientas de CI/CD como Jenkins, Gitlab, etc.
- Herramientas de informes y frameworks de pruebas como Allure, Extent Reports o informes personalizados, y JUnit, TestNG, Cucumber, etc.
- Herramientas de pruebas de rendimiento y frameworks de pruebas de API.
- Plataformas de pruebas basadas en la nube como LambdaTest.
Smart built-in auto-wait
Playwright tiene una función de espera automática incorporada que no está disponible en otros frameworks. Esta función espera hasta que todos los elementos estén listos para interactuar antes de realizar acciones o verificarlos.
Este enfoque interno se puede utilizar para implementar tiempos de espera y condiciones, como visibilidad del elemento, disponibilidad del elemento para interactuar, navegación de página y finalización de llamadas de red.
Pruebas paralelas con aislamiento total de prueba
Playwright crea un contexto del navegador para cada prueba, que es como un nuevo perfil de navegador individual. Esto ayuda a ejecutar varios casos de prueba en paralelo y reduce el tiempo de ejecución.
Dado que cada prueba tiene un perfil de navegador separado, al igual que un hilo diferente en Selenium, todas las pruebas se ejecutan en completa aislamiento sin interferir entre sí. Esto ayuda a reducir las interferencias dentro de los casos de prueba, mejora la confiabilidad de las pruebas, facilita la depuración mediante registros y datos de prueba aislados, reduce la falta de coherencia y brinda entornos de prueba más limpios.
¿Por qué elegir Playwright con Java?
La combinación de Playwright y Java complementa las capacidades del otro y permite la escritura de casos de prueba de automatización más estables y escalables.
Admite varios lenguajes, pero Java es popular debido a su amplia adopción y ecosistema robusto. Java sigue siendo uno de los 3 lenguajes principales y ocupa los primeros 5 lugares en el último índice de lenguajes de programación de TIOBE, por lo que es familiar para muchos programadores y fácil de usar con Playwright. JDK 21 es la última versión con soporte a largo plazo de la plataforma Java SE.
Algunas otras ventajas que hacen de esta combinación una poderosa son:
Configuración sin problemas
La facilidad de configurar un marco de automatización de Playwright con Java lo convierte en la opción principal para tareas de automatización web. Playwright se proporciona como un conjunto de dependencias de módulos Maven que se pueden integrar fácilmente en un proyecto de Java.
Todas las versiones disponibles están listas en el sitio web de Maven y se pueden agregar como se muestra a continuación en su proyecto.
Compatibilidad multiplataforma
Java es un lenguaje independiente de la plataforma que le permite crear scripts de Playwright que se ejecutan en Linux, Windows o macOS. Esto es útil al trabajar con automatización web, ya que los casos de prueba deben ejecutarse en navegadores en todas las plataformas.
Al utilizar Java, se pueden utilizar los mismos casos de prueba y no es necesario volver a escribirlos en un nuevo lenguaje para cada plataforma.
Vínculos de lenguaje modernos
La API de Java de Playwright está diseñada para ser fácil de usar e idiomática para los probadores de Java. Proporciona API bien estructuradas que facilitan la escritura y el mantenimiento de scripts de automatización sin tener que aprender un nuevo lenguaje.
Documentación completa y soporte
Playwright tiene una extensa documentación sobre cómo trabajar con Java. Además, cuenta con una gran comunidad activa de desarrolladores de Java, lo que facilita encontrar recursos y obtener ayuda en caso de cualquier problema.
Configuración del marco para Playwright y Java
Configurar un proyecto de Playwright Java es bastante sencillo. Como se mencionó anteriormente, Playwright se proporciona como un conjunto de módulos Maven. Esto facilita mucho la configuración al agregar una dependencia al archivo pom.xml del proyecto de Maven.
A grandes rasgos, la configuración se puede dividir en tres partes:
- Instalar Java 11
- Crear un proyecto de Maven
- Agregar la dependencia de Maven de Playwright
Vamos a ver cada una de estas partes antes de escribir nuestro primer caso de prueba.
Instalar Java 11
Siga los siguientes pasos para instalar Java si aún no está instalado en su máquina.
Paso 1. Visite el sitio web oficial de Java y descargue la última versión compatible según su sistema operativo. Alternativamente, también puede optar por OpenJDK. Es de código abierto e idéntico a Oracle Java en términos de compilación y resultados.
Paso 2. Ejecute el archivo de instalación descargado y siga los pasos para instalar Java en su sistema.
Crear un proyecto de Maven
En este tutorial, se ha utilizado Eclipse IDE con fines de demostración. Sin embargo, puede usar cualquier IDE de su elección y crear un nuevo proyecto de Maven en él y luego continuar con los siguientes pasos.
Paso 1. Inicie Eclipse IDE → Seleccione Nuevo → Proyecto.
Paso 2. Elija Maven → Proyecto Maven y luego haga clic en Siguiente.
Paso 3. Completa los detalles del proyecto requeridos y nómbralo como PlaywrightJava. Se creará un nuevo proyecto como el siguiente:
Añadir la dependencia de Playwright para Maven
Playwright para Java está disponible como una dependencia de Maven. Para poder usarlo en tu proyecto,
Paso 1. Visita el sitio web de Maven y busca Playwright.
Paso 2. Selecciona la primera opción y luego selecciona la última versión estable disponible.
Paso 3. Copia los detalles de la dependencia y añádelos al archivo pom.xml de tu proyecto. Hemos utilizado la versión 1.38.0, que era la última versión al momento de escribir este artículo.
<dependency> <groupId>com.microsoft.playwright</groupId> <artifactId>playwright</artifactId> <version>1.38.0</version></dependency>
Con esto, hemos completado la configuración básica del proyecto y la instalación para poder comenzar a escribir el primer caso de prueba de automatización web de Playwright Java.
Escribiendo el Primer Caso de Prueba usando Playwright Java
Ahora, pasaremos a escribir nuestro primer caso de prueba de Playwright Java. Para ello, considera el siguiente escenario de prueba para navegar a una página web, realizar acciones en ella y verificar los resultados.
Ejecutaremos nuestros casos de prueba de Playwright en una red en la nube. La ejecución de automatización en la nube proporciona una mayor velocidad y escalabilidad, lo que hace que las pruebas de automatización sean más rápidas y confiables. También nos permite ejecutar varios casos en diferentes navegadores y sistemas operativos.
En este artículo, se utiliza la red en la nube de LambdaTest para lograr esto. LambdaTest es una plataforma de ejecución de pruebas impulsada por IA que permite a los usuarios realizar automatización de Playwright para aplicaciones web en una amplia gama de más de 3000+ navegadores reales y combinaciones de sistemas operativos. Veremos cómo se puede utilizar la misma plataforma en la nube para ejecutar pruebas individuales seguidas de ejecución en paralelo en diferentes navegadores.
Escenario de Prueba
- Navegar hasta el LambdaTest Playground.
- Haz clic en Input Form Submit.
- Verifica que se cargue la página de formulario de entrada.
- Rellena el formulario en la página de destino.
- Haz clic en el botón Submit.
- Verifica el mensaje de confirmación.
Para ejecutar el caso de prueba se ha utilizado TestNG. Añade la dependencia de TestNG junto con una dependencia de gson al pom.xml.
Gson, como se describe en el sitio web de Maven, es una biblioteca de Java que puede convertir objetos de Java en su representación JSON. Lo usaremos para crear un JsonObject para agregar propiedades en la nube para la plataforma LambdaTest y conectarse a la red en la nube. Estas propiedades ayudan a seleccionar el navegador y la plataforma para la ejecución, y a identificar los detalles de la ejecución en el panel de control de automatización web de LambdaTest para un mejor análisis y depuración de resultados.
El pom.xml final después de añadir todas las dependencias debería verse como el siguiente:
<project xmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>PlaywrightJava</groupId> <artifactId>PlaywrightJava</artifactId> <version>0.0.1-SNAPSHOT</version> <build> <sourceDirectory>src</sourceDirectory> <plugins> <plugin> <artifactId>maven-compiler-plugin</artifactId> <version>3.8.1</version> <configuration> <release>19</release> </configuration> </plugin> </plugins> </build> <dependencies> <dependency> <groupId>com.microsoft.playwright</groupId> <artifactId>playwright</artifactId> <version>1.38.0</version> </dependency> <dependency> <groupId>org.testng</groupId> <artifactId>testng</artifactId> <version>7.8.0</version> <scope>test</scope> </dependency> <dependency> <groupId>com.google.code.gson</groupId> <artifactId>gson</artifactId> <version>2.10.1</version> </dependency> </dependencies></project>
Habiendo completado la configuración del proyecto y creado el archivo pom con las dependencias actualizadas a utilizar, ahora pasamos a escribir nuestro primer caso de prueba de Playwright Java con ejecución en la nube.
El caso de prueba que vamos a escribir estará dividido en dos partes:
- Archivo de clase Java, que tendrá el flujo de prueba real, incluyendo la navegación, realización de acciones en la página web, llenado de datos y aserción del resultado.
- Archivo de caso de prueba, que contendrá el código para conectarse a la cuadrícula en la nube de LambdaTest y llamar a la ejecución del flujo de prueba definido en el primer archivo.
Empecemos ahora.
Agrega un paquete como base dentro del paquete src. Dentro de este, agrega un archivo nuevo y nómbralo SampleTestFlow.java. Este archivo tendrá la ejecución del escenario de prueba como se mencionó anteriormente y se verá así:
package base;import static com.microsoft.playwright.assertions.PlaywrightAssertions.assertThat;import com.microsoft.playwright.Locator;import com.microsoft.playwright.Page;public class SampleTestFlow { /* * Esta función se encarga de ejecutar el flujo de prueba. * Navega a la página web, llena y envía los datos, y verifica los mensajes de confirmación. */ public static void playwrightTestFlow(Page page) { try { // Navega al Lambdatest Selenium Playground page.navigate("https://www.lambdatest.com/selenium-playground/"); // Localiza el enlace Input Form Submit y haz clic en él Locator inputForm = page.locator("text=Input Form Submit"); inputForm.click(); // Verifica que se ha cargado la página de Input Form Submit assertThat(page.getByText("Input form validations")).isVisible(); // Llena los datos en el formulario fillInputFormData(page); // Haz clic en el botón Submit para enviar el formulario page.getByText("Submit").click(); // Obtén el mensaje de éxito, imprímelo en la consola y verifica que sea el mismo String successMessage = page.locator("xpath=//p[@class='success-msg hidden']") .textContent(); System.out.println(successMessage); assertThat(page.locator("xpath=//p[@class='success-msg hidden']")) .hasText("Thanks for contacting us, we will get back to you shortly."); } catch (Exception err) { err.printStackTrace(); } } /* * Esta función se encarga de llenar todos los campos requeridos del formulario en la página web */ private static void fillInputFormData(Page page) { page.locator("id=name").fill("Playwright"); page.locator("id=inputEmail4").fill("[email protected]"); page.locator("id=inputPassword4").fill("Playwright@123"); page.getByPlaceholder("Company").fill("Lambdatest"); page.getByPlaceholder("Website").fill("www.playwright.dev"); page.locator("xpath=//select[@name='country']").selectOption("IN"); page.locator("xpath=//input[@name='city']").fill("Gurgaon"); page.locator("xpath=//*[@name='address_line1']").fill("House 1"); page.locator("css=input#inputAddress2").fill("Sector 1"); page.locator("css=#inputState").fill("Haryana"); page.locator("id=inputState").fill("Haryana"); page.locator("css=input[name='zip']").fill("123456"); }}
Explicación del código: SampleTestFlow.java
Paso 1. Importa las interfaces Locator y Page del paquete playwright. La interfaz Locator se utiliza para encontrar un elemento web en cualquier momento, mientras que la interfaz Page interactúa con la página web durante todo el flujo de prueba utilizando sus métodos.
Además, debes importar el método assertThat de la interfaz PlaywrightAssertions estáticamente para verificar el mensaje de éxito en el flujo de prueba.
Paso 2. Agrega la primera función dentro de esta clase como playwrightTestFlow(). Esta función tendrá un parámetro – page – que se utilizará para interactuar con la página web.
El acceso public, junto con el tipo static de esta función, permitirá llamarla directamente en los archivos de clases de prueba utilizando el nombre de la clase sin crear un objeto.
Paso 3. Navega al LambdaTest Selenium Playground.
Paso 4. Localiza el enlace Input Form Submit en la página cargada y haz clic en él.
Playwright proporciona varios métodos de localización incorporados que se pueden utilizar para encontrar un elemento web en la página web usando instancias de page.
Además de estos métodos, también está disponible un método genérico locator() en el que podemos usar el enfoque comúnmente utilizado para localizar elementos web como XPath, id, name, text, CSS, etc., pasándolo como un par clave-valor en el argumento de la función.
En este paso, se utiliza el método locator(). Usamos el tipo text para localizar el elemento web y lo almacenamos en una variable de tipo Locator.
Luego, se utiliza esta variable para hacer clic en ella.
Paso 5. Asegurar que la página de demostración del formulario de entrada se ha cargado verificando la visibilidad de este texto en la página web.
Para la verificación, estamos utilizando el método assertThat(), que importamos al principio. Aquí se utiliza el método incorporado isVisible() de Playwright para comprobar si el elemento web dado es visible en la página o no.
Esta vez, utilizamos el localizador de elementos getByText() para obtener la referencia del elemento web.
Paso 6. Rellenar los datos en el formulario llamando a la función fillInputFormData() utilizando la instancia de page como parámetro.
Realizaremos una presentación de esta función después de que termine la actual.
Paso 7. Hacer clic en el botón Enviar para enviar el formulario de datos rellenado.
Para localizar el botón Enviar, se utiliza nuevamente el localizador getByText().
Paso 8. Obtener el localizador del mensaje de éxito después de enviar el formulario utilizando su XPath.
El contenido real del mismo se obtiene utilizando el método textContent() de la API de Playwright.
Registre este mensaje en la consola y verifíquelo para que sea una coincidencia exacta con el mensaje dado utilizando el método hasText() con la función assertThat.
Paso 9. Añadir la siguiente función como fillInputFormData(), que se utilizará para rellenar todos los datos en el formulario de entrada.
Esta función tomará una instancia de page como parámetro para interactuar con la página y localizar elementos web para rellenar datos.
Paso 10. Utilice el método page.locator() u otros métodos de localización para los campos en la página web para localizar y rellenar todos los datos en el formulario. Se utilizan diferentes identificadores para diferentes campos para mostrar el uso.
Para introducir datos en todos los campos de texto en el formulario, se utiliza el método fill(), que toma los datos a introducir como argumento de tipo String.
10.1) Para rellenar el nombre, el correo electrónico y la contraseña, se utiliza el método locator() con un identificador id.
10.2) Para empresa y sitio web, se utiliza el método de localización getByPlaceholder().
10.3) Dado que la opción de país es un desplegable, para seleccionar el valor del desplegable se utiliza el método selectOption() junto con XPath para localizar el elemento.
Además de esto, también se puede utilizar la etiqueta label o el índice del valor del desplegable para seleccionarlo.
10.4) Para ciudad y dirección línea 1, se demuestra el uso de page.locator() con XPath.
10.5) Por último, para todos los campos restantes, se utiliza un identificador CSS dentro del método locator() para localizar elementos y rellenar datos.
Con esto, hemos terminado de escribir y entender el código para el flujo del caso de prueba utilizando Playwright Java. Pasemos al archivo de la clase de prueba, que contendrá el código para la ejecución de pruebas en la plataforma LambdaTest.
Comienza agregando un nuevo paquete dentro de src y nómbralo test.cloud_execution. Dentro de él, agrega un archivo de prueba en Java, PlaywrightTestSingle.java.
paquete test.cloud_execution;import java.net.URLEncoder;import org.testng.annotations.Test;import com.google.gson.JsonObject;import com.microsoft.playwright.*;import base.SampleTestFlow;public class PlaywrightTestSingle { @Test public void playwrightTestSingle() { String username = System.getenv("LT_USERNAME") == null ? "<lambdatest_username>" : System.getenv("LT_USERNAME"); String accessKey = System.getenv("LT_ACCESS_KEY") == null ? "<lambdatest_accesskey>" : System.getenv("LT_ACCESS"); try (Playwright playwright = Playwright.create()) { JsonObject capabilities = new JsonObject(); JsonObject ltOptions = new JsonObject(); capabilities.addProperty("browsername", "Chrome"); capabilities.addProperty("browserVersion", "latest"); ltOptions.addProperty("platform", "Windows 10"); ltOptions.addProperty("name", "Playwright Single Cloud Test"); ltOptions.addProperty("build", "Playwright Java"); ltOptions.addProperty("user", username); ltOptions.addProperty("accessKey", accessKey); capabilities.add("LT:Options", ltOptions); String cdpUrl = "wss://cdp.lambdatest.com/playwright?capabilities=" + URLEncoder.encode(capabilities.toString(), "utf-8"); Browser browser = playwright.chromium().connect(cdpUrl); // Create BrowserContext object and use it to create a Page object to execute cases in isolation BrowserContext browserContext = browser.newContext(); Page page = browserContext.newPage(); SampleTestFlow.playwrightTestFlow(page); page.close(); browserContext.close(); browser.close(); playwright.close(); } catch (Exception err) { err.printStackTrace(); } }}
Recorrido del código: PlaywrightTestSingle.java
Paso 1. Agrega las siguientes importaciones a la clase de prueba para acceder a los métodos dentro de estos paquetes.
Importaciones de TestNG para poder usar la anotación @Test, biblioteca gson para crear JsonObject, paquete playwright para usar sus interfaces y clase SampleTestFlow para llamar al método de flujo de prueba.
Paso 2. Agrega el método de caso de prueba como playwrightTestSingle() y anótalo con la anotación @Test para poder ejecutar el caso de prueba.
Paso 3. Como se discutió anteriormente, ejecutaremos los casos en la red de nubes de LambdaTest para aprovechar la red en la nube y poder escribir casos de automatización más robustos y escalables. Para ello, debes crear una cuenta en la plataforma LambdaTest.
Después de crear la cuenta, obtén tu nombre de usuario y clave de acceso en la sección Contraseña y Seguridad de tu perfil de LambdaTest.
Alternativamente, también puedes configurar estos valores como variables de entorno y obtenerlos directamente en el código.
Para macOS y Linux:
export LT_USERNAME=LT_USERNAMEexport LT_ACCESS_KEY=LT_ACCESS_KEY
Para Windows:
set LT_USERNAME=LT_USERNAMEset LT_ACCESS_KEY=LT_ACCESS_KEY
Paso 4. Inicializa una nueva instancia de Playwright para acceder a la API de Playwright.
Paso 5. Crea 2 variables de tipo JsonObject y nómbralas como capabilities y ltOptions.
5.1) Utilizamos estas variables para definir las propiedades de la red de nubes de LambdaTest para Playwright. Estas incluyen definir el navegador, su versión y plataforma.
Los detalles de nombre y build del caso se pueden utilizar para filtrar los registros de ejecución en la plataforma LambdaTest.
Y, menciona el nombre de usuario y clave de acceso de la cuenta de LambdaTest con la que se creará la conexión.
Paso 6. Pasa el objeto capabilities a la URL que se utilizará para conectar con la red de nubes de LambdaTest para la ejecución de pruebas de Playwright.
Paso 7. Usando el objeto Playwright creado inicialmente, conecta con la red de la nube LambdaTest con el tipo de navegador Chromium. Asigna esto a un objeto de la interfaz del navegador.
Aquí estamos usando el tipo de navegador Chromium ya que ejecutaremos los casos en el navegador Chrome, que mencionamos en la propiedad browserName en el Paso 5.1.
Paso 8. Crea una nueva instancia de browserContext para crear un hilo separado para cada ejecución de prueba, de modo que cada caso de prueba se ejecute de forma aislada. BrowserContext puede operar múltiples sesiones de navegador independientes y se utiliza típicamente en ejecución paralela.
Esto es equivalente a ThreadLocal al trabajar con Selenium para la automatización web, para crear un hilo separado para cada ejecución de prueba.
Paso 9. Dentro del browserContext, crea una page. Todas las acciones correspondientes en el flujo del caso de prueba se realizan utilizando esta instancia de page.
Cada BrowserContext puede tener múltiples páginas. Una Page es una ventana o pestaña del navegador única que se abre en un contexto de navegador. Proporciona varios métodos para interactuar con la página web. Estos métodos incluyen crear una nueva página, navegar a URLs, localizar elementos web en la página web, e interactuar con elementos de la página para realizar acciones.
Paso 10. Llama a la función playwrightTestFlow() dentro de la clase SampleTestFlow utilizando la instancia de page. Esto ejecutará el escenario de prueba y realizará las interacciones y aserciones de elementos web.
Paso 11. Después de la ejecución de la prueba, cierra las instancias de Playwright, BrowserContext, Browser y Page para limpiar los recursos utilizando el método close().
Ejecución de Código
Ejecuta el caso de prueba de Playwright anterior ejecutándolo como una prueba TestNG.
Para esto, haz clic derecho y selecciona Ejecutar como → Prueba TestNG. Al ejecutarlo, obtendrás una salida como la siguiente en local:
También puedes ver los resultados de la ejecución en el panel de control de LambdaTest navegando a la sección Automatización → Automatización web.
Ejecutando Pruebas Paralelas usando Playwright en LambdaTest
Con la ejecución anterior, hemos entendido los pasos de configuración del proyecto Java de Playwright, cómo escribir el primer caso de prueba de automatización usando la combinación y cómo ejecutarlo en la nube.
Entonces, veamos qué cambios adicionales se deben hacer para ejecutar el mismo escenario de prueba de forma paralela en 2 navegadores.
Para eso, usaremos el atributo parallel = true de la anotación @DataProvider de TestNG.
Dentro del paquete existente test.cloud_execution, agrega 2 archivos de clase Java adicionales:
- PlaywrightTestParallel.java para el caso de prueba con ejecución paralela
- LambdaTestCapabilities.java para pasar las capacidades de 2 configuraciones de navegador diferentes para la ejecución mediante el
DataProvider.
El archivo actualizado LambdaTestCapabilities.java, con 2 capacidades de navegador para ejecución paralela en la nube, se vería así:
package test.cloud_execution;import org.testng.annotations.DataProvider;import com.google.gson.JsonObject;public class LambdaTestCapabilities { @DataProvider(name = "BrowserCapabilities", parallel = true) public static Object[] getDefaultTestCapability() { String username = System.getenv("LT_USERNAME") == null ? "<lambdatest_username>" : System.getenv("LT_USERNAME"); String accessKey = System.getenv("LT_ACCESS_KEY") == null ? "<lambdatest_accesskey>" : System.getenv("LT_ACCESS"); //capacidades para el primer navegador - Chrome JsonObject capabilities1 = new JsonObject(); JsonObject ltOptions1 = new JsonObject(); capabilities1.addProperty("browserName", "Chrome"); capabilities1.addProperty("browserVersion", "latest"); ltOptions1.addProperty("platform", "Windows 10"); ltOptions1.addProperty("name", "Playwright Parallel Test - Chrome"); ltOptions1.addProperty("build", "Playwright Java Parallel Cloud"); ltOptions1.addProperty("user", username); ltOptions1.addProperty("accessKey", accessKey); capabilities1.add("LT:Options", ltOptions1); //capacidades para el segundo navegador - Edge JsonObject capabilities2 = new JsonObject(); JsonObject ltOptions2 = new JsonObject(); capabilities2.addProperty("browserName", "MicrosoftEdge"); capabilities2.addProperty("browserVersion", "latest"); ltOptions2.addProperty("platform", "Windows 10"); ltOptions2.addProperty("name", "Playwright Parallel Test - Edge"); ltOptions2.addProperty("build", "Playwright Java Parallel Cloud"); ltOptions2.addProperty("user", username); ltOptions2.addProperty("accessKey", accessKey); capabilities2.add("LT:Options", ltOptions2); return new Object[] { capabilities1, capabilities2 }; }}
Recorrido del código: LambdaTestCapabilities.java
Paso 1. Dentro de la clase, agrega un nuevo método llamado getDefaultTestCapability(). Anota este método con la anotación @DataProvider de TestNG.
Este método se utilizará para pasar los datos de prueba, que en este caso son las capacidades del navegador, para su ejecución en la nube de Lambdatest Playwright en 2 navegadores: Chrome y Edge. Los casos de prueba se ejecutarán en paralelo en ambos navegadores.
Puedes notar que se utiliza el atributo name con el valor BrowserCapabilities junto con la anotación @DataProvider. Este es el nombre que utilizamos en nuestro caso de prueba para definir qué proveedor de datos se utilizará para la ejecución.
Lo más importante a tener en cuenta aquí es el atributo parallel = true con la anotación. Esto es lo que le indica a TestNG que todos los datos se pasen al caso de prueba y luego se utilicen para la ejecución en paralelo en la nube.
Paso 2. Como estamos ejecutando nuestros casos de Playwright Java en la nube de LambdaTest, obtén tu nombre de usuario y clave de acceso de la sección Contraseña y Seguridad una vez que hayas creado tu cuenta en la plataforma de LambdaTest.
Alternativamente, también puedes configurar estos valores en variables de entorno y obtener el valor de allí, como discutimos en el caso de prueba anterior.
Paso 3. Crea las capacidades del navegador para dos navegadores diferentes en los que ejecutaremos nuestros casos de Playwright en paralelo.
3.1) Crea 2 JsonObjects capabilities1 y ltOptions1 para el primer navegador, Chrome, con las configuraciones correspondientes.
3.2) Agrega todas las configuraciones relacionadas con el navegador y la plataforma de LambdaTest a estos objetos, tal como lo hicimos para la ejecución en la nube individual.
3.3) De manera similar, crea capabilities2 y ltOptions2 para el segundo navegador, Edge, con las configuraciones correspondientes.
3.4) De manera similar a Chrome, agrega todos los detalles de la configuración en los nuevos JsonObjects con los cambios necesarios para Edge. La diferencia importante a tener en cuenta aquí es el valor de browserName.
Paso 4. Devuelve ambos objetos de capacidades que serán utilizados por el caso de prueba para la ejecución de pruebas en paralelo de Playwright.
Una vez hecho esto, pasa al archivo de clase de prueba para ejecutar los casos de prueba.
package test.cloud_execution;import java.net.URLEncoder;import org.testng.annotations.Test;import com.google.gson.JsonObject;import com.microsoft.playwright.*;import base.SampleTestFlow;public class PlaywrightTestParallel { @Test(dataProvider = "BrowserCapabilities", dataProviderClass = LambdaTestCapabilities.class) public void playwrightTestParallel(JsonObject capability) { try (Playwright playwright = Playwright.create()) { String cdpUrl = "wss://cdp.lambdatest.com/playwright?capabilities=" + URLEncoder.encode(capability.toString(), "utf-8"); Browser browser = playwright.chromium().connect(cdpUrl); // Create BrowserContext object and use it to create a Page object to execute cases in isolation BrowserContext browserContext = browser.newContext(); Page page = browserContext.newPage(); SampleTestFlow.playwrightTestFlow(page); page.close(); browserContext.close(); browser.close(); playwright.close(); } catch (Exception err) { err.printStackTrace(); } }}
Recorrido del código: PlaywrightTestParallel.java
Paso 1. Crea un nuevo método de prueba llamado playwrightTestParallel(). Este método tomará un objeto de capacidad JsonObject como parámetro, que contendrá las capacidades del navegador pasadas desde el proveedor de datos de prueba creado en el paso anterior.
Anota este caso de prueba con la anotación @Test de TestNG. Dentro de la anotación, agrega los atributos
dataProvider = "BrowserCapabilities", para indicar el nombre del proveedor de datos que se utilizará para este caso de prueba.dataProviderClass = LambdaTestCapabilities.class, para indicar el nombre de la clase Java en la que se encuentra este proveedor de datos.
Paso 2. Inicializa una nueva instancia de Playwright para acceder a la API de Playwright.
Paso 3. Utiliza el objeto capability del parámetro de prueba para crear la URL para conectarse a la nube de LambdaTest para la ejecución de pruebas de Playwright Java.
Paso 4. Con el objeto playwright creado inicialmente, llama a la función chromium() con la URL para abrir el navegador y asígnalo a un objeto de interfaz de navegador.
Estamos utilizando el tipo de navegador chromium() ya que en este caso de ejecución paralela, se utilizan los navegadores Chrome y MicrosoftEdge, y ambos son compatibles con este tipo de navegador.
Paso 5. Utiliza el objeto browser para crear un browserContext, que ayudará a ejecutar ambos casos en paralelo pero de forma aislada sin afectar uno al otro.
Paso 6. Utilizando el browserContext, crea una nueva instancia de page que representa la ventana/pestaña del navegador en la que se ejecutará.
Paso 7. Llama al método playwrightTestFlow() previamente creado de la clase SampleTestFlow para ejecutar el escenario de prueba. Esta es la función común utilizada tanto para ejecución individual como paralela sin ninguna modificación.
Paso 8. Finalmente, utiliza el método close() para cerrar todas las instancias y liberar la memoria.
Ejecución de código
Ejecuta el caso de prueba como una prueba TestNG para comprobar los resultados de ejecución.
Puedes observar en la captura de pantalla a continuación que se ejecutan un total de 2 casos.
Los resultados de ejecución se pueden ver en el panel de control de LambdaTest en la sección Automation → Web Automation como se muestra a continuación.
Si deseas confirmar si la ejecución en paralelo funciona o no, actualiza el valor del atributo parallel en la anotación @DataProvider como false y ejecuta nuevamente.
En estos resultados de ejecución, puedes observar un tiempo de ejecución total significativamente mayor en IDE y en los resultados del panel de control de LambdaTest. Esto confirma que la ejecución anterior fue en paralelo y esta vez los casos se ejecutan en serie.
Con esto, hemos aprendido cómo escribir automatización con Playwright a gran escala y ejecutarla en paralelo en la nube de LambdaTest.
Conclusión
Esto concluye nuestro artículo sobre cómo ejecutar pruebas de automatización con Playwright Java. En este artículo, aprendimos sobre Playwright, cómo funciona y por qué es una buena opción para la automatización web con Java. También aprendimos cómo ejecutar casos de automatización con Playwright a gran escala utilizando la nube de LambdaTest. Ahora tienes una base sólida para enfrentar desafíos de automatización complejos con Playwright. ¡Así que es hora de comenzar y escribir tu primer script de automatización usando Playwright con Java!
Leave a Reply