Indice
1. Introducción
El testing automatizado de un frontal web es una de las prácticas más extendidas en QA, especialmente en tests de regresión sobre funcionalidades estables, donde el ROI es más evidente. Algunas de sus ventajas más destacadas son:
- Repetición del testeo en múltiples navegadores y plataformas: Una vez definidos los tests, pueden ejecutarse en distintos sistemas operativos, navegadores o configuraciones de idioma.
- Ejecución desatendida: Aunque los tiempos de ejecución pueden ser largos, los tests pueden programarse para ejecutarse en un horario específico, finalizando sin intervención humana. Además, los resultados pueden almacenarse automáticamente en un dashboard de Jira para su análisis.
- Uniformidad y fiabilidad: Los tests automáticos siguen exactamente los pasos definidos, minimizando errores humanos y garantizando la precisión en la validación de funcionalidades nuevas o la detección de regresiones.
Selenium es un framework de desarrollo de tests automatizados compatible con Jira y múltiples lenguajes de programación. Permite la ejecución de pruebas en navegadores como Chrome, Safari y Firefox, entre otros. En nuestros proyectos, lo utilizamos con frecuencia y, en este artículo, servirá como modelo. Sin embargo, uno de los desafíos más comunes es proporcionar visibilidad de los resultados a personas fuera del equipo de automatización.
Por su parte, Jira es una herramienta de gestión de proyectos que permite implementar tanto metodologías ágiles como enfoques tradicionales. Con el complemento XRAY, es posible gestionar pruebas mediante tareas específicas para la especificación, ejecución y reporte de resultados, admitiendo formatos como texto libre, pasos detallados o código Gherkin. Además, permite adjuntar evidencias, enlazar defectos y vincular pruebas a requisitos del sistema.
En este artículo, explicaremos cómo integrar Selenium y XRAY para ejecutar pruebas automatizadas y registrar sus resultados en Jira, obteniendo dashboards listos para su análisis. Asumimos que ya tienes conocimientos de Selenium, por lo que nos centraremos en el código necesario para esta integración.
2. Testing automático con Selenium
En este apartado, hacemos una breve descripción de la estructura de nuestros tests automáticos en Selenium, con el objetivo de facilitar la comprensión del código específico para la integración con XRay, que se abordará en la siguiente sección.
El proyecto está desarrollado en Java y utiliza Apache Maven como gestor de dependencias y construcción. Su estructura típica es la siguiente:
pom.xml: Archivo de configuración principal de Maven, donde se declaran las dependencias, plugins y configuraciones del proyecto.src/main/java: Directorio que contiene el código fuente principal del proyecto. Aquí se encuentra la claseBaseTest.java, de la cual heredan todos los tests. También incluye la carpetaUtil, que almacena funciones auxiliares para establecer la conexión con XRay y reportar los resultados.src/test/java: Directorio que alberga el código fuente de las pruebas. En él se encuentran las clases de prueba, que contienen los tests automatizados en Selenium.src/test/resources: Carpeta donde se almacenan los recursos necesarios para la ejecución de las pruebas, como archivos de configuración y datos de prueba.
2.1. Tests de ejemplo
Los tests se encuentran en la carpeta src/test/java/izertis/tests. Cada test es un archivo Java independiente y, por convención interna, su nombre coincide con el identificador del test en Jira, donde se volcarán los resultados.
Para simplificar el proceso, estos tests contienen únicamente la programación mínima necesaria. Uno de ellos está diseñado para fallar, mientras que otro siempre arroja un resultado positivo. El objetivo de este artículo no es profundizar en la programación de tests en Selenium, sino enfocarse en la integración con Jira.
El test XRI_1_test.java siempre devuelve un resultado positivo, ya que no realiza ninguna acción después de abrir la página web.
|
Java
|
|
|---|---|
|
package izertis.tests;
import com.example.tests.BaseTest; import com.example.tests.PortalInstance; import izertis.objects.HomePageObjects; import izertis.objects.MastersAndProgramsObjects; import izertis.objects.SearchResultsPageObjects; import org.testng.annotations.Optional; import org.testng.annotations.Test; public class XRI_1_test extends BaseTest { // Test que abre la página web de Izertis y concluye sin ninguna acción ni assert public XRI_1_test() { super(); } MastersAndProgramsObjects mastersAndProgramsObjects = new MastersAndProgramsObjects(driver); HomePageObjects homePage = new HomePageObjects(driver); SearchResultsPageObjects searchResultsPage = new SearchResultsPageObjects(driver); @Test(dataProvider = "getParams") public void XRI_1(@Optional("chrome,desktop") String browser, String platform) { configureDriver(browser, platform); PortalInstance.getInstance().setUrl("izertis"); driver.get(PortalInstance.getInstance().getUrl()); } } |
|
Su equivalente en Jira es este caso de test, más completo que la implementación:
Por otro lado, el test XRI_11_test.java siempre genera un resultado negativo, ya que intenta hacer clic en un botón que no existe (se usa findElement sobre un elemento intencionadamente erróneo).
|
Java
|
|
|---|---|
|
package izertis.tests;
import com.example.tests.BaseTest; import com.example.tests.PortalInstance; import izertis.objects.HomePageObjects; import izertis.objects.MastersAndProgramsObjects; import org.openqa.selenium.By; import org.testng.annotations.Optional; import org.testng.annotations.Test; public class XRI_11_test extends BaseTest { public XRI_11_test() { super(); } HomePageObjects homePage = new HomePageObjects(driver); MastersAndProgramsObjects mastersAndProgramsObjects = new MastersAndProgramsObjects(driver); @Test(dataProvider = "getParams") public void XRI_11(@Optional("chrome,desktop") String browser, String platform) { configureDriver(browser, platform); PortalInstance.getInstance().setUrl(portal:"izertis"); driver.get(PortalInstance.getInstance().getUrl()); homePage = new HomePageObjects(driver); if (driver. .findElement(By.cssSelector(cssSelector:"boton_erroneo-btn-handler")) .isDisplayed() } { driver.findElement(By.cssSelector(cssSelector:"boton_erroneo-btn-handler")).click(); } else {} } } |
|
En Jira, este test tiene su correspondiente caso de prueba, aunque deliberadamente no está correctamente implementado en Selenium, ya que el propósito es observar cómo se comporta la integración en un escenario de error.
Por otro lado, en la carpeta src/test/java/suites se encuentra el archivo Izertis.xml, que agrupa los casos de prueba en una suite. Esta suite puede ser referenciada desde la línea de comandos para ejecutar los tests de forma estructurada.
En Java, esto se corresponde con un test plan:
Tras la creación de este test plan en Jira, es necesario anotar su identificador (XRI-11), ya que se requerirá en el código para referenciarlo. A lo largo del artículo, nos referiremos a él como <Jira-Test-Plan-ID>. También es importante recordar el identificador del proyecto (en este caso, “XRI”), que aparecerá en el código como <Jira-project>.
2.2 Lanzamiento de los tests
Para ejecutar los tests definidos en la suite, se utiliza el siguiente comando:
|
Bash
|
|
|---|---|
|
mvn test '-Dsurefire.suiteXmlFiles=src/test/java/suites/izertis.xml' -Dbrowser=chrome -Dreport=false
|
|
Explicación de los parámetros:
-Dsurefire.suiteXmlFiles=src/test/java/suites/izertis.xml→ Especifica la suite de TestNG a ejecutar.-Dbrowser=chrome→ Define el navegador en el que se ejecutarán las pruebas.-Dreport=false→ Indica que no se generará un reporte tras la ejecución.
Una vez lanzados los tests, la consola muestra los resultados de la ejecución, indicando que uno de los tests ha sido exitoso y otro ha fallado.
Detalles del error mostrado:
El test fallido lanza un NoSuchElementException, lo que indica que un elemento esperado en la página no ha sido encontrado. Este error suele deberse a:
- Un selector incorrecto o mal definido (
CSS SelectoroXPathinválido). - El elemento no ha sido cargado antes de que el test lo busque (solucionable con waits en Selenium).
- Cambios en la estructura del DOM de la aplicación.
2.3 Informe de resultados con Allure
Tras ejecutar nuestra suite de pruebas, podemos analizar los resultados de una forma más visual y detallada utilizando Allure Report. Este sistema proporciona un resumen gráfico interactivo, con métricas detalladas sobre la ejecución de los tests, facilitando la detección de errores y la optimización de los procesos de prueba.
2.3.1 Generación del reporte con Allure
Para visualizar los resultados de los tests, se utiliza el siguiente comando en la terminal:
|
Bash
|
|
|---|---|
|
mvn allure:serve
|
|
Este comando iniciará un servidor local y abrirá automáticamente el reporte de Allure en el navegador.
2.3.2. Visión general del informe de Allure
El dashboard de Allure presenta un resumen interactivo con información detallada sobre:
- Número total de pruebas ejecutadas.
- Cantidad de tests exitosos y fallidos.
- Duración de la ejecución de cada prueba.
- Distribución de errores y defectos detectados.
2.3.3. Detalle de un test exitoso en Allure
Un test exitoso en Allure muestra los siguientes detalles:
- Estado: Passed (éxito).
- Duración total.
- Parámetros utilizados (ejemplo: navegador y plataforma).
- Fases del test: configuración, ejecución y cierre (
setUp,tearDown).
2.3.4. Detalle de un test fallido en Allure con error NoSuchElementException
Cuando un test falla, Allure permite inspeccionar en detalle los motivos del fallo. En este caso, el test XRI_11_test falló debido a un error NoSuchElementException, lo que indica que no se encontró un elemento en la página web.
El reporte muestra:
- Estado: Broken (fallido).
- Mensaje de error y stack trace.
- Categoría del fallo:
Test Defects. - Parámetros utilizados.
Este error suele ocurrir cuando:
- Un selector CSS o XPath es incorrecto.
- El elemento no ha sido cargado completamente antes de ser buscado.
- Ha habido cambios en el DOM de la aplicación.
3. Integración de los resultados a XRay y Jira
Para registrar los resultados de las pruebas automatizadas en XRAY y Jira, es necesario establecer una conexión segura con estas herramientas. En este capítulo, detallaremos los datos requeridos para la autenticación, como el API-Token de Jira y el Client Secret de XRAY.
Luego, explicaremos cómo implementar la integración, desde la autenticación en ambas plataformas hasta el envío de los resultados, incluyendo la captura de screenshots, la generación del informe de ejecución y la subida de datos a Jira y XRAY.
Finalmente, abordaremos la validación de los resultados, revisando el Test Execution, analizando el Test Plan y verificando las evidencias en los casos de prueba fallidos. Este proceso garantiza un mejor control y trazabilidad del estado de las pruebas.
3.1. Datos necesarios para la conexión
Para integrar los resultados de las pruebas automatizadas en XRAY y Jira, es fundamental obtener las credenciales necesarias para la autenticación. Tanto Jira como XRAY requieren autenticación basada en tokens en lugar de credenciales tradicionales de usuario y contraseña. En esta sección, detallaremos cómo obtener el API-Token de Jira y el Client Secret de XRAY, ambos esenciales para interactuar con sus respectivas APIs.
3.1.1. Obtención del API-Token de Jira
Para autenticar las solicitudes a la API de Jira Cloud, es necesario generar un API-Token, el cual permite la autenticación segura sin exponer credenciales sensibles.
Pasos para generar el API-Token de Jira:
-
Acceder a la configuración de la cuenta:
Inicia sesión en Atlassian y dirígete a Atlassian API Tokens. -
Generar un nuevo API-Token:
-
Haz clic en "Create API Token".
Interfaz de Atlassian Account para la gestión de API Tokens en Jira, necesarios para la autenticación en la API sin usar credenciales tradicionales. -
Asigna un nombre al token para identificarlo fácilmente (ejemplo: Integración XRAY).
-
Copia el token generado y guárdalo en un lugar seguro.
Vista de la interfaz de Atlassian Account al generar un API Token en Jira, con la opción de copiar el token para su uso en la API.
-
-
Uso del API-Token en autenticación:
Las solicitudes a la API de Jira deben incluir el token en la cabecera de autenticación utilizando el esquema Basic Auth, donde el usuario es tu correo de Atlassian y la contraseña es el token generado.
Ejemplo de cabecera en una solicitud a la API de Jira:
|
Bash
|
|
|---|---|
|
Authorization: Basic base64(email:api_token)
|
|
Ejemplo en cURL:
|
Bash
|
|
|---|---|
|
curl -u "tu_email@empresa.com:API_TOKEN" -X GET "https://tu_dominio.atlassian.net/rest/api/3/project"
|
|
3.1.2. Obtención del Client Secret de XRay
Para subir los resultados de pruebas a XRAY, es necesario autenticarse en su API, que utiliza el protocolo OAuth 2.0. Para ello, debemos obtener las credenciales Client ID y Client Secret desde la configuración de XRAY.
Pasos para obtener el Client Secret de XRay:
-
Verificar permisos de administración en Jira
- La opción de gestión de API Keys en XRAY solo está disponible para usuarios con permisos de administración.
- Si la opción "Manage your apps" no aparece en el menú, contacta con un administrador de Jira para obtener acceso.
Menú «Apps» en Jira, donde los administradores pueden acceder a «Manage your apps» para configurar API Keys en XRay y gestionar permisos de integración.
-
Acceder a la administración de XRAY
- Inicia sesión en Jira y ve a la sección "Apps" → "XRay".
- Dentro de la configuración, accede a "API Keys" (Solo visible para administradores).
Vista del panel de administración en Jira, donde se gestionan las aplicaciones instaladas como XRay, permitiendo la configuración de API Keys para integraciones con herramientas externas.
-
Generar un nuevo Client ID y Client Secret:
- Haz clic en "Generate New API Key".
- Copia el Client ID y Client Secret que se generen, ya que serán necesarios para autenticarse en la API de XRAY.
Autenticación con XRay usando Client ID y Client Secret
Para obtener un token de acceso, se debe hacer una solicitud POST a la API de XRAY:
Ejemplo de autenticación con XRAY en cURL:
|
Bash
|
|
|---|---|
|
curl -X POST "https://xray.cloud.getxray.app/api/v2/authenticate" \
-H "Content-Type: application/json" \ -d '{"client_id": "TU_CLIENT_ID", "client_secret": "TU_CLIENT_SECRET"}' |
|
La respuesta incluirá un token de acceso, que deberá usarse en las peticiones siguientes a la API para subir los resultados de los tests.
Ejemplo de respuesta:
json
{
"token": "eyJhbGciOiJIUzI1…"
}
Uso del token de autenticación en solicitudes a la API de XRAY:
Una vez obtenido el token, todas las solicitudes a la API de XRAY deben incluirlo en la cabecera Authorization:
|
Bash
|
|
|---|---|
|
Authorization: Bearer TU_TOKEN
|
|
3.2 Implementación de la integración
Una vez obtenidas las credenciales necesarias (API Token de Jira y Client Secret de XRay), podemos proceder con la implementación de la integración. Este proceso se divide en tres pasos principales:
- Autenticación en Jira para permitir la interacción con su API.
- Autenticación en XRay utilizando OAuth 2.0 para el envío de datos.
- Envío de los resultados de los tests, incluyendo capturas de pantalla, generación del informe de ejecución y subida de datos a Jira y XRay.
A continuación, se detalla cada uno de estos pasos con ejemplos prácticos.
3.2.1. Autenticación en Jira
Para interactuar con la API de Jira, se requiere autenticación utilizando un API Token generado previamente. La autenticación en Jira se realiza mediante Basic Auth, combinando el correo electrónico del usuario y el token de acceso en formato Base64.
Autenticación en Jira con cURL
|
Bash
|
|
|---|---|
|
curl -u "tu_email@empresa.com:TOKEN_GENERADO" -X GET "https://tu_dominio.atlassian.net/rest/api/3/project"
|
|
Ejemplo en Java con HttpClient
|
Java
|
|
|---|---|
|
import java.net.URI;
import java.net.http.HttpClient; import java.net.http.HttpRequest; import java.net.http.HttpResponse; import java.nio.charset.StandardCharsets; import java.util.Base64; public class JiraApiRequest { public static void main(String[] args) { String JIRA_URL = "https://tu_dominio.atlassian.net"; String API_TOKEN = "TOKEN_GENERADO"; String EMAIL = "tu_email@empresa.com"; try { // Codificar credenciales en Base64 String auth = EMAIL + ":" + API_TOKEN; String encodedAuth = Base64.getEncoder().encodeToString(auth.getBytes(StandardCharsets.UTF_8)); // Crear cliente HTTP HttpClient client = HttpClient.newHttpClient(); // Construir solicitud HTTP GET HttpRequest request = HttpRequest.newBuilder() .uri(URI.create(JIRA_URL + "/rest/api/3/project")) .header("Accept", "application/json") .header("Authorization", "Basic " + encodedAuth) .GET() .build(); // Enviar solicitud y obtener respuesta HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString()); // Imprimir respuesta JSON System.out.println(response.body()); } catch (Exception e) { e.printStackTrace(); } } } |
|
Si la autenticación es correcta, la API de Jira devolverá un código 200 con la información solicitada.
Si la autenticación falla, se recibirá un código de error 401 (Unauthorized), lo que puede indicar que el API Token no es válido o no tiene permisos suficientes.
Autenticación en Jira con JiraRestClient
En lugar de realizar solicitudes manuales con HttpClient, es posible utilizar la librería oficial de JiraRestClient, que facilita la integración con Jira.
Ejemplo de autenticación con JiraRestClient
|
Java
|
|
|---|---|
|
import java.net.URI;
import com.atlassian.jira.rest.client.api.JiraRestClient; import com.atlassian.jira.rest.client.internal.async.AsynchronousJiraRestClientFactory; public class JiraAuth { public static JiraRestClient authJira() { // URL del servidor de Jira URI serverUri = URI.create("https://tu_proyecto.atlassian.net/"); // Reemplazar con <url_jira> // Credenciales de acceso String username = "usuario.jira@test.com"; // Reemplazar con <usuario_jira> String apiToken = "X0X9..........X999XX"; // Reemplazar con <api_token_jira> // Creación del cliente REST de Jira con autenticación básica return new AsynchronousJiraRestClientFactory() .createWithBasicHttpAuthentication(serverUri, username, apiToken); } } |
|
Uso del método de autenticación
El método authJira() se invoca dentro de createReport(), el cual se ejecuta al finalizar una suite de tests para registrar los resultados en Jira.
|
Java
|
|
|---|---|
|
public void createReport() {
System.out.println("📄 Generando reporte en Jira para los siguientes tests:"); JiraRestClient jiraRestClient = authJira(); // Lógica de generación de reportes... } |
|
3.2.2. Autenticación en XRay
Para conectar con XRay y enviar los reportes de ejecución a Jira, es necesario autenticarse mediante OAuth 2.0. La autenticación se realiza en el momento de la generación del reporte, utilizando las credenciales proporcionadas en la configuración del sistema.
Implementación de la autenticación en XRay
La conexión con XRay se establece durante la ejecución del código que envía los resultados de los tests a Jira-XRay. Este proceso es gestionado por la clase GraphQLExecutor, que interactúa con la API de XRay a través de GraphQL.
Código de ejemplo para autenticación en XRay
|
Java
|
|
|---|---|
|
graphQLExecutor = new GraphQLExecutor("https://xray.cloud.getxray.app/api/v2/graphql");
try { graphQLExecutor.setBearerToken( clientId: "<Xray_client_id>", // Sustituir por el Client ID de XRay clientSecret: "<Xray_client_secret>" // Sustituir por el Client Secret de XRay ); create_test_executionDebug(); // Llamada a la generación del reporte } catch (Exception e) { e.printStackTrace(); } |
|
Ejecución en el flujo del reporte
🔹 Autenticación en XRay: Se realiza dentro de GraphQLExecutor, donde se obtiene el token de acceso.
🔹 Generación del reporte: La función create_test_executionDebug() es invocada tras autenticarse, asegurando que los resultados sean registrados correctamente.
🔹 Ejecución tras la suite de tests: La llamada create_report() se realiza dentro de afterSuite, lo que garantiza que la integración con XRay se complete después de ejecutar todas las pruebas.
3.2.3. Envío de resultados de los tests
El proceso de envío de resultados se gestiona a través de la clase BaseTest.java, encargada de registrar la ejecución de cada prueba, capturar evidencias en caso de fallos y generar un reporte automático en Jira-XRay.
1. Importación de Dependencias
En la clase BaseTest.java se incluyen las siguientes importaciones esenciales:
|
Java
|
|
|---|---|
|
import com.example.Utils.JiraReporter;
import com.example.Utils.TestInfo; import com.example.Utils.TestResult; import io.qameta.allure.Allure; import org.testng.ITestResult; import org.testng.annotations.AfterMethod; import org.testng.annotations.AfterSuite; import org.testng.annotations.BeforeSuite; import org.testng.annotations.DataProvider; |
|
2. Inicialización y Almacenamiento de Resultados
Antes de ejecutar los tests, se inicializa un singleton para almacenar la información de cada prueba. Este proceso se gestiona en la clase TestInfo.
|
Java
|
|
|---|---|
|
@BeforeSuite
public void beforeSuite() { TestResult.getInstance().setTestInfoList(new ArrayList<>()); // Inicializa la lista de resultados TestResult.setStartTime(System.currentTimeMillis()); // Registra la hora de inicio de la ejecución } |
|
¿Qué información se almacena?
Cada test ejecutado se registra con los siguientes datos clave:
- Nombre del test
- Resultado (PASSED / FAILED)
- Marca de tiempo (inicio y finalización)
- Evidencias (capturas de pantalla en caso de error)
- Detalles del error (si corresponde)
Esta estructura permite consolidar toda la información necesaria para el reporte en Jira-XRay y facilita el análisis posterior de la ejecución.
3. Captura de Evidencias en Caso de Fallos
Para mejorar la trazabilidad de las pruebas, el método @AfterMethod captura automáticamente una captura de pantalla en caso de fallo y la adjunta al reporte de Allure.
|
Java
|
|
|---|---|
|
@AfterMethod
public void tearDown(ITestResult result) { if (result.getStatus() == ITestResult.FAILURE) { // Captura de pantalla en caso de fallo File screenshot = ((TakesScreenshot) driver).getScreenshotAs(OutputType.FILE); try { // Guardar la captura de pantalla en un archivo FileUtils.copyFile( screenshot, new File("target/screenshots/" + result.getName() + ".png") ); // Registrar la captura de pantalla en Allure Allure.addAttachment("Screenshot", new FileInputStream(screenshot)); } catch (IOException e) { e.printStackTrace(); } Throwable cause = result.getThrowable(); TestInfo testInfo = new TestInfo( result.getName(), "FAILED", result.getStartMillis(), result.getEndMillis(), "target/screenshots/" + result.getName() + ".png", cause.getMessage() ); TestResult.getInstance().getTestInfoList().add(testInfo); } else { TestInfo testInfo = new TestInfo( result.getName(), "PASSED", result.getStartMillis(), result.getEndMillis(), "", "" ); TestResult.getInstance().getTestInfoList().add(testInfo); } if (driver != null) { driver.quit(); } } |
|
A continuación detallaremos el flujo que realizará, paso a paso, el código expuesto anteriormente:
-
Detecta el estado del test:
- Si el test falla, captura una captura de pantalla y la almacena en la carpeta
target/screenshots/. - Si el test pasa, simplemente almacena los datos en
TestResult.
- Si el test falla, captura una captura de pantalla y la almacena en la carpeta
-
Adjunta la captura de pantalla a Allure para mejorar la trazabilidad del error.
-
Guarda los datos del test en la lista
TestResult.getInstance().getTestInfoList()para su posterior reporte en Jira.
4. Generación del reporte y subida a Jira
Al finalizar la suite de pruebas, si la variable de sistema report=true, se generará el reporte automático y se enviará a Jira.
|
Java
|
|
|---|---|
5. Definición de la estructura TestInfo
Para almacenar los datos relevantes de cada test ejecutado, se utiliza la clase TestInfo. Esta estructura encapsula la información esencial de cada prueba, lo que permite un seguimiento detallado y la generación de reportes automatizados.
Datos que almacena TestInfo:
testName→ Nombre del test ejecutado.testResult→ Resultado de la prueba (PASSEDoFAILED).startTime/endTime→ Tiempos de inicio y finalización de la ejecución.attachment→ Ruta de la captura de pantalla en caso de fallo (si aplica).error→ Mensaje de error generado por el test (si ha fallado).
Implementación de la estructura TestInfo
El método toString() permite representar la información de cada test en un formato estructurado, útil para debugging y generación de reportes.
|
Java
|
|
|---|---|
|
public String toString() {
return ( "TestInfo [testName=" + testName + ", testResult=" + testResult + ", startTime=" + setDate(startTime) + ", endTime=" + setDate(endTime) + ", attachment=" + attachment + ", error=" + error + "]" ); } |
|
Esta estructura se utiliza a lo largo del flujo de ejecución de pruebas para registrar cada test y posteriormente enviarlo a XRay y Jira en el formato correcto.
6. Creación del Test Execution en XRay
Una vez recopilados los resultados, se crea un Test Execution en XRay. Este proceso se encarga de:
✅ Asignar los IDs de los tests ejecutados.
✅ Asociar los entornos de prueba.
✅ Vincular los resultados con Jira para su seguimiento.
📌 Implementación en Java
El siguiente método create_test_executionDebug() se encarga de automatizar la creación del Test Execution.
|
Java
|
|
|---|---|
|
public void create_test_executionDebug() {
JSONObject jira = create_jira_data(); JSONArray testIssueIds = new JSONArray(); for (TestInfo testInfo : TestResult.getInstance().getTestInfoList()) { testIssueIds.put(getIssueIdByKey(testInfo.getTestName()).toString()); } JSONArray testEnvironments = new JSONArray(); testEnvironments.put("Web"); JSONObject jsonObject = new JSONObject(); jsonObject.put("testIssueIds", testIssueIds); jsonObject.put("testEnvironments", testEnvironments); jsonObject.put("jira", jira); try { JSONObject createTestExecutionResponse = graphQLExecutor.executeQuery( Mutations.CreateTestExecution, jsonObject.toString() ); if ( !createTestExecutionResponse.getJSONObject("data").isNull("createTestExecution") ) { JSONObject getTestExecutionJsonObject = createTestExecutionResponse .getJSONObject("data") .getJSONObject("createTestExecution") .getJSONObject("testExecution"); String issueId = getTestExecutionJsonObject.getString("issueId"); System.err.println(tab + "✅ Created Test Execution " + getIssueKeyById(issueId)); pushResultsInTestExecutionDebug(issueId); } else { System.out.println( tab + "❌ Test Execution not created" + tab + getError(createTestExecutionResponse) ); } } catch (Exception e) { e.printStackTrace(); } } |
|
7. Envío de resultados individuales a XRay
Cada test ejecutado se registra en el Test Execution previamente creado, enviando:
- El estado del test (PASSED / FAILED).
- La evidencia (capturas de pantalla en caso de fallo).
- Tiempos de inicio y finalización.
- Comentarios sobre el error en caso de fallo.
|
Java
|
|
|---|---|
|
public void pushResultsInTestExecutionDebug(String testExecutionId) {
try { for (TestInfo testInfo : TestResult.getInstance().getTestInfoList()) { System.out.println( "---------------------" + testInfo.getTestName() + "------------------------------" ); JSONObject GetTestRunjsonObject = new JSONObject(); GetTestRunjsonObject.put( "testIssueId", getIssueIdByKey(testInfo.getTestName()).toString() ); GetTestRunjsonObject.put("testExecIssueId", testExecutionId); JSONObject GetTestRunResponse = graphQLExecutor.executeQuery( Queries.GetTestRun, GetTestRunjsonObject.toString() ); if (!GetTestRunResponse.getJSONObject("data").isNull("getTestRun")) { JSONObject getTestRun = GetTestRunResponse .getJSONObject("data") .getJSONObject("getTestRun"); String TestRunId = getTestRun.getString("id"); JSONObject statusJson = new JSONObject(); statusJson.put("id", TestRunId); statusJson.put("status", testInfo.getTestResult()); JSONObject updateTestRunStatusResponse = graphQLExecutor.executeQuery( Mutations.UpdateTestRunStatus, statusJson.toString() ); if ( !updateTestRunStatusResponse .getJSONObject("data") .isNull("updateTestRunStatus") ) { System.err.println( tab + "✅ Updated status of the test " + testInfo.getTestName() ); } else { System.err.println( tab + "❌ Status not updated of the test " + testInfo.getTestName() + tab + getError(updateTestRunStatusResponse) ); } JSONObject testRunDataJson = new JSONObject(); testRunDataJson.put("id", TestRunId); testRunDataJson.put("startedOn", setTestRunDate(testInfo.getStartTime())); testRunDataJson.put("finishedOn", setTestRunDate(testInfo.getEndTime())); testRunDataJson.put("comment", testInfo.getError()); JSONObject updateTestRunDataResponse = graphQLExecutor.executeQuery( Mutations.UpdateTestRun, testRunDataJson.toString() ); if (!updateTestRunDataResponse.getJSONObject("data").isNull("updateTestRun")) { System.err.println( tab + "✅ Updated data of the test " + testInfo.getTestName() ); } else { System.err.println( tab + "❌ Data not updated of the test " + testInfo.getTestName() + tab + getError(updateTestRunDataResponse) ); } JSONObject testRunEvidenceJson = new JSONObject(); testRunEvidenceJson.put("id", TestRunId); testRunEvidenceJson.put( "evidence", new JSONArray() .put( create_evidence( createEvidenceName( testInfo.getTestName(), getIssueKeyById(testExecutionId) ), testInfo.getAttachment(), JiraConfig.MIMETYPEPNG ) ) ); JSONObject updateTestRunEvidenceResponse = graphQLExecutor.executeQuery( Mutations.AddEvidenceToTestRun, testRunEvidenceJson.toString() ); if (!testInfo.getTestResult().equals("PASSED")) { if ( !updateTestRunEvidenceResponse .getJSONObject("data") .isNull("addEvidenceToTestRun") ) { System.out.println( tab + "✅ Evidence pushed of the test " + testInfo.getTestName() ); } else { System.out.println( tab + "❌ Evidence not pushed of the test " + testInfo.getTestName() + tab + getError(updateTestRunEvidenceResponse) ); } } } else { System.err.println( tab + "❌ Test Run" + testInfo.getTestName() + " not found in Test Execution " + getIssueKeyById(testExecutionId) + tab + getError(GetTestRunResponse) ); } System.out.println( "---------------------------------------------------------------" ); } } |
|
7. Asociación del Test Execution con el Test Plan
Por último, se enlaza el Test Execution recién creado con el Test Plan existente:
|
Java
|
|
|---|---|
|
public void addTestExecutionsToTestPlanDebug(String testExecutionId) {
System.out.println("va a buscar el test plan"); System.out.println(PortalInstance.getInstance().getPortalName()); String testPlanId = TestPlanIdResolver(PortalInstance.getInstance().getPortalName()); System.out.println(testPlanId); JSONObject jsonObject = new JSONObject(); jsonObject.put("issueId", testPlanId); JSONArray testExecIssueIds = new JSONArray(); testExecIssueIds.put(testExecutionId); jsonObject.put("testExecIssueIds", testExecIssueIds); try { JSONObject response = graphQLExecutor.executeQuery( Mutations.AddTestExecutionsToTestPlan, jsonObject.toString() ); if (!response.getJSONObject("data").isNull("addTestExecutionsToTestPlan")) { System.err.println( tab + "✅ Test execution " + getIssueKeyById(testExecutionId) + " added to test plan " + getIssueKeyById(testPlanId) ); System.err.println("🆔 Test execution " + getIssueKeyById(testExecutionId)); System.err.println("📤 Reports added at " + setDate()); } else { System.err.println( tab + "❌ Test Execution" + getIssueKeyById(testExecutionId) + "not added to test plan " + getIssueKeyById(testPlanId) + tab + getError(response) ); } } catch (Exception e) { System.err.println("Error adding test executions to test plan: " + e.getMessage()); e.printStackTrace(); } } |
|
3.3. Validación de los resultados en Jira y XRay
Una vez que los resultados de los tests han sido enviados correctamente a XRay y Jira, es fundamental validar su correcta integración y analizar la ejecución de las pruebas.
Esta validación garantiza que la información reportada sea precisa y útil para la toma de decisiones en el proceso de desarrollo y pruebas.
Los objetivos de la validación
- Confirmar que los resultados de los tests han sido registrados correctamente en Jira y XRay.
- Verificar que los errores en los tests fallidos sean identificables y analizables.
- Asegurar que las evidencias (capturas de pantalla y logs) se han adjuntado correctamente.
En esta sección, revisaremos cómo visualizar y analizar los resultados en Jira y XRay, organizados en Test Execution y Test Plan, además de la gestión de evidencias en pruebas fallidas.
3.3.1. Revisión de Test Execution
¿Qué es el Test Execution en XRay?
Un Test Execution en XRay es una entidad que agrupa los resultados de una ejecución de pruebas. Permite visualizar qué tests han pasado o fallado y acceder a detalles adicionales como logs y evidencias.
Cómo acceder al Test Execution en Jira
Para consultar los detalles del Test Execution en Jira, sigue estos pasos:
- Inicia sesión en Jira y navega hasta "Projects".
- Selecciona el proyecto donde se ejecutaron los tests.
- Ve a la sección "Test Executions" dentro del menú de XRay.
Estado de ejecución de pruebas en Jira con XRay. Se muestra un Test Execution, donde un test ha pasado (PASSED) y otro ha fallado (FAILED), facilitando el análisis de calidad del software. -
Busca el ID del Test Execution generado en la última ejecución.
Vista consolidada de ejecución de pruebas en Jira XRay con tiempos y resultados.
Elementos clave en el Test Execution
Dentro de un Test Execution, podemos verificar varios elementos clave que nos ayudarán a analizar la ejecución de las pruebas:
- Resumen de ejecución: Permite ver el estado general de los tests (PASSED, FAILED, SKIPPED).
- Ejecución individual de cada test: Se puede analizar cada test de manera individual.
- Acceso a evidencias: Se pueden revisar logs, capturas de pantalla y comentarios sobre los errores detectados.
Validación de la información en el Test Execution
Al abrir un Test Execution en XRay, es importante comprobar que los valores de los siguientes campos sean correctos:
- Assignee y Reporter: Deben contener el usuario Jira (
<Usuario-jira>) con el que se generó el API-token y la conexión a Jira. - Test Plan: Se debe enlazar al Test Plan correcto, visible en la sección "Open Test Plans", representado como
<Jira-Test-Plan-ID>.Vista consolidada de ejecución de pruebas en Jira XRay con tiempos y resultados. - Start Date y End Date: Deben reflejar la fecha y hora reales de inicio y finalización de la ejecución.
- Título (Summary): Asignado en el código con el identificador
<Test-execution-title>. - Labels (Etiquetas): Generadas automáticamente en el código, incluyendo:
"QA-Auto"(valor fijo).- Nombre del navegador en el que se ejecutaron las pruebas (
<test-execution-labels>).
- Test Environment: Configurado por código como
<test-environment-name>, que debe existir previamente en Jira como una opción válida.
Lista de casos de prueba con su estado actual en Jira XRay.
Análisis de los resultados de los tests
En la sección de Tests, se listan las pruebas ejecutadas dentro del Test Execution, con su estado correspondiente:
- XRI-1 → PASSED ✅
- XRI-11 → FAILED ❌
Para obtener más detalles, podemos hacer clic en "Test Run" en cada fila del test, lo que nos permitirá ver:
- Fechas y horas de inicio y finalización de cada test (
Started OnyFinished On). - Evidencias de ejecución, como capturas de pantalla y registros de errores.
- Comentarios sobre los fallos detectados, con detalles del error.
Ejemplo de Test Execution: XRI-1 (PASSED)
El test XRI-1 ha sido ejecutado exitosamente con el estado PASSED. Podemos verificar los siguientes datos en su registro:
- Inicio y finalización del test, con sus respectivos valores en Jira XRay.
-
Usuario asignado, ejecutor y entorno de prueba, que coinciden con los valores del Test Execution general.
Datos sobre tiempos de ejecución y usuario asignado en una prueba en Jira XRay.
Ejemplo de Test Execution: XRI-11 (FAILED)
El test XRI-11 ha fallado en su ejecución, obteniendo el estado FAILED. Además de los datos habituales, se han generado secciones adicionales para análisis:
- "Evidence", donde se almacenan las capturas de pantalla y logs relevantes.
-
"Comment", que detalla el motivo del fallo y los errores detectados durante la ejecución.
Detalles de errores y evidencias capturadas en Jira XRay para pruebas fallidas.
A continuación, podemos ver un ejemplo detallado de la información generada para un test con estado FAILED:
3.3.2. Análisis del Test Plan
¿Qué es un Test Plan en XRay?
El Test Plan agrupa múltiples Test Executions bajo un mismo conjunto de validación. Permite un análisis más amplio del estado del software en pruebas de regresión o despliegues.
Cómo acceder al Test Plan en Jira
- Ve a la sección "Test Plans" dentro del menú de XRay en Jira.
- Busca el ID del Test Plan asociado a la ejecución actual.
-
Verifica el estado global de los tests en ejecución.
Ejemplo de visualización del Test Plan:
Análisis de resultados en el Test Plan
- Distribución de tests PASSED / FAILED.
- Identificación de tendencias de fallos recurrentes.
-
Revisión de históricos de ejecución.
Ejemplo de consulta de Test Plan desde la API de XRay:
|
Bash
|
|
|---|---|
|
curl -X GET "https://xray.cloud.getxray.app/api/v2/testplan/{TestPlan_ID}" \
-H "Authorization: Bearer TU_TOKEN" |
|
El Test Plan permite un análisis a mayor escala, asegurando que los errores recurrentes sean identificados y corregidos.
3.3.3. Evidencias y comentarios en los test fallidos
Cuando un test falla, es importante agregar evidencias y comentarios para que los equipos de desarrollo puedan resolver los problemas de manera eficiente.
Adjuntar capturas de pantalla en XRay
Para cada test fallido, XRay permite adjuntar capturas de pantalla o logs como evidencia.
Ejemplo de adjuntar una imagen a un test fallido en XRay (cURL):
|
Bash
|
|
|---|---|
|
curl -X POST "https://xray.cloud.getxray.app/api/v2/testexecution/{TestExecution_ID}/test/{Test_ID}/evidence" \
-H "Authorization: Bearer TU_TOKEN" \ -H "Content-Type: multipart/form-data" \ -F "file=@error_test_XRI-11.png" |
|
Ejemplo:
|
Java
|
|
|---|---|
|
import java.net.URI;
import java.net.http.HttpClient; import java.net.http.HttpRequest; import java.net.http.HttpResponse; import java.nio.charset.StandardCharsets; import java.util.Base64; public class JiraAddComment { public static void main(String[] args) { String JIRA_DOMAIN = "https://tu_dominio.atlassian.net"; String TEST_EXECUTION_ID = "TestExecution_ID"; // Reemplaza con el ID real String JIRA_API_URL = JIRA_DOMAIN + "/rest/api/3/issue/" + TEST_EXECUTION_ID + "/comment"; String API_TOKEN = "TOKEN_GENERADO"; String EMAIL = "tu_email@empresa.com"; // Payload JSON del comentario String commentPayload = "{ "body": "El test falló debido a un error en el login. Se revisará en la próxima iteración." }"; try { // Codificar credenciales en Base64 String auth = EMAIL + ":" + API_TOKEN; String encodedAuth = Base64.getEncoder().encodeToString(auth.getBytes(StandardCharsets.UTF_8)); // Crear cliente HTTP HttpClient client = HttpClient.newHttpClient(); // Construir solicitud HTTP POST HttpRequest request = HttpRequest.newBuilder() .uri(URI.create(JIRA_API_URL)) .header("Authorization", "Basic " + encodedAuth) .header("Content-Type", "application/json") .POST(HttpRequest.BodyPublishers.ofString(commentPayload)) .build(); // Enviar solicitud y obtener respuesta HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString()); // Imprimir respuesta JSON System.out.println(response.body()); } catch (Exception e) { e.printStackTrace(); } } } |
|
Si la evidencia se sube correctamente, aparecerá en el Test Execution correspondiente.
Agregar comentarios en tests fallidos
Los comentarios ayudan a documentar el motivo del fallo y las acciones tomadas para corregirlo.
Ejemplo de agregar un comentario en un Test Execution en Jira (cURL):
|
Bash
|
|
|---|---|
|
curl -X POST "https://tu_dominio.atlassian.net/rest/api/3/issue/{TestExecution_ID}/comment" \
-H "Authorization: Basic base64(EMAIL:TOKEN)" \ -H "Content-Type: application/json" \ -d '{"body": "El test falló debido a un error en el login. Se revisará en la próxima iteración."}' |
|
Ejemplo:
|
Java
|
|
|---|---|
|
import java.net.URI;
import java.net.http.HttpClient; import java.net.http.HttpRequest; import java.net.http.HttpResponse; import java.nio.charset.StandardCharsets; import java.util.Base64; public class JiraAddComment { public static void main(String[] args) { // Definir las credenciales y la URL de Jira String JIRA_DOMAIN = "https://tu_dominio.atlassian.net"; String TEST_EXECUTION_ID = "TestExecution_ID"; // Sustituir por el ID real String JIRA_API_URL = JIRA_DOMAIN + "/rest/api/3/issue/" + TEST_EXECUTION_ID + "/comment"; String API_TOKEN = "TOKEN_GENERADO"; String EMAIL = "tu_email@empresa.com"; // JSON del comentario String commentPayload = "{ "body": "El test falló debido a un error en el login. Se revisará en la próxima iteración." }"; try { // Codificar credenciales en Base64 String auth = EMAIL + ":" + API_TOKEN; String encodedAuth = Base64.getEncoder().encodeToString(auth.getBytes(StandardCharsets.UTF_8)); // Crear cliente HTTP HttpClient client = HttpClient.newHttpClient(); // Construir solicitud HTTP POST HttpRequest request = HttpRequest.newBuilder() .uri(URI.create(JIRA_API_URL)) .header("Authorization", "Basic " + encodedAuth) .header("Content-Type", "application/json") .POST(HttpRequest.BodyPublishers.ofString(commentPayload)) .build(); // Enviar solicitud y obtener respuesta HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString()); // Imprimir la respuesta JSON System.out.println("Respuesta de Jira: " + response.body()); } catch (Exception e) { e.printStackTrace(); } } } |
|
Los comentarios permiten hacer seguimiento de los errores reportados en Jira y XRay.
3.4. Conexión entre Test Execution y Test Plan
Una vez que hemos ejecutado nuestras pruebas automatizadas y revisado los resultados en el Test Execution, el siguiente paso es asociar estos resultados a un Test Plan en XRay y Jira. La conexión entre Test Execution y Test Plan permite:
- Agrupar múltiples ejecuciones de pruebas dentro de un mismo plan de pruebas.
- Obtener una visión global del estado de las pruebas en distintas iteraciones.
- Analizar tendencias de errores y validar la evolución del software a lo largo del tiempo.
A continuación, se explican los pasos necesarios para conectar un Test Execution con un Test Plan, incluyendo la gestión de datos mediante la API de XRay.
3.4.1. ¿Qué es un Test Plan en XRay?
Un Test Plan en XRay es una entidad clave en la gestión de pruebas de software. Permite agrupar múltiples Test Executions bajo una misma estrategia de validación, asegurando un control eficiente sobre la calidad del software en cada iteración del desarrollo.
¿Para qué se utiliza un Test Plan?
Los Test Plans son esenciales en escenarios como:
- Pruebas de regresión: Verificar que cambios recientes no han afectado funcionalidades previas.
- Pruebas continuas: Evaluar la estabilidad de la aplicación en cada entrega.
- Pruebas de versión: Garantizar que una versión específica cumple con los requisitos antes de su lanzamiento.
Preguntas clave que responde un Test Plan:
🔹 ¿Cuántos tests han sido ejecutados en total?
🔹 ¿Cuántos han pasado, fallado o han sido omitidos?
🔹 ¿Cuáles son los tests críticos que siguen fallando en cada iteración?
3.4.2. Relación entre Test Execution y Test Plan
Cada Test Execution puede vincularse a un Test Plan, permitiendo consolidar los resultados de múltiples ejecuciones dentro de una estrategia global de validación.
Ejemplo de estructura de un Test Plan en XRay:
-
Test Plan: "Regresión Web – Sprint 10" (XRI-100)
- Test Execution 1: Pruebas en Chrome ✅
- Test Execution 2: Pruebas en Firefox ✅
- Test Execution 3: Pruebas en Móvil ❌
Vista de ejecuciones de pruebas en Jira XRay con su estado actual y detalles.
En este caso, el Test Plan XRI-100 permite visualizar los resultados de cada entorno y navegador, ayudando al equipo a identificar tendencias y priorizar la corrección de errores.
3.4.3. Cómo vincular un Test Execution a un Test Plan
Existen dos maneras de conectar un Test Execution a un Test Plan:
- Manualmente en Jira a través de la interfaz de XRay.
- Automáticamente mediante la API de XRay.
Método 1: Vinculación manual en Jira
- Accede a Jira → XRay → Test Executions.
- Abre el Test Execution que deseas asociar.
- En la sección Test Plan, selecciona el plan de pruebas deseado.
- Guarda los cambios.
Método 2: Vinculación automática con la API de XRay
Podemos automatizar este proceso utilizando la API de XRay para asociar un Test Execution a un Test Plan.
Ejemplo en cURL:
|
Bash
|
|
|---|---|
|
curl -X POST "https://xray.cloud.getxray.app/api/v2/testplan/{TestPlan_ID}/testexecution" \
-H "Authorization: Bearer TU_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "testExecutionKeys": ["XRI-22", "XRI-23"] }' |
|
Ejemplo:
|
Java
|
|
|---|---|
|
import java.net.URI;
import java.net.http.HttpClient; import java.net.http.HttpRequest; import java.net.http.HttpResponse; import java.nio.charset.StandardCharsets; public class XRayTestPlanExecution { public static void main(String[] args) { // Definir la URL de la API de XRay String XRAY_API_URL = "https://xray.cloud.getxray.app/api/v2/testplan/{TestPlan_ID}/testexecution"; String TOKEN = "TU_BEARER_TOKEN"; // Sustituir con el token real // JSON con los testExecutionKeys String jsonPayload = "{ "testExecutionKeys": ["XRI-22", "XRI-23"] }"; try { // Crear cliente HTTP HttpClient client = HttpClient.newHttpClient(); // Construir solicitud HTTP POST HttpRequest request = HttpRequest.newBuilder() .uri(URI.create(XRAY_API_URL)) .header("Authorization", "Bearer " + TOKEN) .header("Content-Type", "application/json") .POST(HttpRequest.BodyPublishers.ofString(jsonPayload, StandardCharsets.UTF_8)) .build(); // Enviar solicitud y obtener respuesta HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString()); // Imprimir la respuesta JSON System.out.println("Respuesta de XRay: " + response.body()); } catch (Exception e) { e.printStackTrace(); } } } |
|
Si la vinculación es exitosa, los Test Executions aparecerán dentro del Test Plan en Jira.
3.4.4. Validación de la conexión en Jira
Una vez vinculados los Test Executions al Test Plan, podemos validar la conexión en Jira.
Pasos para validar en Jira:
- Ir a la sección Test Plans en XRay.
- Seleccionar el Test Plan vinculado.
- Verificar que los Test Executions aparecen en la lista.
- Revisar el estado de ejecución de cada test dentro del plan.
3.4.5. Beneficios de la conexión entre Test Execution y Test Plan
La conexión entre Test Execution y Test Plan aporta múltiples ventajas:
- Historial de ejecución: Permite comparar diferentes iteraciones de pruebas.
- Análisis de tendencias: Identifica patrones de fallos en regresión.
- Gestión eficiente: Facilita la organización de pruebas en grandes proyectos.
- Integración con reporting: Mejora la trazabilidad y documentación de los errores.
Si una ejecución falla en múltiples entornos, podemos priorizar la corrección antes de liberar el software.
4. Conclusión
La integración de pruebas automatizadas con XRay y Jira proporciona una solución eficiente para la gestión y trazabilidad de pruebas en proyectos de software. A lo largo de este artículo, hemos detallado el proceso completo, desde la ejecución de tests hasta la validación de los resultados en Jira y XRay, garantizando así la calidad del software y la automatización del reporte de resultados.
Principales aprendizajes y beneficios
-
Estandarización y centralización de resultados: Al integrar la ejecución de pruebas con XRay, todos los datos relevantes de los tests quedan almacenados en un solo lugar, facilitando su consulta y análisis.
-
Automatización de la generación de reportes: Se logra reducir el esfuerzo manual al registrar automáticamente los resultados en Jira, asignar etiquetas y adjuntar evidencias en caso de fallos.
-
Detección rápida de errores: Gracias a herramientas como Allure, es posible analizar los reportes de ejecución de forma visual, permitiendo identificar y solucionar problemas con mayor rapidez.
-
Conexión entre pruebas y requerimientos: La relación entre Test Execution, Test Plan y Test Cases asegura una trazabilidad completa, vinculando cada ejecución con los objetivos de prueba establecidos.
-
Flexibilidad en la ejecución: Se puede personalizar el entorno de pruebas, seleccionar navegadores específicos y definir condiciones para cada ejecución, adaptándose a diferentes escenarios de validación.
Reflexión final
La implementación de esta integración no solo optimiza la ejecución de pruebas automatizadas, sino que también mejora la comunicación dentro del equipo de desarrollo y calidad, permitiendo un control más efectivo sobre el estado del software. Con herramientas como Selenium, XRay, Jira y Allure, es posible construir un flujo de pruebas robusto y escalable, minimizando riesgos y asegurando entregas de mayor calidad.
Esta metodología es ideal para equipos que desean optimizar sus pruebas y garantizar un producto final más confiable.
5. Glosario
- API (Application Programming Interface)
- Conjunto de reglas y protocolos que permiten la comunicación entre diferentes sistemas de software.
- API Token
- Clave única utilizada para autenticar y autorizar solicitudes a una API sin necesidad de credenciales de usuario.
- Autenticación OAuth 2.0
- Protocolo de autorización estándar que permite a las aplicaciones acceder a recursos en nombre de un usuario sin necesidad de compartir sus credenciales.
- Bearer Token
- Tipo de token de autenticación utilizado en OAuth 2.0, que debe incluirse en el encabezado de cada solicitud para acceder a una API protegida.
- CI/CD (Continuous Integration / Continuous Deployment)
- Prácticas de desarrollo de software que permiten la integración y despliegue continuo de código en entornos de producción o prueba.
- Cucumber
- Herramienta de pruebas basada en BDD (Behavior-Driven Development) que permite escribir pruebas en lenguaje natural, comprensible por todas las partes interesadas.
- Evidencias en Pruebas
- Capturas de pantalla, logs o cualquier otro tipo de archivo que respalda la ejecución de un test y su resultado.
- GraphQL
- Lenguaje de consulta para APIs que permite solicitar exactamente los datos necesarios, optimizando el rendimiento de las consultas en comparación con REST.
- HTTP Headers
- Información adicional incluida en una solicitud HTTP, como la autenticación, el tipo de contenido o las cookies.
- Jira
- Herramienta de gestión de proyectos y seguimiento de errores ampliamente utilizada en entornos de desarrollo ágil.
- Jira Test Plan
- Funcionalidad dentro de Jira (integrada con XRay) que permite agrupar varios casos de prueba para su ejecución organizada.
- JSON (JavaScript Object Notation)
- Formato ligero de intercambio de datos basado en texto, fácil de leer y escribir para humanos y máquinas.
- Maven
- Herramienta de gestión y construcción de proyectos Java que permite automatizar la compilación, pruebas y empaquetado del software.
- Mutación (GraphQL)
- Operación que permite modificar datos en una API GraphQL (similar a `POST`, `PUT`, `DELETE` en REST).
- Payload
- Datos enviados en el cuerpo de una solicitud HTTP, generalmente en formato JSON.
- Postman
- Herramienta utilizada para probar APIs mediante la ejecución de solicitudes HTTP.
- REST API (Representational State Transfer)
- Arquitectura para el diseño de servicios web basada en el uso de HTTP para la comunicación entre cliente y servidor.
- Selenium
- Herramienta de automatización para pruebas de aplicaciones web que permite simular la interacción del usuario con un navegador.
- Suite de Pruebas
- Conjunto de pruebas agrupadas que se ejecutan juntas para validar una funcionalidad específica o un sistema completo.
- Test Execution
- Proceso de ejecución de un conjunto de pruebas en un entorno específico.
- Test Plan
- Documento o estructura que organiza y planifica las pruebas a realizar sobre una aplicación.
- TestNG
- Framework de pruebas en Java utilizado para la automatización de pruebas unitarias, de integración y funcionales.
- Token de Acceso
- Clave temporal que permite a un usuario autenticado acceder a una API.
- XRay
- Plugin de Jira para la gestión de pruebas que permite planificar, ejecutar y analizar casos de prueba automatizados o manuales.
6. Referencias bibliográficas
- Atlassian. (2024). *Jira Software API Documentation.*
- Documentación oficial sobre el uso de la API de Jira, incluyendo autenticación, gestión de pruebas y reportes. Disponible en: https://developer.atlassian.com/cloud/jira/platform/rest/v3/
- Xpand IT. (2024). *XRay Test Management for Jira – API Documentation.*
- Referencia técnica sobre la API de XRay, con ejemplos para la integración de pruebas automatizadas. Disponible en: https://docs.getxray.app/display/XRAYCLOUD/REST+API
- Postman. (2023). *Testing APIs with Postman.*
- Guía sobre el uso de Postman para pruebas de APIs REST y GraphQL, incluyendo autenticación con *OAuth 2.0* y *API tokens*. Disponible en: https://learning.postman.com/docs/introduction/overview/
- SeleniumHQ. (2024). *Selenium WebDriver Documentation.*
- Referencia oficial de *Selenium* para la automatización de pruebas en navegadores web. Disponible en: https://www.selenium.dev/documentation/
- GraphQL Foundation. (2024). *GraphQL Specification.*
- Documentación oficial sobre *GraphQL*, con detalles sobre consultas, mutaciones y ejecución de peticiones. Disponible en: https://graphql.org/learn/
- Apache Maven. (2024). *Introduction to Apache Maven.*
- Guía sobre la configuración y uso de *Maven* en proyectos *Java*. Disponible en: https://maven.apache.org/guides/getting-started/
- Allure Framework. (2024). *Allure Report Documentation.*
- Documentación oficial sobre el framework *Allure*, utilizado para la generación de reportes de pruebas. Disponible en: https://docs.qameta.io/allure/
- TestNG. (2024). *TestNG Documentation.*
- Referencia sobre *TestNG*, framework para la ejecución de pruebas automatizadas en *Java*. Disponible en: https://testng.org/doc/
