Skill de test ScoutQA

Effectuez des tests exploratoires alimentés par l'IA sur des applications web en utilisant le CLI scoutqa.

Pensez à ScoutQA comme un partenaire de test intelligent capable d'explorer de manière autonome, de découvrir des problèmes et de vérifier les fonctionnalités. Déléguez les tests à plusieurs exécutions ScoutQA parallèles pour maximiser la couverture tout en économisant du temps.

Quand utiliser ce skill

Utilisez ce skill dans deux scénarios :

1. Requêtes de l'utilisateur pour tester - Quand l'utilisateur demande explicitement de tester un site web ou de vérifier une fonctionnalité
2. Vérification proactive - Après l'implémentation de fonctionnalités web, exécutez automatiquement les tests pour vérifier que l'implémentation fonctionne correctement

Exemple d'utilisation proactive :

• Après l'implémentation d'un formulaire de connexion → Testez le flux d'authentification
• Après l'ajout de validation de formulaire → Vérifiez les règles de validation et la gestion des erreurs
• Après la construction d'un flux de paiement → Testez le processus d'achat de bout en bout
• Après la correction d'un bug → Vérifiez que la correction fonctionne et n'a pas cassé d'autres fonctionnalités

Bonne pratique : Quand vous finissez d'implémenter une fonctionnalité web, lancez proactivement un test ScoutQA en arrière-plan pour vérifier qu'il fonctionne pendant que vous continuez avec d'autres tâches.

Exécuter les tests

Flux de travail des tests

Copiez cette checklist et suivez votre progression :

Progression des tests :

• [ ] Écrire un prompt de test spécifique avec des attentes claires
• [ ] Exécuter la commande scoutqa en arrière-plan
• [ ] Informer l'utilisateur de l'ID d'exécution et de l'URL du navigateur
• [ ] Extraire et analyser les résultats

Étape 1 : Écrire un prompt de test spécifique

Consultez la section « Writing Effective Prompts » ci-dessous pour les directives.

Étape 2 : Exécuter la commande scoutqa

IMPORTANT : Utilisez le paramètre timeout de l'outil Bash (5000ms = 5 secondes) pour capturer les détails d'exécution :

Lors de l'appel de l'outil Bash, définissez timeout: 5000 comme paramètre :

• Ceci est le paramètre timeout intégré de l'outil Bash dans Claude Code (PAS la commande Unix timeout)
• Après 5 secondes, l'outil Bash retourne le contrôle avec un ID de tâche et le processus continue de s'exécuter en arrière-plan
• Ceci est différent du timeout Unix qui tue le processus - ici le processus continue de s'exécuter
• Les 5 premières secondes capturent l'ID d'exécution et l'URL du navigateur depuis la sortie de ScoutQA
• Le test continue de s'exécuter à distance sur l'infrastructure de ScoutQA avec la tâche en arrière-plan

scoutqa --url "https://example.com" --prompt "Your test instructions"

Dans les premières secondes, la commande affichera :

• ID d'exécution (p. ex., 019b831d-xxx)
• URL du navigateur (p. ex., https://app.scoutqa.ai/t/019b831d-xxx)
• Appels d'outils initiaux montrant la progression du test

Après le timeout de 5 secondes, l'outil Bash retourne un ID de tâche et la commande continue de s'exécuter en arrière-plan. Vous pouvez travailler sur d'autres tâches pendant que le test s'exécute. Le timeout n'est que pour capturer la sortie initiale (ID d'exécution et URL du navigateur) - le test continue de s'exécuter à la fois localement en tant que tâche en arrière-plan et à distance sur l'infrastructure de ScoutQA.

Étape 3 : Informer l'utilisateur de l'ID d'exécution et de l'URL du navigateur

Une fois que l'outil Bash retourne avec l'ID de tâche (ayant capturé les détails d'exécution dans les 5 premières secondes), informez l'utilisateur de :

• L'ID d'exécution ScoutQA et l'URL du navigateur afin qu'il puisse surveiller la progression dans son navigateur
• L'ID de tâche en arrière-plan s'il souhaite vérifier la sortie de commande locale plus tard

Le test continue de s'exécuter en arrière-plan pendant que vous continuez d'autres travaux.

Étape 4 : Extraire et analyser les résultats

Consultez la section « Présentation des résultats » ci-dessous pour le format complet.

Options de commande

• --url (obligatoire) : URL du site web à tester (supporte localhost / 127.0.0.1)
• --prompt (obligatoire) : Instructions de test en langage naturel
• --project-id (optionnel) : Associer à un projet pour le suivi
• -v, --verbose (optionnel) : Afficher tous les appels d'outils y compris les appels internes

Support des tests locaux

ScoutQA supporte les tests des URLs localhost et 127.0.0.1 de manière autonome — aucune configuration manuelle requise.

# Testez facilement une application s'exécutant localement lorsque vous développez votre application
scoutqa --url "http://localhost:3000" --prompt "Test the registration form"

Quand utiliser chaque commande

Commencer un nouveau test ? → Utilisez scoutqa --url --prompt Vérifier un problème connu ? → Utilisez scoutqa issue-verify --issue-id <id> Trouver les IDs de problèmes à partir d'une exécution ? → Utilisez scoutqa list-issues --execution-id <id> L'agent a besoin de plus de contexte ? → Utilisez scoutqa send-message (voir « Following Up on Stuck Executions »)

Écrire des prompts efficaces

Concentrez-vous sur ce qu'il faut explorer et vérifier, pas sur des étapes prescriptives. ScoutQA détermine de manière autonome comment tester.

Exemple : Flux d'inscription utilisateur

scoutqa --url "https://example.com" --prompt "
Explore the user registration flow. Test form validation edge cases,
verify error handling, and check accessibility compliance.
"

Exemple : Paiement e-commerce

scoutqa --url "https://shop.example.com" --prompt "
Test the checkout flow. Verify pricing calculations, cart persistence,
payment options, and mobile responsiveness.
"

Exemple : Exécuter des tests parallèles pour une couverture complète

Lancez plusieurs tests en parallèle en effectuant plusieurs appels d'outils Bash dans un seul message, chacun avec le paramètre timeout de l'outil Bash défini à 5000 (millisecondes) :

# Test 1: Authentification et sécurité
scoutqa --url "https://app.example.com" --prompt "
Explore authentication: login/logout, session handling, password reset,
and security edge cases.
"

# Test 2: Fonctionnalités principales (s'exécute en parallèle)
scoutqa --url "https://app.example.com" --prompt "
Test dashboard and main user workflows. Verify data loading,
CRUD operations, and search functionality.
"

# Test 3: Accessibilité (s'exécute en parallèle)
scoutqa --url "https://app.example.com" --prompt "
Conduct accessibility audit: WCAG compliance, keyboard navigation,
screen reader support, color contrast.
"

Implémentation : Envoyez un seul message avec trois appels d'outils Bash. Pour chaque invocation d'outil Bash, définissez le paramètre timeout sur 5000 millisecondes. Après 5 secondes, chaque appel Bash retourne avec un ID de tâche pendant que les processus continuent de s'exécuter en arrière-plan. Cela capture l'ID d'exécution et l'URL du navigateur de chaque test dans la sortie initiale, puis tous les trois continuent de s'exécuter en parallèle (à la fois en tant que tâches en arrière-plan localement et à distance sur l'infrastructure de ScoutQA).

Directives clés :

• Décrivez ce qu'il faut tester, pas comment tester (ScoutQA détermine les étapes)
• Concentrez-vous sur les objectifs, les cas limites et les préoccupations
• Exécutez plusieurs exécutions parallèles pour différentes zones de test
• Faites confiance à ScoutQA pour explorer et découvrir les problèmes de manière autonome
• Définissez toujours le paramètre timeout de l'outil Bash sur 5000 millisecondes lors de l'appel des commandes scoutqa (cela retourne le contrôle après 5 secondes pendant que le processus continue en arrière-plan)
• Pour les tests parallèles, effectuez plusieurs appels d'outils Bash dans un seul message
• N'oubliez pas : Bash tool timeout ≠ commande Unix timeout (Bash timeout continue le processus en arrière-plan, Unix timeout le tue)

Scénarios de test courants

Test de fumée après déploiement :

scoutqa --url "$URL" --prompt "
Smoke test: verify critical functionality works after deployment.
Check homepage, navigation, login/logout, and key user flows.
"

Audit d'accessibilité :

scoutqa --url "$URL" --prompt "
Audit accessibility: WCAG 2.1 AA compliance, keyboard navigation,
screen reader support, color contrast, and semantic HTML.
"

Tests d'e-commerce :

scoutqa --url "$URL" --prompt "
Explore e-commerce functionality: product search/filtering,
cart operations, checkout flow, and pricing calculations.
"

Application SaaS :

scoutqa --url "$URL" --prompt "
Test SaaS app: authentication, dashboard, CRUD operations,
permissions, and data integrity.
"

Validation de formulaire :

scoutqa --url "$URL" --prompt "
Test form validation: edge cases, error handling, required fields,
format validation, and successful submission.
"

Réactivité mobile :

scoutqa --url "$URL" --prompt "
Check mobile experience: responsive layout, navigation,
touch interactions, and viewport behavior.
"

Vérification d'un problème connu :

# D'abord, trouvez les IDs de problèmes d'une exécution précédente
scoutqa list-issues --execution-id <executionId>

# Ensuite vérifiez le problème (crée une nouvelle exécution de vérification automatiquement)
scoutqa issue-verify --issue-id <issueId>

La commande issue-verify effectuera :

1. Créer une exécution de vérification pour le problème
2. Afficher l'ID d'exécution et l'URL du navigateur
3. Diffuser la progression de la vérification de l'agent en temps réel
4. Afficher un résumé d'exécution avec un lien vers les résultats

Vérification de fonctionnalité (après implémentation) :

scoutqa --url "$URL" --prompt "
Verify the new [feature name] works correctly. Test core functionality,
edge cases, error handling, and integration with existing features.
"

Exemple : Test proactif après codage d'une fonctionnalité

Après l'implémentation d'un formulaire d'inscription utilisateur, vérifiez automatiquement qu'il fonctionne :

scoutqa --url "http://localhost:3000/register" --prompt "
Test the newly implemented registration form. Verify:
- Form validation (email format, password strength, required fields)
- Error messages display correctly
- Successful registration flow
- Edge cases (duplicate emails, special characters, etc.)
"

Cela détecte les problèmes immédiatement pendant que l'implémentation est frais dans le contexte.

Lister les problèmes

Utilisez scoutqa list-issues pour parcourir les problèmes trouvés dans une exécution précédente. C'est utile pour trouver les IDs de problèmes à utiliser avec issue-verify.

scoutqa list-issues --execution-id <executionId>

Options :

• --execution-id (obligatoire) : ID d'exécution (depuis l'URL /t/<executionId> ou la sortie CLI)

Exemple de sortie :

Showing 3 issues:

🔴 019c-abc1
   Login button unresponsive on mobile
   Severity: critical | Category: usability | Status: open

🟠 019c-abc2
   Missing form validation on email field
   Severity: high | Category: functional | Status: open

🟡 019c-abc3
   Color contrast insufficient on footer links
   Severity: medium | Category: accessibility | Status: resolved

Présentation des résultats

Présentation immédiate (après lancement du test)

Juste après l'exécution de la commande scoutqa, présentez les détails d'exécution à l'utilisateur :

**ScoutQA Test Started**

Execution ID: `019b831d-xxx`
View Live: https://app.scoutqa.ai/t/019b831d-xxx

The test is running remotely. You can view real-time progress in your browser at the link above while I continue with other tasks.

Résultats finaux (après completion)

Quand l'exécution est terminée, utilisez ce format pour présenter les résultats :

**ScoutQA Test Results**

Execution ID: `ex_abc123`

**Issues Found:**

[High] Accessibility: Missing alt text on logo image

- Impact: Screen readers cannot describe the logo
- Location: Header navigation

[Medium] Usability: Submit button not visible on mobile viewport

- Impact: Users cannot complete form on mobile devices
- Location: Contact form, bottom of page

[Low] Functional: Search returns no results for valid queries

- Impact: Search feature appears broken
- Location: Main search bar

**Summary:** Found 3 issues across accessibility, usability, and functional categories. See full interactive report with screenshots at the URL above.

Toujours inclure :

• ID d'exécution (p. ex., ex_abc123) pour la référence
• Problèmes trouvés avec sévérité, catégorie (accessibilité, utilisabilité, fonctionnel), impact et localisation

Suivi des exécutions bloquées

Si l'agent distant se bloque ou a besoin de clarification, utilisez send-message pour continuer :

# Exemple : L'agent est bloqué à la connexion, l'utilisateur fournit des identifiants
scoutqa send-message --execution-id ex_abc123 --prompt "
Use these test credentials: username: testuser@example.com, password: TestPass123
"

# Exemple : L'agent demande quel flux tester ensuite
scoutqa send-message --execution-id ex_abc123 --prompt "
Focus on the checkout flow next, skip the wishlist feature
"

Vérification des résultats des tests

Les tests ScoutQA s'exécutent à distance sur l'infrastructure de ScoutQA. Après avoir démarré un test avec un timeout court pour capturer l'ID d'exécution :

1. Le test continue de s'exécuter à distance (pas localement en arrière-plan)
2. Vous pouvez continuer immédiatement d'autres travaux
3. Pour vérifier les résultats plus tard, visitez l'URL du navigateur fournie au démarrage du test
4. Alternativement, utilisez scoutqa get-execution --execution-id <id> pour récupérer les résultats via CLI

Bonne pratique : Démarrez les tests en définissant le paramètre timeout de l'outil Bash sur 5000 millisecondes. Après 5 secondes, l'outil Bash retourne le contrôle avec un ID de tâche et les détails d'exécution (ID d'exécution et URL du navigateur) pendant que le test continue de s'exécuter en arrière-plan. Vous pouvez ensuite continuer d'autres travaux et vérifier les résultats sur le site web de ScoutQA ou via CLI si nécessaire.

Dépannage