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

Périmètre : ce guide décrit la séparation des profils de navigateur dans vos propres environnements QA ou autorisés. L'objectif est un test reproductible avec cookies, stockage et comptes de test isolés. Il ne décrit ni technique de contournement, ni masquage d'identité, ni manipulation d'empreinte.

Quand plusieurs comptes de test sont utilisés en parallèle, les défauts ne viennent souvent pas du CAPTCHA lui-même, mais de sessions polluées : d'anciens cookies restent actifs, le stockage local écrase de nouvelles données ou un profil reprend par inadvertance l'état d'un autre cas de test. Une séparation propre des profils rend les exécutions QA plus stables et plus parlantes.

Pourquoi séparer les profils en QA

Dans les environnements de staging et de préproduction, vous voulez pouvoir rejouer chaque scénario isolément :

• première visite sans session existante,
• retour d'un compte de test connu,
• changement de région ou de tenant,
• tests de régression parallèles avec plusieurs rôles.

Sans profils séparés, ces cas se chevauchent. Les résultats deviennent difficiles à reproduire et il est impossible de dire si un comportement CAPTCHA vient de l'intégration ou d'un état résiduel du navigateur.

Ce qui doit être isolé par profil

En QA, il suffit de séparer proprement les données qui portent un état. La cible est la reproductibilité, pas la manipulation du navigateur.

Si votre équipe utilise un gestionnaire de profils, il doit servir uniquement d'outil QA pour des limites de session propres. L'important n'est pas l'outil mais la discipline : définir clairement un profil par cas de test et le réinitialiser de manière cohérente après chaque exécution.

Exemple : état de profil pour un test staging

Un schéma pragmatique consiste à enregistrer l'état de départ de chaque rôle dans un fichier et à le recharger de manière contrôlée à 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"))

Avec cette structure, vous pouvez définir par exemple les profils checkout-first-visit, logged-in-user ou expired-session et réutiliser le même état de départ dans plusieurs exécutions de test.

Utiliser CaptchaAI dans une suite QA interne

Une fois les profils correctement séparés, la vérification CAPTCHA s'intègre de façon stable à votre suite, par rôle de test.

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 sert ici uniquement de point d'ancrage de reproductibilité. Le résultat CAPTCHA n'est pas réutilisé pour des sites tiers : il est consommé par un contrôle QA documenté contre votre propre vérification.

Dépannage

Guides connexes sûrs

• Démarrage rapide CaptchaAI
• Tests QA CAPTCHA dans des environnements autorisés
• Intégration continue avec des tests CAPTCHA
• Tester les endpoints CAPTCHA dans vos formulaires web

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