QA Engineer : tests, qualité et automatisation

QA Engineer, Testeur et SDET : les rôles

Le secteur du test logiciel utilise plusieurs titres qui recouvrent des réalités différentes. Avant de choisir une voie ou de rédiger une offre d'emploi, il est indispensable de comprendre les distinctions.

Testeur manuel (QA Tester) — Il explore l'application, suit des plans de test, rédige des rapports de bugs et valide les corrections. Son outil principal reste le navigateur et sa capacité d'observation. Ce profil est souvent le point d'entrée dans la qualité logicielle.

QA Engineer — Profil plus complet, il maîtrise à la fois les tests manuels et l'automatisation. Il conçoit la stratégie de test, rédige des cas de test, maintient les suites automatisées et participe aux cérémonies Agile. C'est aujourd'hui le profil le plus demandé.

SDET (Software Development Engineer in Test) — Profil hybride dev/QA. Il code des frameworks de test complets, contribue à la base de code principale et pilote l'outillage de qualité à l'échelle de l'organisation. C'est l'évolution naturelle du QA Engineer après plusieurs années d'expérience.

Types de tests logiciels

Un QA Engineer compétent maîtrise l'ensemble des niveaux de la pyramide de tests. Chaque niveau a un objectif précis et un coût de maintenance différent.

La pyramide de tests

• Tests unitaires — Vérifient une fonction ou une classe isolée. Rapides, nombreux, peu coûteux à maintenir. Exemple : Jest, Vitest, JUnit.
• Tests d'intégration — Vérifient la communication entre plusieurs composants (service + base de données, API + front). Exemple : Supertest, Spring Boot Test.
• Tests End-to-End (E2E) — Simulent un vrai utilisateur dans un vrai navigateur. Coûteux mais indispensables pour valider les parcours critiques. Exemple : Cypress, Playwright.
• Tests de régression — Garantissent qu'une nouvelle livraison ne casse pas l'existant. Souvent automatisés et déclenchés en CI.
• Tests de performance — Mesurent la tenue en charge, les temps de réponse et les points de rupture. Exemple : JMeter, k6, Gatling.
• Tests de sécurité — Détectent les vulnérabilités (injections SQL, XSS, CSRF). Exemple : OWASP ZAP, Burp Suite.

// Exemple de test unitaire avec Jest (TypeScript)
// Fichier : src/utils/price.utils.spec.ts

import { calculateDiscount } from './price.utils';

describe('calculateDiscount', () => {
    // Vérifie le comportement nominal : 10% sur 100€ = 90€
    it('applique une remise en pourcentage correctement', () => {
        expect(calculateDiscount(100, 10)).toBe(90);
    });

    // Vérifie le cas limite : remise à 0% ne change pas le prix
    it('retourne le prix original si remise nulle', () => {
        expect(calculateDiscount(200, 0)).toBe(200);
    });

    // Vérifie la protection contre les valeurs négatives
    it('lève une erreur si le pourcentage est négatif', () => {
        expect(() => calculateDiscount(100, -5)).toThrow('Discount cannot be negative');
    });
});

Tests manuels vs automatisés

L'automatisation n'a pas vocation à remplacer les tests manuels mais à les compléter. Choisir le bon outil pour le bon usage est une compétence clé du QA Engineer.

Quand privilégier les tests manuels

• Tests exploratoires sur une nouvelle fonctionnalité
• Validation d'expérience utilisateur et d'ergonomie
• Tests sur des interfaces très instables ou en cours de design
• Tests d'accessibilité nécessitant un jugement humain
• Scénarios complexes et non répétitifs

Quand automatiser

• Tests de régression exécutés à chaque livraison
• Parcours critiques répétés de nombreuses fois (login, checkout, formulaires)
• Tests de performance et de charge
• Vérifications de données dans les APIs (smoke tests)
• Tout ce qui serait fastidieux ou sujet à erreur humaine

// Exemple de test E2E avec Cypress
// Fichier : cypress/e2e/login.cy.ts

describe('Parcours de connexion', () => {
    beforeEach(() => {
        // Réinitialise l'état avant chaque test
        cy.visit('/login');
    });

    it('connecte un utilisateur avec des identifiants valides', () => {
        // Saisit le nom d'utilisateur dans le champ email
        cy.get('[data-testid="email-input"]').type('user@example.com');

        // Saisit le mot de passe
        cy.get('[data-testid="password-input"]').type('SecurePass123');

        // Soumet le formulaire
        cy.get('[data-testid="login-btn"]').click();

        // Vérifie la redirection vers le tableau de bord
        cy.url().should('include', '/dashboard');

        // Vérifie que le prénom est affiché dans le header
        cy.get('[data-testid="user-greeting"]').should('contain', 'Bonjour');
    });

    it('affiche un message d erreur si le mot de passe est incorrect', () => {
        cy.get('[data-testid="email-input"]').type('user@example.com');
        cy.get('[data-testid="password-input"]').type('WrongPassword');
        cy.get('[data-testid="login-btn"]').click();

        // Vérifie la présence du message d'erreur
        cy.get('[data-testid="error-message"]')
            .should('be.visible')
            .and('contain', 'Identifiants incorrects');
    });
});

Outils du QA Engineer

L'écosystème du test logiciel est riche. Voici les outils incontournables classés par usage, avec les cas d'utilisation concrets pour chacun.

Tests E2E et navigation

• Cypress — Framework JavaScript moderne, idéal pour les applications web. Rechargement en temps réel, debugging visuel, snapshots automatiques. Parfait pour les apps React, Angular, Vue.
• Playwright — Développé par Microsoft. Supporte Chromium, Firefox et WebKit. Excellent pour le multi-navigateur et le mobile. API très complète.
• Selenium — Vétéran du secteur, supporte tous les langages (Java, Python, C#, JS). Incontournable dans les entreprises Java. Plus verbeux que Cypress ou Playwright.

Tests unitaires et d'intégration

• Jest — Standard de facto pour JavaScript/TypeScript. Intégré dans Angular (via Karma par défaut, mais Jest est préféré), React et Vue.
• Vitest — Alternative ultra-rapide à Jest, pensée pour les projets Vite. Compatibilité API avec Jest.
• JUnit 5 — Référence pour les projets Java Spring Boot.

Tests d'API

• Postman / Newman — Création de collections de tests API, exécution en ligne de commande via Newman pour la CI.
• REST-assured — Librairie Java pour tester les APIs REST de façon fluente.
• Supertest — Tests d'intégration HTTP pour les serveurs Node.js/Express.

Tests de performance

• JMeter — Outil Apache historique pour les tests de charge. Interface graphique, nombreux plugins.
• k6 — Moderne, scriptable en JavaScript, intégrable dans les pipelines CI. Très populaire en contexte DevOps.
• Gatling — Orienté Scala/Kotlin, excellentes performances, rapports HTML détaillés.

Tests multi-navigateurs et cloud

• BrowserStack — Service cloud pour exécuter vos tests sur des centaines de combinaisons navigateur/OS/mobile réels.
• Sauce Labs — Concurrent de BrowserStack, très utilisé en entreprise.
• LambdaTest — Alternative moins coûteuse, intégration CI/CD complète.

// Exemple de test API avec Playwright (TypeScript)
// Fichier : tests/api/users.api.spec.ts

import { test, expect } from '@playwright/test';

test.describe('API Users', () => {
    // Teste la création d'un nouvel utilisateur via POST
    test('crée un utilisateur et retourne un 201', async ({ request }) => {
        const response = await request.post('/api/users', {
            data: {
                name: 'Alice Martin',
                email: 'alice@example.com',
                role: 'editor'
            }
        });

        // Vérifie le code de statut HTTP
        expect(response.status()).toBe(201);

        // Vérifie la structure de la réponse JSON
        const body = await response.json();
        expect(body).toHaveProperty('id');
        expect(body.name).toBe('Alice Martin');
        expect(body.email).toBe('alice@example.com');
    });

    // Teste la récupération d'un utilisateur inexistant
    test('retourne un 404 pour un utilisateur inconnu', async ({ request }) => {
        const response = await request.get('/api/users/99999');
        expect(response.status()).toBe(404);

        const body = await response.json();
        expect(body.message).toContain('not found');
    });
});

Compétences techniques et soft skills

Le QA Engineer moderne est un profil T-shaped : une expertise en qualité logicielle en profondeur, combinée à de larges connaissances en développement, DevOps et UX.

Compétences techniques indispensables

• Langages de programmation — JavaScript/TypeScript en priorité (Cypress, Playwright, Jest). Python pour les projets data ou Django. Java pour les entreprises utilisant Spring Boot et Selenium.
• Conception de cas de test — Partitionnement d'équivalence, valeurs limites, tables de décision, diagrammes d'état.
• Gestion des bugs — Jira, Linear, GitHub Issues. Savoir rédiger un rapport de bug actionnable (étapes de reproduction, comportement attendu vs observé, logs, captures).
• Git et versioning — Branches de test, gestion des fixtures de test, intégration des tests dans les PR.
• SQL et bases de données — Vérifier les états de la base après une opération, préparer des jeux de données de test.
• APIs REST — Comprendre les codes HTTP, headers, authentification JWT, tester avec Postman ou des scripts.

Soft skills clés

• Curiosité et esprit critique — Toujours questionner ce qui pourrait mal tourner, explorer les edge cases que les développeurs n'ont pas anticipés.
• Communication — Rédiger des rapports de bugs clairs, communiquer les risques qualité sans créer de tension avec les développeurs.
• Rigueur et organisation — Maintenir des plans de test à jour, documenter les régressions, suivre les métriques de couverture.
• Empathie utilisateur — Se mettre dans la peau de l'utilisateur final pour identifier les vrais problèmes d'usage.
• Collaboration — Le QA est le pont entre le développement, le product owner et les utilisateurs. Il doit savoir travailler avec tous les profils.

QA dans le pipeline CI/CD

Un pipeline CI/CD bien configuré exécute automatiquement les tests à chaque push ou pull request. Le QA Engineer joue un rôle central dans la conception et la maintenance de ce pipeline.

Architecture d'un pipeline de test typique

• Étape 1 — Lint et analyse statique — ESLint, SonarQube. Rapide, bloque dès qu'une règle est violée.
• Étape 2 — Tests unitaires — Jest/Vitest. Exécution en parallèle, couverture minimale imposée (ex : 80%).
• Étape 3 — Build — Compilation et vérification de l'artefact.
• Étape 4 — Tests d'intégration — Lancement de services annexes (Docker Compose), tests sur une base réelle.
• Étape 5 — Tests E2E — Cypress ou Playwright sur un environnement de staging. Sélectifs et ciblés sur les parcours critiques.
• Étape 6 — Rapport et notification — Publication des résultats (Allure, HTML Reporter), notification Slack en cas d'échec.

# .github/workflows/qa-pipeline.yml
# Pipeline CI avec tests automatisés sur GitHub Actions

name: QA Pipeline

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

jobs:
  unit-tests:
    name: Tests unitaires
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      # Installe Node.js LTS
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'

      # Installe les dépendances
      - name: Install dependencies
        run: npm ci

      # Lance les tests unitaires avec couverture
      - name: Run unit tests
        run: npm run test:ci -- --coverage

      # Publie le rapport de couverture comme artefact
      - name: Upload coverage report
        uses: actions/upload-artifact@v4
        with:
          name: coverage-report
          path: coverage/

  e2e-tests:
    name: Tests E2E Cypress
    runs-on: ubuntu-latest
    needs: unit-tests
    steps:
      - uses: actions/checkout@v4

      # Lance l'application et les tests Cypress en parallèle
      - name: Run Cypress E2E tests
        uses: cypress-io/github-action@v6
        with:
          build: npm run build
          start: npm run start:ci
          wait-on: 'http://localhost:4200'
          wait-on-timeout: 60

      # Conserve les captures d'écran en cas d'échec
      - name: Upload screenshots on failure
        uses: actions/upload-artifact@v4
        if: failure()
        with:
          name: cypress-screenshots
          path: cypress/screenshots/

Salaires et évolution de carrière

Le QA Engineer est un profil en forte demande, notamment à mesure que les équipes adoptent des pratiques DevOps et Agile matures. L'évolution vers le SDET ou le Lead QA ouvre des perspectives salariales comparables aux développeurs seniors.

Évolutions possibles

• SDET — Évolution naturelle pour les QA Engineers qui approfondissent le développement. Participe activement à la base de code et conçoit les outils de test internes.
• Lead QA / QA Manager — Encadre une équipe QA, définit la stratégie qualité globale, interlocuteur des directeurs techniques.
• DevOps Engineer — Transition fréquente grâce à la maîtrise des pipelines CI/CD et de l'automatisation.
• Développeur full-stack — Possible si le QA a suffisamment développé ses compétences de développement logiciel.
• Consultant QA / Freelance — TJM entre 450 et 750 €/jour selon l'expérience et la spécialisation.

Comment devenir QA Engineer

Contrairement à d'autres spécialisations, le QA est accessible depuis des profils variés. Que vous veniez du développement, d'un profil fonctionnel ou que vous débutiez, voici un chemin structuré.

Depuis un profil développeur

La transition est naturelle. Vous maîtrisez déjà le code, il faut maintenant développer la culture qualité :

• Apprendre les techniques de conception de tests (ISTQB Foundation Level)
• Maîtriser un framework E2E : Cypress ou Playwright en priorité
• S'initier aux tests de performance avec k6
• Contribuer à des projets open source avec une suite de tests

Depuis un profil fonctionnel (analyste, PO)

Vous avez déjà la compréhension métier, il faut acquérir les bases techniques :

• Apprendre les bases de JavaScript (structures de données, fonctions, promesses)
• Commencer par Postman pour tester des APIs sans coder
• Évoluer vers Cypress avec des tutoriels progressifs
• Pratiquer sur des projets personnels ou des applications de démonstration

Certifications reconnues

• ISTQB Foundation Level — La certification de base, reconnue internationalement. Indispensable pour les postes en ESN ou grands groupes.
• ISTQB Advanced Level (Test Analyst / Test Manager) — Pour les profils seniors souhaitant accéder à des postes de management.
• Cypress.io Certified Associate — Certification officielle Cypress, valorisée dans les équipes front-end modernes.
• AWS Certified DevOps Engineer — Pertinent pour les QA spécialisés dans l'automatisation cloud et le CI/CD.

// Exemple de test Playwright pour un débutant
// Un premier test simple pour valider la page d'accueil

import { test, expect } from '@playwright/test';

test('la page d accueil se charge correctement', async ({ page }) => {
    // Navigue vers la page d'accueil
    await page.goto('https://example.com');

    // Vérifie que le titre de la page est correct
    await expect(page).toHaveTitle(/Example Domain/);

    // Vérifie qu'un lien "More information" est visible
    const link = page.getByRole('link', { name: 'More information' });
    await expect(link).toBeVisible();

    // Vérifie que le heading principal est présent
    const heading = page.getByRole('heading', { level: 1 });
    await expect(heading).toHaveText('Example Domain');
});

Conclusion

Le QA Engineer est devenu un acteur incontournable des équipes produit modernes. Loin de se limiter à "trouver des bugs", ce profil conçoit des stratégies de test complètes, automatise les vérifications critiques et garantit la fiabilité des livraisons dans un contexte de déploiement continu.

L'évolution vers le SDET ou le Lead QA offre des perspectives salariales attractives et une position centrale dans les organisations tech. Que vous soyez développeur cherchant à vous spécialiser ou débutant attiré par la qualité logicielle, la combinaison de la certification ISTQB, d'une maîtrise de Cypress ou Playwright et d'une intégration CI/CD avec GitHub Actions constitue un socle solide pour débuter ou progresser dans ce métier.