Résolution de CAPTCHA pour l'assurance qualité et les tests autorisés (guide complet)

Les équipes de test doivent vérifier régulièrement les flux protégés par CAPTCHA. CaptchaAI vous permet d'automatiser ces tests sans interaction manuelle CAPTCHA.

Quand les équipes d’assurance qualité ont besoin de résoudre les CAPTCHA

Scénario	Pourquoi CaptchaAI aide
Tests de régression	Vérifier que les formulaires fonctionnent toujours après le déploiement
Tests de bout en bout	Testez des parcours utilisateur complets
Test de charge	Simulez des flux CAPTCHA réalistes à grande échelle
Tests multi-navigateurs	Valider les rendus CAPTCHA sur tous les navigateurs
Tests d'accessibilité	Tester des flux alternatifs pour les utilisateurs handicapés

Intégration Pytest

import pytest
import requests
import time


class CaptchaTestHelper:
    """Helper for solving CAPTCHAs in test environments."""

    def __init__(self, api_key):
        self.api_key = api_key

    def solve_recaptcha(self, sitekey, pageurl, timeout=120):
        """Solve reCAPTCHA and return token."""
        resp = requests.post("https://ocr.captchaai.com/in.php", data={
            "key": self.api_key,
            "method": "userrecaptcha",
            "googlekey": sitekey,
            "pageurl": pageurl,
            "json": 1,
        }, timeout=30)
        result = resp.json()
        assert result.get("status") == 1, f"Submit failed: {result}"
        task_id = result["request"]

        deadline = time.time() + timeout
        time.sleep(10)

        while time.time() < deadline:
            resp = requests.get("https://ocr.captchaai.com/res.php", params={
                "key": self.api_key, "action": "get",
                "id": task_id, "json": 1,
            }, timeout=15)
            data = resp.json()

            if data.get("status") == 1:
                return data["request"]
            if data["request"] != "CAPCHA_NOT_READY":
                raise RuntimeError(f"Solve error: {data['request']}")
            time.sleep(5)

        raise TimeoutError("CAPTCHA solve timeout")


@pytest.fixture(scope="session")
def captcha_helper():
    """Provide CaptchaAI helper for test session."""
    import os
    api_key = os.environ.get("CAPTCHAAI_API_KEY")
    if not api_key:
        pytest.skip("CAPTCHAAI_API_KEY not set")
    return CaptchaTestHelper(api_key)


class TestLoginFlow:
    """Test login flow behind reCAPTCHA."""

    SITEKEY = "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-"
    LOGIN_URL = "https://staging.example.com/login"

    def test_login_with_valid_credentials(self, captcha_helper):
        """Verify login succeeds with valid creds and solved CAPTCHA."""
        token = captcha_helper.solve_recaptcha(self.SITEKEY, self.LOGIN_URL)
        assert token and len(token) > 100

        resp = requests.post(self.LOGIN_URL, data={
            "username": "test_user",
            "password": "test_pass",
            "g-recaptcha-response": token,
        })
        assert resp.status_code == 200
        assert "Welcome" in resp.text

    def test_login_with_invalid_credentials(self, captcha_helper):
        """Verify login fails gracefully with bad creds but valid CAPTCHA."""
        token = captcha_helper.solve_recaptcha(self.SITEKEY, self.LOGIN_URL)

        resp = requests.post(self.LOGIN_URL, data={
            "username": "wrong_user",
            "password": "wrong_pass",
            "g-recaptcha-response": token,
        })
        assert resp.status_code in (200, 401)
        assert "Invalid" in resp.text or "error" in resp.text.lower()

    def test_login_without_captcha_fails(self):
        """Verify login rejects submissions without CAPTCHA."""
        resp = requests.post(self.LOGIN_URL, data={
            "username": "test_user",
            "password": "test_pass",
        })
        assert resp.status_code in (400, 403, 422)

Modèle de test au sélénium E2E

import pytest
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC


@pytest.fixture
def browser():
    """Create browser for testing."""
    options = webdriver.ChromeOptions()
    options.add_argument("--window-size=1920,1080")
    driver = webdriver.Chrome(options=options)
    yield driver
    driver.quit()


class TestRegistrationFlow:
    """Test registration form with CAPTCHA."""

    REG_URL = "https://staging.example.com/register"

    def test_registration_form_submits(self, browser, captcha_helper):
        """Full registration flow with CAPTCHA solving."""
        browser.get(self.REG_URL)

        # Fill form
        browser.find_element(By.ID, "email").send_keys("test@example.com")
        browser.find_element(By.ID, "password").send_keys("SecurePass123!")
        browser.find_element(By.ID, "confirm_password").send_keys("SecurePass123!")

        # Extract sitekey from page
        captcha_div = browser.find_element(By.CSS_SELECTOR, ".g-recaptcha")
        sitekey = captcha_div.get_attribute("data-sitekey")

        # Solve via API
        token = captcha_helper.solve_recaptcha(sitekey, browser.current_url)

        # Inject token
        browser.execute_script("""
            document.querySelector('[name="g-recaptcha-response"]').value = arguments[0];
        """, token)

        # Trigger callback if needed
        callback = captcha_div.get_attribute("data-callback")
        if callback:
            browser.execute_script(f"window['{callback}'](arguments[0]);", token)

        # Submit
        browser.find_element(By.CSS_SELECTOR, "button[type=submit]").click()

        # Verify success
        WebDriverWait(browser, 10).until(
            EC.presence_of_element_located((By.CSS_SELECTOR, ".success-message"))
        )

    def test_captcha_renders_on_page(self, browser):
        """Verify CAPTCHA widget loads on registration page."""
        browser.get(self.REG_URL)
        captcha = WebDriverWait(browser, 10).until(
            EC.presence_of_element_located((By.CSS_SELECTOR, ".g-recaptcha, iframe[src*='recaptcha']"))
        )
        assert captcha.is_displayed()

Configuration des tests

# conftest.py
import os

# Mark tests that need CAPTCHA solving
def pytest_configure(config):
    config.addinivalue_line(
        "markers", "captcha: tests requiring CAPTCHA solving (may be slow)"
    )


# pytest.ini or pyproject.toml
"""
[tool.pytest.ini_options]
markers = [
    "captcha: tests requiring CAPTCHA solving (may be slow)",
]
"""

Exécutez uniquement les tests CAPTCHA :

pytest -m captcha -v

Exécuter sans tests CAPTCHA (pipeline rapide) :

pytest -m "not captcha" -v

Conseils de test rentables

Stratégie	Avantage
Utiliser un environnement de test	Diminution de la difficulté CAPTCHA
Exécutez les tests CAPTCHA dans les délais prévus, pas à chaque poussée	Réduisez les coûts des API
Résultats des tests de cache pour les tests irréguliers	Évitez les résolutions inutiles
Utilisez l'indicateur d'environnement pour ignorer les CAPTCHA localement	Économisez des coûts pendant le développement
Tests CAPTCHA par lots dans un travail CI dédié	Contrôler les coûts par pipeline

FAQ

Combien coûte l’exécution de tests CAPTCHA ?

Chaque résolution reCAPTCHA v2 coûte environ 0,003 $. Une suite de tests avec 50 tests CAPTCHA coûte environ 0,15 $ par exécution. Coûts quotidiens de fonctionnement ~ 4,50 $/month.

Dois-je résoudre les CAPTCHA dans les tests unitaires ?

Non. Mockez les réponses CAPTCHA dans les tests unitaires. Résolvez uniquement les vrais CAPTCHA lors des tests d'intégration et E2E dans des environnements réels.

Puis-je utiliser CaptchaAI avec d’autres frameworks de test ?

Oui. CaptchaAI est basé sur HTTP, il fonctionne donc avec n'importe quel framework de test dans n'importe quel langage : Jest, Mocha, JUnit, NUnit, etc.