QA Automation : Comment valider les emails d'inscription avec Playwright et l'API JunkMail

C'est le cauchemar classique du QA Engineer ou du développeur Fullstack : tester le flux d'inscription (Sign Up Flow).

Le scénario est simple sur le papier :

L'utilisateur remplit le formulaire.
Il reçoit un email avec un lien magique.
Il clique sur le lien.
Son compte est activé.

Avec des outils modernes comme Playwright ou Cypress, les étapes 1 et 4 sont triviales. Mais les étapes 2 et 3 sont souvent un trou noir. Comment vérifier qu'un email a vraiment été envoyé ? Comment récupérer le lien de validation à l'intérieur pour cliquer dessus programmatiquement ?

Souvent, les équipes de dev utilisent des hacks :

Se connecter à une vraie boîte Gmail via IMAP (lent, instable, Google bloque souvent la connexion).
Mocker l'envoi d'email (rapide, mais ne teste pas la délivrabilité réelle ni le template HTML).
Utiliser Mailhog/Mailcatcher en local (bien, mais ne fonctionne pas en Staging/Prod).

La solution robuste ? Utiliser une API d'email jetable et programmable comme JunkMail.

L'Architecture du Test

Voici ce que nous allons construire :

Playwright génère une adresse email unique via l'API JunkMail.
Playwright remplit le formulaire d'inscription de votre app avec cet email.
Playwright interroge l'API JunkMail (Polling) jusqu'à réception du message.
Playwright extrait l'URL de validation (Regex) du corps du message.
Playwright navigue vers cette URL et vérifie le succès.

Prérequis

Node.js installé.
Un projet Playwright (npm init playwright@latest).
Une clé API JunkMail (disponible dans votre dashboard Business).

Le Code

Voici un exemple complet en TypeScript.

1. Le Client API JunkMail

D'abord, créons un petit helper pour interagir avec JunkMail.

// utils/junkmail.ts
import { request } from '@playwright/test';

const JUNKMAIL_API_URL = 'https://junkmail.site/api/v1';
const API_KEY = process.env.JUNKMAIL_API_KEY;

export async function createTempEmail() {
  const context = await request.newContext();
  const response = await context.post(`${JUNKMAIL_API_URL}/emails`, {
    headers: { 'Authorization': `Bearer ${API_KEY}` }
  });
  return await response.json(); // Retourne { id: "...", address: "xyz@junkmail.site" }
}

export async function waitForEmail(addressId: string, timeout = 30000) {
  const context = await request.newContext();
  const startTime = Date.now();

  while (Date.now() - startTime < timeout) {
    const response = await context.get(`${JUNKMAIL_API_URL}/emails/${addressId}/messages`, {
      headers: { 'Authorization': `Bearer ${API_KEY}` }
    });
    const messages = await response.json();
    
    if (messages.length > 0) {
      return messages[0]; // On retourne le premier message reçu
    }
    
    // Attendre 1s avant de réessayer
    await new Promise(r => setTimeout(r, 1000));
  }
  throw new Error('Email non reçu dans les temps');
}

2. Le Test E2E

Maintenant, utilisons ce helper dans notre spec Playwright.

// tests/signup.spec.ts
import { test, expect } from '@playwright/test';
import { createTempEmail, waitForEmail } from '../utils/junkmail';

test('Un nouvel utilisateur peut s\'inscrire et valider son email', async ({ page }) => {
  // 1. Créer une adresse email unique pour ce test
  const tempEmail = await createTempEmail();
  console.log(`Email de test généré : ${tempEmail.address}`);

  // 2. Remplir le formulaire d'inscription
  await page.goto('https://mon-app.com/register');
  await page.fill('input[name="email"]', tempEmail.address);
  await page.fill('input[name="password"]', 'Password123!');
  await page.click('button[type="submit"]');

  await expect(page.locator('text=Vérifiez vos emails')).toBeVisible();

  // 3. Attendre la réception de l'email (Côté JunkMail)
  const message = await waitForEmail(tempEmail.id);
  console.log(`Email reçu : ${message.subject}`);

  // 4. Extraire le lien de validation
  // On cherche une URL qui ressemble à https://mon-app.com/verify?token=...
  const linkRegex = /https:\/\/mon-app\.com\/verify\?token=[a-zA-Z0-9-]+/;
  const match = message.body.text.match(linkRegex);
  
  if (!match) throw new Error('Lien de validation non trouvé dans l\'email');
  const verificationUrl = match[0];

  // 5. Visiter le lien de validation
  await page.goto(verificationUrl);

  // 6. Vérifier que le compte est activé
  await expect(page.locator('text=Compte activé avec succès')).toBeVisible();
});

Pourquoi c'est mieux que les autres méthodes ?

Isolation des données

Chaque test utilise une adresse email neuve (test-123@junkmail.site, test-456@junkmail.site). Vous ne risquez pas de conflit de données (ex: "Cet email existe déjà") si vous lancez vos tests en parallèle.

Test de la chaîne complète (End-to-End)

Contrairement aux mocks, vous testez :

Que votre service d'envoi (SendGrid, AWS SES...) fonctionne.
Que votre template HTML ne casse pas le lien.
Que le lien de validation fonctionne réellement sur le navigateur.

Stabilité et Rapidité

L'API JunkMail est conçue pour les développeurs. Elle est rapide, RESTful, et ne nécessite pas de configuration IMAP complexe ou de contournement de 2FA comme avec Gmail.

Le moment philo : QA vs Réalité

Un test qui ne reproduit pas la réalité n'est pas un test, c'est une espérance. Vos utilisateurs ne "mockent" pas leurs emails. Ils attendent vraiment de les recevoir. Si votre système d'envoi d'email tombe en panne (quota dépassé, blacklist IP), vos tests mockés seront toujours verts, mais votre business sera à l'arrêt.

Tester avec une vraie infrastructure de réception d'email est la seule façon d'avoir une confiance absolue dans votre "Happy Path" d'inscription.

Conclusion

L'automatisation des tests d'emails ne devrait pas être une douleur. Avec les bons outils, c'est aussi simple qu'un appel API. Intégrez JunkMail dans votre pipeline CI/CD et arrêtez de croiser les doigts à chaque déploiement.

Prêt à coder ? Récupérez votre clé API sur JunkMail Developer.