Checkout-Integrationstests für stark nachgefragte Produkte

Anwendungsbereich: Dieser Leitfaden behandelt ausschließlich das Testen von Checkout- und Zahlungsflows, die Sie selbst betreiben oder für die eine ausdrückliche Genehmigung vorliegt. Alle Muster sind für eigene Staging-Umgebungen und autorisierte QA gedacht – nicht für automatisierte Käufe auf fremden Plattformen oder in fremden Stores.

Ein CAPTCHA im Checkout lässt sich genauso deterministisch prüfen wie jede andere Formularvalidierung – vorausgesetzt, der Test läuft gegen eine eigene Staging-Umgebung und nicht gegen ein fremdes Produktivsystem. Genau darum geht es hier: reCAPTCHA v2, reCAPTCHA v3 und Cloudflare Turnstile in Ihrer eigenen Checkout-Pipeline verifizieren, ganz ohne echte Zahlungen und ohne reales Inventar. CaptchaAI liefert dabei das Token, das Ihr Test in das erwartete Formularfeld einträgt, sodass der Flow bis zur serverseitigen Validierung durchläuft.

Der Nutzen ist konkret: Eine wackelige CAPTCHA-Integration erzeugt sonst sporadische Fehlschläge in der CI, die niemand reproduzieren kann. Ein sauberer Smoke-Test beantwortet dagegen auf einen Blick, ob die Integration trägt:

• Lädt das Widget beim erwarteten Trigger?
• Kommt das gelöste Token im richtigen Formularfeld an?
• Akzeptiert das Backend das Token in der serverseitigen Prüfung?

Was ein Checkout-CAPTCHA-Test abdecken muss

Jeder dieser Punkte zahlt direkt auf die Zuverlässigkeit ein. Zwei Effekte machen sich im QA-Alltag sofort bemerkbar:

• deutlich weniger manuelle Wiederholungen pro Testlauf
• eindeutige Zuordnung eines Fehlschlags zu Browser, CAPTCHA-Integration oder Server-Logik

Welche CAPTCHA-Typen im Checkout auftauchen

Diese drei Typen deckt CaptchaAI produktiv ab und sind damit die relevanten Kandidaten für Ihre Checkout-QA. hCaptcha und FunCaptcha werden von CaptchaAI nicht unterstützt – falls Ihr Shop einen dieser Typen einsetzt, planen Sie den Test entsprechend anders und erwarten Sie keinen CaptchaAI-Token dafür.

Smoke-Test für eine eigene Checkout-Seite

Der folgende Smoke-Test läuft gegen eine Staging-Umgebung – etwa einen Shopware- oder JTL-Store in Ihrer Testinstanz. Es kommen keine echten Zahlungsmittel zum Einsatz, und alle URLs sind Test-Endpunkte:

import requests
import time

CAPTCHAAI_KEY = "YOUR_API_KEY"
CAPTCHAAI_URL = "https://ocr.captchaai.com"


def solve_checkout_captcha(sitekey, pageurl):
    resp = requests.post(
        f"{CAPTCHAAI_URL}/in.php",
        data={
            "key": CAPTCHAAI_KEY,
            "method": "userrecaptcha",
            "googlekey": sitekey,
            "pageurl": pageurl,
            "json": 1,
        },
        timeout=30,
    )
    resp.raise_for_status()
    task_id = resp.json()["request"]

    for _ in range(30):
        time.sleep(5)
        result = requests.get(
            f"{CAPTCHAAI_URL}/res.php",
            params={"key": CAPTCHAAI_KEY, "action": "get", "id": task_id, "json": 1},
            timeout=30,
        )
        result.raise_for_status()
        data = result.json()
        if data.get("status") == 1:
            return data["request"]

    raise TimeoutError("CAPTCHA-Lösungszeit abgelaufen")


def checkout_smoke_test():
    session = requests.Session()
    staging_url = "https://staging.example-store.test/checkout"
    page = session.get(staging_url, timeout=30)
    page.raise_for_status()

    # sitekey aus Ihrer eigenen Staging-Konfiguration
    sitekey = "6Lc_TEST_SITEKEY_OWNED_STORE"
    token = solve_checkout_captcha(sitekey, staging_url)

    submit_response = session.post(
        f"{staging_url}/submit",
        data={
            "g-recaptcha-response": token,
            "product_id": "TEST-SKU-001",       # Testprodukt (kein echtes Inventar)
            "payment_token": "tok_test_example", # Fake-Zahlungstoken
        },
        timeout=30,
    )
    assert submit_response.status_code == 200, (
        f"Checkout fehlgeschlagen: {submit_response.status_code}"
    )
    print("Smoke-Test bestanden: Checkout akzeptiert Token und gibt 200 zurueck")


if __name__ == "__main__":
    checkout_smoke_test()

Der Token gilt nur rund 120 Sekunden – lösen Sie ihn deshalb erst kurz vor der Übermittlung und setzen Sie ihn sofort ein.

Mehrere CAPTCHA-Typen in einem Durchlauf prüfen

Setzt Ihr Shop je nach Seite unterschiedliche CAPTCHA-Typen ein – etwa reCAPTCHA v2 auf der Warenkorb-Seite und Turnstile im Checkout –, prüfen Sie sie tabellengesteuert in einem einzigen Testlauf:

import requests
import time

CAPTCHAAI_KEY = "YOUR_API_KEY"
CAPTCHAAI_URL = "https://ocr.captchaai.com"


def solve_turnstile(sitekey, pageurl):
    resp = requests.post(
        f"{CAPTCHAAI_URL}/in.php",
        data={
            "key": CAPTCHAAI_KEY,
            "method": "turnstile",
            "sitekey": sitekey,
            "pageurl": pageurl,
            "json": 1,
        },
        timeout=30,
    )
    resp.raise_for_status()
    task_id = resp.json()["request"]

    for _ in range(24):
        time.sleep(5)
        result = requests.get(
            f"{CAPTCHAAI_URL}/res.php",
            params={"key": CAPTCHAAI_KEY, "action": "get", "id": task_id, "json": 1},
            timeout=30,
        )
        result.raise_for_status()
        data = result.json()
        if data.get("status") == 1:
            return data["request"]

    raise TimeoutError("Turnstile-Lösungszeit abgelaufen")


def solve_recaptcha_v2(sitekey, pageurl):
    resp = requests.post(
        f"{CAPTCHAAI_URL}/in.php",
        data={
            "key": CAPTCHAAI_KEY,
            "method": "userrecaptcha",
            "googlekey": sitekey,
            "pageurl": pageurl,
            "json": 1,
        },
        timeout=30,
    )
    resp.raise_for_status()
    task_id = resp.json()["request"]

    for _ in range(30):
        time.sleep(5)
        result = requests.get(
            f"{CAPTCHAAI_URL}/res.php",
            params={"key": CAPTCHAAI_KEY, "action": "get", "id": task_id, "json": 1},
            timeout=30,
        )
        result.raise_for_status()
        data = result.json()
        if data.get("status") == 1:
            return data["request"]

    raise TimeoutError("reCAPTCHA-v2-Lösungszeit abgelaufen")


CHECKOUT_TEST_CASES = [
    {
        "name": "Warenkorb-Seite (reCAPTCHA v2)",
        "url": "https://staging.example-store.test/cart",
        "sitekey": "6Lc_TEST_V2_SITEKEY",
        "method": "recaptcha_v2",
    },
    {
        "name": "Checkout-Seite (Cloudflare Turnstile)",
        "url": "https://staging.example-store.test/checkout",
        "sitekey": "0x4AAAA_TEST_TURNSTILE_SITEKEY",
        "method": "turnstile",
    },
]

for test in CHECKOUT_TEST_CASES:
    print(f"Teste: {test['name']}")
    try:
        if test["method"] == "turnstile":
            token = solve_turnstile(test["sitekey"], test["url"])
        else:
            token = solve_recaptcha_v2(test["sitekey"], test["url"])
        print(f"  Token erhalten: {token[:20]}...")
        print(f"  Status: BESTANDEN")
    except Exception as exc:
        print(f"  Status: FEHLGESCHLAGEN — {exc}")

Neue Test-Cases fügen Sie als weitere Einträge in der Liste hinzu – die Solver-Funktionen bleiben unverändert.

Token serverseitig verifizieren

Ein Smoke-Test ist erst dann aussagekräftig, wenn er auch die serverseitige Prüfung abdeckt. Testen Sie deshalb, ob Ihr Backend das CAPTCHA-Token korrekt validiert:

import requests

GOOGLE_VERIFY_URL = "https://www.google.com/recaptcha/api/siteverify"


def verify_token_server_side(token, secret_key):
    # Token serverseitig verifizieren - nur in Ihrer eigenen Umgebung
    response = requests.post(
        GOOGLE_VERIFY_URL,
        data={"secret": secret_key, "response": token},
        timeout=10,
    )
    response.raise_for_status()
    return response.json()


# Nur mit Ihrem eigenen Test-Secret-Key verwenden
result = verify_token_server_side(
    token="SOLVED_TOKEN_FROM_CAPTCHAAI",
    secret_key="6LeIxAcTAAAAAGG-vFI1TnRWxMZNFuojJ4WifJWe",  # Google-Testschluessel
)
print("Verifikation:", result)
# Erwartete Ausgabe: {"success": true, "score": 0.9, "action": "checkout"}

Prüfen Sie dabei nicht nur den Gutfall: Ein absichtlich abgelaufenes oder manipuliertes Token sollte serverseitig sauber abgelehnt werden – erst dann ist die Fehlerbehandlung Ihres Backends verifiziert.

Fehlerbehebung

Häufige Fragen

Wie bleiben Checkout-Tests deterministisch, wenn Token nach ~120 Sekunden ablaufen?

Lösen Sie das Token unmittelbar vor der Übermittlung, nicht am Anfang des Testlaufs. In der CI heißt das: erst Warenkorb und Sitzung aufbauen, dann das CAPTCHA lösen und sofort absenden. So läuft der Test nicht ins Timeout, weil das Token zwischen Lösung und Einsatz veraltet.

Darf ich echte Kundendaten für Checkout-Tests verwenden?

Nein. Nutzen Sie synthetische Testdaten, Test-SKUs und Fake-Zahlungstokens. Reale Namen, Adressen oder Zahlungsdaten fallen unter die DSGVO und haben in einer Staging-Umgebung nichts zu suchen – synthetische Daten sind hier nicht nur sicherer, sondern auch reproduzierbarer.

Wie viele Checkout-Tests kann ich parallel fahren?

So viele, wie Ihr Thread-Kontingent zulässt. CaptchaAI rechnet pro gleichzeitigem Thread ab, nicht pro Lösung – BASIC (15 $/Monat, 5 Threads) genügt für kleine Test-Suites, größere Lastläufe skalieren über ADVANCE (90 $/Monat, 50 Threads). Achten Sie darauf, dass Ihre Test-Sitekeys nicht mit der Produktionskonfiguration kollidieren.

Was tun, wenn das Backend das Token mit 403 ablehnt?

Prüfen Sie zuerst Secret-Key und Verify-Endpunkt: Ein 403 nach der Übermittlung deutet fast immer auf eine fehlgeschlagene serverseitige Validierung hin, nicht auf ein fehlerhaftes Token. Verifizieren Sie das Token mit dem oben gezeigten siteverify-Aufruf und vergleichen Sie action und score mit den Erwartungen Ihres Backends.

Fazit

Ein Checkout-CAPTCHA lässt sich so zuverlässig prüfen wie jede andere Formularvalidierung – solange der Test gegen eine eigene Staging-Umgebung läuft. reCAPTCHA v2, reCAPTCHA v3 und Cloudflare Turnstile deckt CaptchaAI produktiv ab: Der Token wird gelöst, ins erwartete Formularfeld eingetragen und serverseitig verifiziert. So verschwinden sporadische CI-Fehlschläge, und ein verbleibender Fehler lässt sich eindeutig Browser, Integration oder Backend zuordnen.

Verwandte Leitfäden

• CaptchaAI in wenigen Minuten einrichten
• CAPTCHA-QA in autorisierten Testumgebungen
• CAPTCHA-Endpoints in eigenen Webformularen testen
• CAPTCHA-Tests in die Continuous Integration einbinden

Prüfen Sie Ihre Checkout-Integration zuverlässig – holen Sie sich Ihren CaptchaAI-Schlüssel.