Cas d'usage : tests E2E, scraping, RPA

Trois domaines, un même outil

Dans cette dernière leçon, vous allez explorer trois cas d’usage concrets de Computer Use en production. Chacun illustre une facette différente de la technologie et les bonnes pratiques associées.

Cas 1 : Tests End-to-End (E2E)

Le problème des tests classiques

Les tests E2E traditionnels (Selenium, Cypress, Playwright) reposent sur des sélecteurs CSS ou XPath. Ils cassent dès que l’interface change — un bouton renommé, une classe CSS modifiée, un composant restructuré.

Avec Computer Use, les tests deviennent visuels : l’agent voit l’interface comme un utilisateur et agit en conséquence.

Implémentation

import anthropic
import base64
from playwright.sync_api import sync_playwright

def e2e_test(test_name: str, steps: str, expected_outcome: str):
    """Exécute un test E2E via Computer Use."""
    client = anthropic.Anthropic()

    pw = sync_playwright().start()
    browser = pw.chromium.launch(headless=True)
    page = browser.new_page(viewport={"width": 1280, "height": 720})

    task = f"""
    Tu exécutes un test E2E nommé "{test_name}".

    ÉTAPES :
    {steps}

    RÉSULTAT ATTENDU :
    {expected_outcome}

    INSTRUCTIONS :
    - Exécute chaque étape dans l'ordre
    - Après la dernière étape, vérifie le résultat attendu
    - Retourne PASS si le résultat correspond, FAIL sinon
    - En cas de FAIL, décris précisément ce qui ne correspond pas
    """

    result = run_agent(task, page=page)

    browser.close()
    pw.stop()
    return result


# Exemple : tester le formulaire de contact
result = e2e_test(
    test_name="Formulaire de contact",
    steps="""
    1. Va sur https://monsite.com/contact
    2. Remplis le champ 'Nom' avec 'Test Automatisé'
    3. Remplis le champ 'Email' avec '[email protected]'
    4. Remplis le champ 'Message' avec 'Test E2E automatisé'
    5. Clique sur 'Envoyer'
    """,
    expected_outcome="""
    Un message de confirmation apparaît :
    'Votre message a été envoyé' ou similaire.
    Pas de message d'erreur visible.
    """
)
print(f"Résultat : {result}")

Avantages par rapport aux tests classiques

• Pas de sélecteurs CSS fragiles
• Résilient aux changements de design
• Vérifie l’expérience utilisateur réelle (pas seulement le DOM)
• Détecte les problèmes visuels (chevauchement, texte tronqué)

Limites

• Plus lent (5-30s par test vs 1-5s pour Playwright pur)
• Coût API non négligeable pour des suites de tests complètes
• Non déterministe : le même test peut donner des résultats différents

Cas 2 : Scraping intelligent

Quand le scraping classique échoue

Le scraping classique (BeautifulSoup, Scrapy) échoue face aux sites qui :

• Chargent le contenu en JavaScript (SPA)
• Utilisent du shadow DOM ou des web components
• Changent régulièrement leur structure HTML
• Implémentent des protections anti-bot

Computer Use contourne ces obstacles en agissant comme un vrai utilisateur.

Pipeline de scraping

import json
from datetime import datetime

def scraping_pipeline(urls: list[str], extraction_prompt: str):
    """Pipeline de scraping avec Computer Use."""
    all_data = []

    for url in urls:
        pw = sync_playwright().start()
        browser = pw.chromium.launch(headless=True)
        page = browser.new_page(
            viewport={"width": 1280, "height": 720}
        )
        page.goto(url)
        page.wait_for_load_state("networkidle")

        task = f"""
        Tu es sur la page {url}.
        {extraction_prompt}

        Retourne les données au format JSON strict.
        Si la page est vide ou inaccessible, retourne {{"error": "page inaccessible"}}.
        """

        result = run_agent(task, page=page)

        try:
            data = json.loads(result)
            data["_source_url"] = url
            data["_extracted_at"] = datetime.utcnow().isoformat()
            all_data.append(data)
        except json.JSONDecodeError:
            all_data.append({
                "_source_url": url,
                "_error": "JSON invalide",
                "_raw": result[:500],
            })

        browser.close()
        pw.stop()

    return all_data


# Exemple : scraper des fiches produits
data = scraping_pipeline(
    urls=[
        "https://shop.example.com/product/1",
        "https://shop.example.com/product/2",
        "https://shop.example.com/product/3",
    ],
    extraction_prompt="""
    Extrais les informations suivantes du produit :
    - nom (string)
    - prix (nombre, en euros)
    - disponible (boolean)
    - description (string, max 200 caractères)
    - note_moyenne (nombre, sur 5)
    """
)

Bonnes pratiques scraping

• Respectez les robots.txt et les conditions d’utilisation
• Espacez les requêtes (1-2 secondes entre chaque page)
• Utilisez un user-agent honnête qui identifie votre bot
• Ne surchargez pas le serveur cible
• Stockez les données brutes pour retraitement ultérieur

Cas 3 : RPA (Robotic Process Automation)

Automatiser les applications sans API

De nombreux logiciels métier (ERP, CRM, outils comptables) n’offrent pas d’API. Computer Use permet de les automatiser via leur interface web ou desktop.

Exemple : saisie de factures

def saisir_facture(page, facture: dict):
    """Saisit une facture dans le logiciel comptable."""
    task = f"""
    Tu es connecté au logiciel de comptabilité.

    Saisis cette facture :
    - Fournisseur : {facture["fournisseur"]}
    - Numéro de facture : {facture["numero"]}
    - Date : {facture["date"]}
    - Montant HT : {facture["montant_ht"]} EUR
    - TVA : {facture["tva"]}%
    - Description : {facture["description"]}

    Étapes :
    1. Clique sur "Nouvelle facture" ou "Créer"
    2. Remplis tous les champs dans l'ordre
    3. Vérifie que le montant TTC calculé est correct
    4. Clique sur "Enregistrer" ou "Valider"
    5. Confirme que la facture a été enregistrée avec succès
    """

    return run_agent(task, page=page)


# Traitement par lot
factures = [
    {
        "fournisseur": "ACME Corp",
        "numero": "FAC-2026-0042",
        "date": "01/04/2026",
        "montant_ht": 1500.00,
        "tva": 20,
        "description": "Prestations de conseil Q1 2026",
    },
    {
        "fournisseur": "TechParts SAS",
        "numero": "TP-26-1337",
        "date": "02/04/2026",
        "montant_ht": 3200.00,
        "tva": 20,
        "description": "Fourniture de matériel informatique",
    },
]

for facture in factures:
    result = saisir_facture(page, facture)
    print(f"Facture {facture['numero']} : {result}")

Workflow RPA complet

Un workflow RPA typique en production inclut :

1. Planification : Cron job ou déclencheur événementiel
2. Connexion : Authentification automatique (cookies, TOTP)
3. Exécution : Séquence d’actions avec checkpoints
4. Validation : Vérification des résultats
5. Reporting : Envoi d’un rapport de synthèse

def rpa_daily_workflow():
    """Workflow RPA quotidien."""
    metrics = WorkflowMetrics(workflow_id="daily-invoices")

    try:
        # Connexion
        page = setup_authenticated_session()
        metrics.steps_total = len(factures_du_jour)

        # Traitement
        for facture in factures_du_jour:
            try:
                saisir_facture(page, facture)
                metrics.steps_completed += 1
            except Exception as e:
                metrics.record_error(str(e), facture["numero"])

        # Reporting
        metrics.finalize()
        send_report(metrics.summary())

    except Exception as e:
        alert_human(f"Workflow RPA échoué : {e}")

Choisir le bon cas d’usage

Points clés à retenir

• Tests E2E : Computer Use rend les tests résilients aux changements d’interface mais plus lents et non déterministes
• Scraping : Idéal pour les sites dynamiques inaccessibles aux scrapers classiques, mais respectez l’éthique et la légalité
• RPA : Permet d’automatiser des logiciels métier sans API, avec un ROI élevé sur les tâches répétitives
• Choisissez Computer Use quand les outils classiques ne fonctionnent pas ou sont trop fragiles
• Combinez toujours monitoring, gestion d’erreurs et sandboxing en production