Cómo usar Selenium WebDriver para pruebas de API

💡

Antes de sumergirte en el tutorial de Selenium, echa un vistazo a Apidog, una herramienta gratuita diseñada para simplificar las pruebas e integración de APIs. Con la interfaz intuitiva de Apidog, puedes depurar y optimizar fácilmente tus flujos de trabajo de API, agilizando el proceso de desarrollo y ahorrándote un tiempo valioso. Ya sea que estés construyendo APIs o solucionando problemas, Apidog tiene todo lo que necesitas para mejorar tu flujo de trabajo.

button

Cuando pensamos en Selenium WebDriver, normalmente lo asociamos con la automatización del navegador y las pruebas de la interfaz de usuario. Sin embargo, Selenium también puede ser una herramienta poderosa para las pruebas de API cuando se usa correctamente. Este tutorial te guiará a través del proceso de aprovechamiento de las capacidades de Selenium WebDriver para realizar pruebas de API, proporcionándote ejemplos prácticos y mejores prácticas.

Las pruebas de API (Interfaz de Programación de Aplicaciones) implican probar las APIs de la aplicación directamente, verificando su funcionalidad, fiabilidad, rendimiento y seguridad. Si bien existen herramientas dedicadas para las pruebas de API como Postman, REST Assured o SoapUI, Selenium WebDriver puede ser una valiosa adición a tu conjunto de herramientas de pruebas de API, especialmente cuando deseas combinar las pruebas de la interfaz de usuario y la API en el mismo marco de trabajo.

Requisitos previos

Antes de sumergirte en las pruebas de API con Selenium WebDriver, asegúrate de tener:

Conocimientos básicos de Selenium WebDriver
Un lenguaje de programación de tu elección (Java, Python, C#, JavaScript)
Selenium WebDriver configurado en tu entorno de desarrollo
Comprensión de las APIs REST/SOAP
Conocimientos básicos de los métodos HTTP (GET, POST, PUT, DELETE)

Comprensión de la arquitectura

La arquitectura de Selenium WebDriver lo hace adecuado para las pruebas de API a través de su capacidad para:

Enviar solicitudes HTTP directamente utilizando bibliotecas integradas o externas
Manejar respuestas y verificar datos
Integrarse con los marcos de trabajo de pruebas existentes
Gestionar los datos y entornos de prueba

Configuración de tu entorno

Vamos a configurar un entorno básico para las pruebas de API con Selenium WebDriver:

Ejemplo de Java

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeOptions;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class SeleniumApiTesting {
    private WebDriver driver;

    public void setUp() {
        System.setProperty("webdriver.chrome.driver", "path/to/chromedriver");
        ChromeOptions options = new ChromeOptions();
        options.addArguments("--headless"); // Modo sin cabeza para las pruebas de API
        driver = new ChromeDriver(options);
    }

    public void tearDown() {
        if (driver != null) {
            driver.quit();
        }
    }
}

Ejemplo de Python

from selenium import webdriver
from selenium.webdriver.chrome.options import Options
import requests
import json

def setup_driver():
    chrome_options = Options()
    chrome_options.add_argument("--headless")  # Modo sin cabeza para las pruebas de API
    driver = webdriver.Chrome(options=chrome_options)
    return driver

def teardown_driver(driver):
    if driver is not None:
        driver.quit()

Enfoques de pruebas de API con Selenium WebDriver

1. Uso de bibliotecas HTTP nativas

El enfoque más sencillo es utilizar las bibliotecas HTTP nativas de tu lenguaje de programación junto con Selenium WebDriver.

Ejemplo de Java - Solicitud GET

public String performGetRequest(String endpoint) throws IOException {
    URL url = new URL(endpoint);
    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
    connection.setRequestMethod("GET");

    int responseCode = connection.getResponseCode();
    System.out.println("GET Response Code: " + responseCode);

    if (responseCode == HttpURLConnection.HTTP_OK) {
        BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
        String inputLine;
        StringBuilder response = new StringBuilder();

        while ((inputLine = in.readLine()) != null) {
            response.append(inputLine);
        }
        in.close();

        return response.toString();
    } else {
        return "GET request failed with response code: " + responseCode;
    }
}

Ejemplo de Python - Solicitud POST

def perform_post_request(endpoint, payload):
    headers = {'Content-Type': 'application/json'}
    response = requests.post(endpoint, data=json.dumps(payload), headers=headers)

    print(f"POST Response Code: {response.status_code}")

    if response.status_code == 200:
        return response.json()
    else:
        return f"POST request failed with response code: {response.status_code}"

2. Uso de JavaScriptExecutor para llamadas AJAX

Otro enfoque es utilizar JavaScriptExecutor de Selenium para realizar llamadas AJAX directamente desde el navegador.

Ejemplo de Java

import org.openqa.selenium.JavascriptExecutor;

public String performApiCallWithJsExecutor(String endpoint, String method, String payload) {
    String script = String.format(
        "var xhr = new XMLHttpRequest();" +
        "xhr.open('%s', '%s', false);" +
        "xhr.setRequestHeader('Content-Type', 'application/json');" +
        "xhr.send('%s');" +
        "return xhr.responseText;",
        method, endpoint, payload
    );

    return (String) ((JavascriptExecutor) driver).executeScript(script);
}

Ejemplo de Python

def perform_api_call_with_js_executor(driver, endpoint, method, payload):
    script = f"""
        var xhr = new XMLHttpRequest();
        xhr.open('{method}', '{endpoint}', false);
        xhr.setRequestHeader('Content-Type', 'application/json');
        xhr.send('{payload}');
        return xhr.responseText;
    """

    return driver.execute_script(script)

3. Interceptación y modificación de llamadas API

Selenium WebDriver se puede utilizar para interceptar y modificar las llamadas API realizadas por la aplicación, especialmente cuando se combina con herramientas de proxy como BrowserMob Proxy.

Ejemplo de Java con BrowserMob Proxy

import net.lightbody.bmp.BrowserMobProxy;
import net.lightbody.bmp.BrowserMobProxyServer;
import net.lightbody.bmp.client.ClientUtil;
import org.openqa.selenium.Proxy;

public void setupProxyForApiInterception() {
    // Iniciar el proxy
    BrowserMobProxy proxy = new BrowserMobProxyServer();
    proxy.start(0);

    // Obtener el objeto proxy de Selenium
    Proxy seleniumProxy = ClientUtil.createSeleniumProxy(proxy);

    // Configurar Chrome para usar el proxy
    ChromeOptions options = new ChromeOptions();
    options.setCapability("proxy", seleniumProxy);

    // Crear la instancia de WebDriver
    driver = new ChromeDriver(options);

    // Agregar un filtro de solicitud para interceptar las llamadas API
    proxy.addRequestFilter((request, contents, messageInfo) -> {
        if (request.getUri().contains("/api/")) {
            System.out.println("Intercepted API call: " + request.getUri());
            // Modificar los encabezados, parámetros o el cuerpo de la solicitud si es necesario
        }
        return null;
    });

    // Agregar un filtro de respuesta para inspeccionar y modificar las respuestas de la API
    proxy.addResponseFilter((response, contents, messageInfo) -> {
        if (messageInfo.getOriginalRequest().getUri().contains("/api/")) {
            String responseBody = contents.getTextContents();
            System.out.println("API Response: " + responseBody);
            // Modificar la respuesta si es necesario
        }
    });
}

Construcción de un marco de trabajo completo de pruebas de API

Vamos a crear un marco de trabajo de pruebas de API más estructurado utilizando Selenium WebDriver:

Ejemplo de Java

import org.json.JSONObject;
import org.testng.Assert;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;

import java.io.IOException;

public class ApiTestFramework {
    private WebDriver driver;
    private final String BASE_URL = "<https://api.example.com>";

    @BeforeClass
    public void setUp() {
        System.setProperty("webdriver.chrome.driver", "path/to/chromedriver");
        ChromeOptions options = new ChromeOptions();
        options.addArguments("--headless");
        driver = new ChromeDriver(options);
    }

    @Test
    public void testGetUserEndpoint() throws IOException {
        String endpoint = BASE_URL + "/api/users/1";
        String response = performGetRequest(endpoint);

        JSONObject jsonResponse = new JSONObject(response);

        Assert.assertEquals(jsonResponse.getString("name"), "John Doe");
        Assert.assertEquals(jsonResponse.getInt("id"), 1);
        Assert.assertTrue(jsonResponse.has("email"));
    }

    @Test
    public void testCreateUserEndpoint() throws IOException {
        String endpoint = BASE_URL + "/api/users";
        JSONObject payload = new JSONObject();
        payload.put("name", "Jane Smith");
        payload.put("email", "jane.smith@example.com");

        String response = performPostRequest(endpoint, payload.toString());
        JSONObject jsonResponse = new JSONObject(response);

        Assert.assertTrue(jsonResponse.has("id"));
        Assert.assertEquals(jsonResponse.getString("name"), "Jane Smith");
    }

    private String performGetRequest(String endpoint) throws IOException {
        // Implementación del ejemplo anterior
    }

    private String performPostRequest(String endpoint, String payload) throws IOException {
        URL url = new URL(endpoint);
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setRequestMethod("POST");
        connection.setRequestProperty("Content-Type", "application/json");
        connection.setDoOutput(true);

        // Escribir la carga útil en la conexión
        try (java.io.OutputStream os = connection.getOutputStream()) {
            byte[] input = payload.getBytes("utf-8");
            os.write(input, 0, input.length);
        }

        int responseCode = connection.getResponseCode();
        System.out.println("POST Response Code: " + responseCode);

        try (BufferedReader br = new BufferedReader(
                new InputStreamReader(connection.getInputStream(), "utf-8"))) {
            StringBuilder response = new StringBuilder();
            String responseLine;
            while ((responseLine = br.readLine()) != null) {
                response.append(responseLine.trim());
            }
            return response.toString();
        }
    }

    @AfterClass
    public void tearDown() {
        if (driver != null) {
            driver.quit();
        }
    }
}

Ejemplo de Python

import unittest
import json
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
import requests

class ApiTestFramework(unittest.TestCase):
    BASE_URL = "<https://api.example.com>"

    def setUp(self):
        chrome_options = Options()
        chrome_options.add_argument("--headless")
        self.driver = webdriver.Chrome(options=chrome_options)

    def test_get_user_endpoint(self):
        endpoint = self.BASE_URL + "/api/users/1"
        response = self.perform_get_request(endpoint)

        self.assertEqual(response['name'], "John Doe")
        self.assertEqual(response['id'], 1)
        self.assertIn('email', response)

    def test_create_user_endpoint(self):
        endpoint = self.BASE_URL + "/api/users"
        payload = {
            "name": "Jane Smith",
            "email": "jane.smith@example.com"
        }

        response = self.perform_post_request(endpoint, payload)

        self.assertIn('id', response)
        self.assertEqual(response['name'], "Jane Smith")

    def perform_get_request(self, endpoint):
        response = requests.get(endpoint)
        return response.json() if response.status_code == 200 else None

    def perform_post_request(self, endpoint, payload):
        headers = {'Content-Type': 'application/json'}
        response = requests.post(endpoint, data=json.dumps(payload), headers=headers)
        return response.json() if response.status_code in [200, 201] else None

    def tearDown(self):
        if self.driver:
            self.driver.quit()

if __name__ == '__main__':
    unittest.main()

Combinación de pruebas de la interfaz de usuario y la API

Una de las mayores ventajas de usar Selenium WebDriver para las pruebas de API es la capacidad de combinar las pruebas de la interfaz de usuario y la API en el mismo marco de trabajo:

@Test
public void testLoginAndVerifyUserDataAPI() throws IOException {
    // Parte de la interfaz de usuario: Iniciar sesión a través de la interfaz de usuario
    driver.get("<https://example.com/login>");
    driver.findElement(By.id("username")).sendKeys("testuser");
    driver.findElement(By.id("password")).sendKeys("password");
    driver.findElement(By.id("loginButton")).click();

    // Esperar a que se complete el inicio de sesión
    WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
    wait.until(ExpectedConditions.urlContains("/dashboard"));

    // Extraer el token de autenticación de las cookies o el almacenamiento local
    String authToken = (String) ((JavascriptExecutor) driver)
        .executeScript("return localStorage.getItem('authToken');");

    // Parte de la API: Usar el token para realizar una llamada API autenticada
    String endpoint = BASE_URL + "/api/user/profile";
    URL url = new URL(endpoint);
    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
    connection.setRequestMethod("GET");
    connection.setRequestProperty("Authorization", "Bearer " + authToken);

    // Procesar y verificar la respuesta de la API
    int responseCode = connection.getResponseCode();
    Assert.assertEquals(responseCode, 200);

    // Leer y analizar la respuesta
    BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
    String response = in.lines().collect(Collectors.joining());
    in.close();

    JSONObject jsonResponse = new JSONObject(response);

    // Verificar que los datos de la API coincidan con lo que se muestra en la interfaz de usuario
    String uiUsername = driver.findElement(By.id("profileUsername")).getText();
    Assert.assertEquals(jsonResponse.getString("username"), uiUsername);
}

Mejores prácticas para las pruebas de API con Selenium WebDriver

Usar el modo sin cabeza: Cuando realices pruebas de API puras, ejecuta Selenium en modo sin cabeza para ahorrar recursos.
Separar las pruebas de la API y la interfaz de usuario: Si bien puedes combinarlas, mantén las pruebas de la API y la interfaz de usuario separadas lógicamente.
Aprovechar las bibliotecas de aserciones: Utiliza bibliotecas de aserciones integrales para validar las respuestas de la API.
Implementar el manejo de errores: Agrega un manejo de errores adecuado para los fallos de la API.
Registrar las solicitudes y respuestas de la API: Para fines de depuración, registra todas las interacciones de la API.
Parametrizar las pruebas: Utiliza proveedores de datos o pruebas parametrizadas para probar varios escenarios.
Implementar el manejo de la autenticación: Crea métodos reutilizables para manejar la autenticación.
Considerar el rendimiento: Ten en cuenta que Selenium podría agregar una sobrecarga en comparación con las herramientas dedicadas de pruebas de API.

Limitaciones del uso de Selenium WebDriver para las pruebas de API

Sobrecarga de rendimiento: Selenium está diseñado principalmente para la automatización del navegador, por lo que agrega una sobrecarga para las pruebas de API puras.
Funciones específicas de la API limitadas: Las herramientas dedicadas de pruebas de API ofrecen funciones más específicas para las pruebas de API.
Dependencia del navegador: Incluso en modo sin cabeza, Selenium requiere un navegador, lo que podría ser innecesario para las pruebas de API.
Complejidad: La configuración de Selenium para las pruebas de API podría ser más compleja que el uso de herramientas dedicadas de pruebas de API.

Cuándo usar Selenium WebDriver para las pruebas de API

Selenium WebDriver es más adecuado para las pruebas de API en los siguientes escenarios:

Cuando ya tienes un marco de trabajo de pruebas de la interfaz de usuario basado en Selenium y deseas extenderlo.
Cuando necesitas probar escenarios que involucran interacciones tanto de la interfaz de usuario como de la API.
Cuando necesitas probar las APIs en el contexto de un navegador (como probar las llamadas API de JavaScript).
Cuando deseas interceptar y modificar las llamadas API realizadas por la aplicación.

Conclusión

Selenium WebDriver puede ser una herramienta versátil para las pruebas de API, especialmente cuando se integra con los marcos de trabajo de pruebas de la interfaz de usuario existentes. Si bien puede que no reemplace las herramientas dedicadas de pruebas de API para las necesidades complejas de pruebas de API, proporciona una forma flexible de combinar las pruebas de la interfaz de usuario y la API en un solo marco de trabajo.

Al aprovechar los enfoques y ejemplos proporcionados en este tutorial, puedes usar eficazmente Selenium WebDriver para tus requisitos de pruebas de API. Recuerda considerar las ventajas y desventajas y elegir la herramienta adecuada para tus necesidades específicas de pruebas.

Ya sea que estés probando APIs REST, servicios SOAP o puntos finales de GraphQL, Selenium WebDriver puede ayudarte a crear pruebas integrales que validen tanto la interfaz de usuario de tu aplicación como su funcionalidad API subyacente.

Para necesidades más avanzadas de pruebas de API, es posible que desees considerar la combinación de Selenium WebDriver con bibliotecas o marcos de trabajo dedicados de pruebas de API como REST Assured (para Java) o Requests (para Python) para obtener lo mejor de ambos mundos.

¡Felices pruebas!