Séparation des profils de navigateur pour les tests QA avec CaptchaAI

Périmètre : ce guide traite de la séparation des profils dans vos propres environnements QA ou autorisés. L'objectif est un test reproductible, avec cookies, stockage et comptes de test isolés — pas le masquage d'empreinte ni la dissimulation d'identité.

Isoler les profils de navigateur, c'est donner à chaque cas de test son propre jeu de cookies, de stockage et de comptes, pour que deux scénarios QA ne se contaminent jamais. Sans cette séparation, vous ne savez plus si un comportement CAPTCHA vient de votre intégration ou d'un simple cookie survivant du test précédent — et la plupart des faux positifs en QA relèvent justement de cet état résiduel, pas du défi CAPTCHA lui-même.

Les données à cloisonner dans chaque profil

L'enjeu n'est pas de manipuler le navigateur, mais de séparer tout ce qui porte un état d'une exécution à l'autre. Minimisez au passage les données personnelles de vos fixtures — c'est le bon réflexe RGPD, même sur des comptes de test.

L'outil importe peu : ce qui compte, c'est la règle. Un profil par cas de test, réinitialisé de la même façon après chaque passage.

Pourquoi l'isolation change vos résultats QA

En staging comme en préproduction, vous voulez rejouer chaque scénario seul :

• première visite, sans aucune session préexistante,
• retour d'un compte de test déjà connu,
• bascule de région ou de tenant,
• régressions parallèles jouées avec plusieurs rôles.

Sans profils séparés, ces cas se chevauchent et deviennent impossibles à reproduire. Avec un profil dédié par scénario, chaque exécution part d'un état connu et vos rapports redeviennent lisibles.

Enregistrer l'état de départ d'un profil de test

Une approche pragmatique consiste à figer l'état initial de chaque rôle dans un fichier, puis à le recharger à chaque exécution.

from pathlib import Path
import json


PROFILE_DIR = Path("./qa-browser-profiles")
PROFILE_DIR.mkdir(exist_ok=True)


def state_file(profile_name: str) -> Path:
    return PROFILE_DIR / f"{profile_name}.json"


def save_profile_state(profile_name: str, cookies: list[dict], local_storage: dict) -> None:
    payload = {
        "profile": profile_name,
        "cookies": cookies,
        "local_storage": local_storage,
    }
    state_file(profile_name).write_text(json.dumps(payload, indent=2), encoding="utf-8")


def load_profile_state(profile_name: str) -> dict:
    path = state_file(profile_name)
    if not path.exists():
        return {"cookies": [], "local_storage": {}}
    return json.loads(path.read_text(encoding="utf-8"))

Vous déclarez ainsi des profils comme checkout-first-visit, logged-in-user ou expired-session. Un poste de développement à Lyon et un pipeline CI en région eu-west-3 (Paris) rejouent alors le même scénario, ce qui rend les écarts enfin diagnostiquables.

Brancher CaptchaAI sur une suite QA interne

Une fois les profils bien séparés, la vérification CAPTCHA s'intègre à votre suite rôle par rôle. CaptchaAI prend en charge reCAPTCHA v2 et Cloudflare Turnstile à partir du sitekey et de l'URL de la page.

import requests
import time


CAPTCHAAI_API_KEY = "YOUR_API_KEY"


def solve_for_staging(page_url: str, sitekey: str) -> str:
    submit = requests.post(
        "https://ocr.captchaai.com/in.php",
        data={
            "key": CAPTCHAAI_API_KEY,
            "method": "userrecaptcha",
            "googlekey": sitekey,
            "pageurl": page_url,
            "json": 1,
        },
        timeout=30,
    )
    submit.raise_for_status()
    submit_json = submit.json()
    if submit_json.get("status") != 1:
        raise RuntimeError(submit_json.get("request", "unknown submit error"))

    task_id = submit_json["request"]
    for _ in range(30):
        time.sleep(5)
        result = requests.get(
            "https://ocr.captchaai.com/res.php",
            params={"key": CAPTCHAAI_API_KEY, "action": "get", "id": task_id, "json": 1},
            timeout=30,
        )
        result.raise_for_status()
        result_json = result.json()
        if result_json.get("status") == 1:
            return result_json["request"]

    raise TimeoutError("CaptchaAI task timed out in QA")


def verify_profile_flow(profile_name: str, page_url: str, sitekey: str) -> dict:
    token = solve_for_staging(page_url, sitekey)
    response = requests.post(
        "https://staging.example-app.test/qa/captcha/verify",
        json={
            "profile": profile_name,
            "pageUrl": page_url,
            "token": token,
            "environment": "staging",
        },
        timeout=30,
    )
    response.raise_for_status()
    return response.json()

Le profil reste ici un point d'ancrage de reproductibilité. Le token n'est jamais rejoué contre un site tiers : il alimente un contrôle QA face à votre propre endpoint de vérification en staging.

Dépannage des profils QA

Questions fréquentes

Faut-il vraiment un profil distinct pour chaque cas de test ?

Oui. Dès que deux scénarios partagent des cookies ou du stockage, leurs états fuient l'un dans l'autre et vos résultats cessent d'être reproductibles.

Comment garder les exécutions locales et la CI cohérentes ?

Chargez les mêmes fixtures d'état de départ dans les deux environnements et réinitialisez le profil avant chaque passage : tout écart doit alors venir du code testé.

Quels types de CAPTCHA puis-je valider dans une suite QA ?

CaptchaAI couvre reCAPTCHA v2, reCAPTCHA v3, Cloudflare Turnstile, Cloudflare Challenge, GeeTest v3, ainsi que les CAPTCHA image/OCR et les grilles d'images. Il lui suffit du sitekey et de l'URL de la page.

Comment éviter qu'un ancien cookie fausse un test ?

Rechargez explicitement l'état du profil avant chaque exécution plutôt que de compter sur le navigateur, et journalisez le rôle et l'environnement.

Guides connexes

• le démarrage rapide CaptchaAI
• les tests QA CAPTCHA en environnement autorisé
• l'intégration continue avec tests CAPTCHA
• tester les endpoints CAPTCHA de vos formulaires

Structurez vos profils QA par cas de test et par environnement — CaptchaAI rend vos contrôles CAPTCHA reproductibles dans vos suites de staging.