Testwire : Agents IA et Tests Flutter via MCP et rechargement à chaud

# Testwire : Intégration d'agents IA dans les tests d'intégration Flutter avec MCP et rechargement à chaud

Les agents IA peinent à rédiger des tests d'intégration Flutter en raison d'une consommation élevée de tokens, de temps de compilation longs et d'un manque de contexte visuel. Testwire résout ces problèmes en fournissant un outil d'exécution de tests étape par étape connecté au service VM via MCP. Cela permet aux agents de contrôler le processus, de prendre des captures d'écran et d'utiliser le rechargement à chaud pour des corrections rapides.

Architecture de Testwire et fonctionnement

Testwire repose sur trois composants principaux qui interagissent via le Protocole de Contexte de Modèle (MCP). Les tests s'exécutent en mode flutter run avec l'option --dart-define=AGENT_MODE=true, activant le mode debug et les extensions du service Dart VM. Le serveur MCP testwire_mcp se connecte au test via le service VM, offrant à l'agent un ensemble d'outils pour gérer l'exécution. En tant que client MCP, l'agent IA utilise ces outils pour surveiller les états des étapes, exécuter des commandes et analyser les erreurs avec accès aux visuels de l'interface.

Outils MCP clés disponibles pour l'agent :

• connect : Connexion au test via l'URI du service VM.
• step_forward : Exécution de l'étape suivante et pause.
• run_remaining : Exécution de toutes les étapes restantes, arrêt en cas d'erreur.
• retry_step : Reprise d'une étape échouée.
• get_test_state : Récupération du statut de toutes les étapes de test.
• hot_reload_testwire_test : Rechargement à chaud en préservant l'avancement.
• hot_restart_testwire_test : Redémarrage complet du test.
• screenshot : Capture de l'écran de l'interface actuelle.
• disconnect : Déconnexion du test.

Mise en œuvre des tests dans Testwire : Code et structure

Les tests Testwire sont structurés en classes étendant TestwireTest pour supporter le rechargement à chaud. Chaque test se décompose en étapes logiques avec des états : en attente, terminée, en cours ou échouée. Les étapes sont définies via la méthode step, qui inclut une description, un contexte et une action. Voici un exemple de structure de test pour valider un formulaire de retour :

class MyTest extends TestwireTest {
  MyTest() : super(
    'Soumettre le formulaire de retour',
    setUp: (tester) async {
      app.main();
      await tester.pumpAndSettle();
    },
  );

  @override
  Future<void> body(WidgetTester tester) async {
    await step(
      description: 'Naviguer vers Laisser un avis',
      context: 'Appuyer sur la tuile "Laisser un avis" de l\'écran d\'accueil.',
      action: () async {
        await tester.tap(find.byKey(const Key('leave_review_tile')));
        await tester.pumpAndSettle();
      },
    );

    await step(
      description: 'Saisir le nom',
      context: 'Taper "Alex" dans le champ nom.',
      action: () async {
        await tester.enterText(
          find.byKey(const Key('name_field')), 'Alex');
        await tester.pumpAndSettle();
      },
    );

    await step(
      description: 'Sélectionner 5 étoiles',
      context: 'Appuyer sur la 5e étoile pour définir la note à 5.',
      action: () async {
        await tester.tap(find.byKey(const Key('star_5')));
        await tester.pumpAndSettle();
      },
    );

    await step(
      description: 'Vérifier le résultat',
      context: 'Vérifier que le message de succès s\'affiche.',
      action: () async {
        expect(find.text('Merci !'), findsOneWidget);
        expect(find.text('5 étoiles d\'Alex'), findsOneWidget);
      },
    );
  }
}

Rechargement à chaud : Mécanisme central de débogage

Le rechargement à chaud de Testwire permet aux agents de corriger le code des tests sans recompilation complète, en préservant l'avancement de l'exécution. Lors d'un échec d'étape, le test se met en pause, l'agent examine les logs, l'état VM et les captures d'écran de l'interface, puis déclenche un rechargement à chaud et reprend. Cela réduit les cycles de développement de 15–20 minutes à quelques itérations, diminuant drastiquement les coûts en tokens et l'usage de la fenêtre de contexte. Le support du rechargement à chaud nécessite des tests basés sur des classes (pas des fonctions) pour maintenir l'état entre les rechargements.

Intégration dans les workflows de développement et CI/CD

Testwire propose deux modes : mode agent pour le développement et mode standard pour CI/CD. En développement, lancez les tests avec flutter run --dart-define=AGENT_MODE=true pour activer MCP et le rechargement à chaud. En CI, utilisez flutter test comme un test d'intégration classique sans options supplémentaires. Cette approche d'un seul fichier de test garantit la cohérence et simplifie la maintenance. L'intégration de Testwire peut nécessiter des ajustements des compétences de l'agent et de la documentation, mais elle fait des tests d'intégration une tâche centrale, et non un complément.

Points clés

• Testwire résout les principaux problèmes des agents IA en écriture de tests : coûts élevés en tokens, compilations lentes, absence de retour visuel.
• Il utilise MCP pour se connecter au service VM, offrant aux agents un contrôle étape par étape des tests.
• Le rechargement à chaud permet des corrections sans recompilation, accélérant les cycles de développement.
• Les tests sont basés sur des classes pour le rechargement à chaud et la compatibilité double mode CI/CD.
• Une configuration est nécessaire, mais elle intègre les tests dans chaque workflow de développement.

— Editorial Team