Redis für CAPTCHA-Token-TTL-Diagnose in QA-Workflows

CAPTCHA-Ergebnisse haben kurze Gültigkeitsfenster. In QA ist deshalb nicht entscheidend, wie man Token "wiederverwendet", sondern wie man sauber misst, wann ein Ergebnis erzeugt wurde, wann es abläuft und wie das eigene Backend in Grenzfällen reagiert. Redis eignet sich dafür hervorragend, weil Ablaufzeiten, Zeitfenster und Korrelationen präzise protokolliert werden können.

Anwendungsbereich: Dieser Leitfaden beschreibt Diagnose- und Telemetrie-Muster für eigene oder autorisierte QA-Umgebungen. Er dient dazu, Ablaufzeiten und Backend-Reaktionen zu messen, nicht zur Umgehung fremder Schutzsysteme.

Warum TTL-Diagnose in QA wichtig ist

In vielen Teams ist unklar, warum ein Testlauf einmal erfolgreich ist und kurz darauf scheitert. Die Ursache liegt oft im Timing:

• das Widget wurde korrekt geladen,
• die CaptchaAI-Aufgabe wurde korrekt angelegt,
• das Ergebnis kam an,
• aber die Backend-Prüfung erfolgte zu spät oder mit falschem Kontext.

Redis hilft hier als Diagnose-Layer, weil Sie für jeden Lauf dieselben Fragen beantworten können:

• Wann wurde das Ergebnis angefordert?
• Wann wurde es erhalten?
• Wie groß war das Restfenster bis zum Ablauf?
• Welche Antwort gab das eigene Backend zurück?

Welche Daten Sie in Redis speichern sollten

Für QA genügen wenige, aber saubere Felder. Wichtig ist, dass Sie Zeitfenster dokumentieren, statt Ergebnisse für andere Seiten oder andere Kontexte weiterzureichen.

Beispiel: Token-Laufzeiten in Redis protokollieren

from __future__ import annotations

from datetime import datetime, timedelta, timezone
import json
import redis


r = redis.Redis(host="localhost", port=6379, decode_responses=True)


def token_record_key(test_run_id: str) -> str:
    return f"qa:captcha:ttl:{test_run_id}"


def store_ttl_record(*, test_run_id: str, task_id: str, received_token: str, ttl_seconds: int) -> str:
    now = datetime.now(timezone.utc)
    payload = {
        "task_id": task_id,
        "token_preview": received_token[:16],
        "issued_at": now.isoformat(),
        "expires_at": (now + timedelta(seconds=ttl_seconds)).isoformat(),
        "verification_result": "pending",
        "environment": "staging",
    }
    key = token_record_key(test_run_id)
    r.set(key, json.dumps(payload), ex=ttl_seconds)
    return key

Dieses Muster ist bewusst auf Diagnose reduziert. Es speichert nur so viel wie nötig, um QA-Läufe zu analysieren und Ablaufgrenzen reproduzierbar zu testen.

CaptchaAI-Aufgabe in einen QA-Lauf einbinden

import requests
import time


API_KEY = "YOUR_API_KEY"


def submit_and_poll(page_url: str, sitekey: str) -> tuple[str, str]:
    submit = requests.post(
        "https://ocr.captchaai.com/in.php",
        data={
            "key": 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", "submit failed"))

    task_id = submit_json["request"]
    for _ in range(30):
        time.sleep(5)
        result = requests.get(
            "https://ocr.captchaai.com/res.php",
            params={"key": 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 task_id, result_json["request"]

    raise TimeoutError("CaptchaAI polling timed out")

Im nächsten Schritt dokumentieren Sie das Ergebnis nicht als allgemeines Cache-Objekt, sondern als QA-Messpunkt mit klarer Ablaufgrenze.

Ablaufgrenzen gegen das eigene Backend prüfen

Ein sinnvoller QA-Test besteht oft aus zwei Durchläufen:

1. sofortige Verifikation nach Eintreffen des Ergebnisses
2. absichtlich verzögerte Verifikation kurz vor oder nach dem internen Ablaufgrenzwert

def verify_in_staging(token: str, test_run_id: str, delay_seconds: int = 0) -> dict:
    if delay_seconds:
        time.sleep(delay_seconds)

    response = requests.post(
        "https://staging.example-app.test/qa/captcha/verify",
        json={
            "token": token,
            "testRunId": test_run_id,
            "environment": "staging",
        },
        timeout=30,
    )
    response.raise_for_status()
    return response.json()

So erkennen Sie, ob Ihre eigene Backend-Implementierung abgelaufene oder verspätete Ergebnisse erwartungsgemäß zurückweist und ob Fehlercodes sauber im Monitoring auftauchen.

Fehlerbehebung

Sichere verwandte Leitfäden

• CaptchaAI Schnellstart
• CAPTCHA-QA in autorisierten Testumgebungen
• CAPTCHA-Endpoints in eigenen Webformularen testen
• Kontinuierliche Integration mit CAPTCHA-Tests

Dokumentieren Sie Ablaufgrenzen und Backend-Reaktionen mit belastbaren QA-Daten – CaptchaAI unterstützt reproduzierbare Verifikationsläufe in eigenen Umgebungen.