Como Usar o Selenium WebDriver para Testes de API

Quando pensamos sobre Selenium WebDriver, geralmente o associamos à automação de navegadores e testes de interface do usuário. No entanto, o Selenium também pode ser uma ferramenta poderosa para teste de APIs quando usado corretamente. Este tutorial irá guiá-lo pelo processo de aproveitamento das capacidades do Selenium WebDriver para realizar testes de API, fornecendo exemplos práticos e melhores práticas.

O teste de API (Interface de Programação de Aplicações) envolve testar as APIs da aplicação diretamente, verificando sua funcionalidade, confiabilidade, desempenho e segurança. Embora existam ferramentas dedicadas para teste de API, como Postman, REST Assured ou SoapUI, o Selenium WebDriver pode ser um valioso acréscimo ao seu conjunto de ferramentas de teste de API, especialmente quando você quer combinar testes de interface do usuário e de API no mesmo framework.

Pré-requisitos

Antes de mergulhar em testes de API com Selenium WebDriver, certifique-se de que você tenha:

1. Conhecimento básico de Selenium WebDriver
2. Uma linguagem de programação de sua escolha (Java, Python, C#, JavaScript)
3. Selenium WebDriver configurado no seu ambiente de desenvolvimento
4. Entendimento de APIs REST/SOAP
5. Conhecimento básico dos métodos HTTP (GET, POST, PUT, DELETE)

Entendendo a Arquitetura

A arquitetura do Selenium WebDriver a torna adequada para testes de API através de sua capacidade de:

1. Enviar solicitações HTTP diretamente usando bibliotecas internas ou externas
2. Lidar com respostas e verificar dados
3. Integrar-se com frameworks de teste existentes
4. Gerenciar dados e ambientes de teste

Configurando Seu Ambiente

Vamos configurar um ambiente básico para testes de API com Selenium WebDriver:

Exemplo em 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", "caminho/para/chromedriver");
        ChromeOptions options = new ChromeOptions();
        options.addArguments("--headless"); // Modo headless para teste de API
        driver = new ChromeDriver(options);
    }

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

Exemplo em 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 headless para teste de API
    driver = webdriver.Chrome(options=chrome_options)
    return driver

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

Abordagens de Teste de API com Selenium WebDriver

1. Usando Bibliotecas HTTP Nativas

A abordagem mais direta é usar as bibliotecas HTTP nativas da sua linguagem de programação juntamente com o Selenium WebDriver.

Exemplo em Java - Requisição 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("Código de Resposta GET: " + 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 "A requisição GET falhou com o código de resposta: " + responseCode;
    }
}

Exemplo em Python - Requisição POST

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

    print(f"Código de Resposta POST: {response.status_code}")

    if response.status_code == 200:
        return response.json()
    else:
        return f"A requisição POST falhou com o código de resposta: {response.status_code}"

2. Usando JavaScriptExecutor para Chamadas AJAX

Outra abordagem é usar o JavaScriptExecutor do Selenium para realizar chamadas AJAX diretamente do navegador.

Exemplo em 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);
}

Exemplo em 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. Interceptando e Modificando Chamadas de API

O Selenium WebDriver pode ser usado para interceptar e modificar chamadas de API feitas pela aplicação, especialmente quando combinado com ferramentas proxy como BrowserMob Proxy.

Exemplo em Java com 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 o proxy
    BrowserMobProxy proxy = new BrowserMobProxyServer();
    proxy.start(0);

    // Obter o objeto proxy do Selenium
    Proxy seleniumProxy = ClientUtil.createSeleniumProxy(proxy);

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

    // Criar a instância do WebDriver
    driver = new ChromeDriver(options);

    // Adicionar um filtro de requisição para interceptar chamadas de API
    proxy.addRequestFilter((request, contents, messageInfo) -> {
        if (request.getUri().contains("/api/")) {
            System.out.println("Chamada de API interceptada: " + request.getUri());
            // Modificar cabeçalhos, parâmetros ou o corpo da requisição se necessário
        }
        return null;
    });

    // Adicionar um filtro de resposta para inspecionar e modificar respostas de API
    proxy.addResponseFilter((response, contents, messageInfo) -> {
        if (messageInfo.getOriginalRequest().getUri().contains("/api/")) {
            String responseBody = contents.getTextContents();
            System.out.println("Resposta da API: " + responseBody);
            // Modificar a resposta se necessário
        }
    });
}

Construindo um Framework Completo de Teste de API

Vamos criar um framework de teste de API mais estruturado usando o Selenium WebDriver:

Exemplo em 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.exemplo.com>";

    @BeforeClass
    public void setUp() {
        System.setProperty("webdriver.chrome.driver", "caminho/para/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@exemplo.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 {
        // Implementação do exemplo 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);

        // Escrever payload na conexão
        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("Código de Resposta POST: " + 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();
        }
    }
}

Exemplo em 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.exemplo.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@exemplo.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()

Combinando Testes de UI e API

Uma das maiores vantagens de usar o Selenium WebDriver para testes de API é a capacidade de combinar testes de UI e API no mesmo framework:

@Test
public void testLoginAndVerifyUserDataAPI() throws IOException {
    // Parte de UI: Login através da UI
    driver.get("<https://exemplo.com/login>");
    driver.findElement(By.id("username")).sendKeys("testuser");
    driver.findElement(By.id("password")).sendKeys("password");
    driver.findElement(By.id("loginButton")).click();

    // Aguardar a conclusão do login
    WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
    wait.until(ExpectedConditions.urlContains("/dashboard"));

    // Extrair o token de autenticação de cookies ou armazenamento local
    String authToken = (String) ((JavascriptExecutor) driver)
        .executeScript("return localStorage.getItem('authToken');");

    // Parte de API: Usar o token para fazer uma chamada 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);

    // Processar e verificar a resposta da API
    int responseCode = connection.getResponseCode();
    Assert.assertEquals(responseCode, 200);

    // Ler e analisar a resposta
    BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
    String response = in.lines().collect(Collectors.joining());
    in.close();

    JSONObject jsonResponse = new JSONObject(response);

    // Verificar se os dados da API correspondem ao que é exibido na UI
    String uiUsername = driver.findElement(By.id("profileUsername")).getText();
    Assert.assertEquals(jsonResponse.getString("username"), uiUsername);
}

Melhores Práticas para Testes de API com Selenium WebDriver

1. Use Modo Headless: Ao realizar testes de API puros, execute o Selenium em modo headless para economizar recursos.
2. Separe Testes de API e UI: Embora você possa combiná-los, mantenha testes de API e UI logicamente separados.
3. Aproveite Bibliotecas de Assertivas: Use bibliotecas completas de assertivas para validar respostas de API.
4. Implemente Tratamento de Erros: Adicione um tratamento adequado para falhas de API.
5. Registre Requisições e Respostas de API: Para fins de depuração, registre todas as interações de API.
6. Parametrize Testes: Use provedores de dados ou testes parametrizados para testar vários cenários.
7. Implemente Tratamento de Autenticação: Crie métodos reutilizáveis para manipular autenticação.
8. Considere Desempenho: Esteja ciente de que o Selenium pode adicionar sobrecarga em comparação com ferramentas dedicadas a testes de API.

Limitações do Uso do Selenium WebDriver para Testes de API

1. Sobrecarrega de Desempenho: O Selenium é projetado principalmente para automação de navegadores, portanto, adiciona sobrecarga para testes de API puros.
2. Recursos Específicos Limitados: Ferramentas dedicadas para testes de API oferecem recursos mais específicos para testes de API.
3. Dependência de Navegador: Mesmo em modo headless, o Selenium requer um navegador, o que pode ser desnecessário para testes de API.
4. Complexidade: Configurar o Selenium para testes de API pode ser mais complexo do que usar ferramentas dedicadas a testes de API.

Quando Usar Selenium WebDriver para Testes de API

O Selenium WebDriver é mais adequado para testes de API nos seguintes cenários:

1. Quando você já possui um framework de testes de UI baseado em Selenium e deseja estendê-lo.
2. Quando você precisa testar cenários que envolvem interações de UI e API.
3. Quando você precisa testar APIs no contexto de um navegador (como testar chamadas de API em JavaScript).
4. Quando você deseja interceptar e modificar chamadas de API feitas pela aplicação.

Conclusão

O Selenium WebDriver pode ser uma ferramenta versátil para testes de API, especialmente quando integrado a frameworks de testes de UI existentes. Embora possa não substituir ferramentas dedicadas a testes de API para necessidades de testes de API complexas, ele fornece uma maneira flexível de combinar testes de UI e de API em um único framework.

Aproveitando as abordagens e exemplos fornecidos neste tutorial, você pode usar efetivamente o Selenium WebDriver para suas necessidades de testes de API. Lembre-se de considerar as trocas e escolher a ferramenta certa para suas necessidades específicas de testes.

Se você está testando APIs REST, serviços SOAP ou endpoints GraphQL, o Selenium WebDriver pode ajudá-lo a criar testes abrangentes que validam tanto a UI da sua aplicação quanto sua funcionalidade de API subjacente.

Para necessidades de teste de API mais avançadas, você pode querer considerar a combinação do Selenium WebDriver com bibliotecas ou frameworks dedicados de teste de API, como REST Assured (para Java) ou Requests (para Python) para obter o melhor dos dois mundos.

Feliz teste!