Chapitre 10

Tests et qualité

Apprenez à utiliser l’IA pour améliorer l’efficacité et la qualité des tests, et découvrez les meilleures pratiques pour la génération de cas de test assistée par l’IA, la rédaction de code de test, l’optimisation des tests, et plus encore.

Apprendre les tests pilotés par l’IA avec Sequential Thinking

L’application de l’IA aux tests implique plusieurs aspects, en utilisantMéthodes de pensée structuréePeut vous aider à maîtriser systématiquement :

1
Aperçu des types de tests
Comprendre rapidement les tests unitaires, d’intégration et E2E
2
Génération de cas de test assistée par IA
Génération de cas de test unitaires, d’intégration et E2E
3
Rédaction de code de test assistée par l’IA
Utilisation de frameworks de test, génération de données fictives, préparation des données de test
4
Optimisation des tests assistée par l’IA
Optimisation des performances, analyse de la couverture, refactorisation des tests
5
Automatisation des tests pilotée par l’IA
Intégration CI/CD, génération de rapports de test, prédiction des défauts

Aperçu des types de tests

Comprenez rapidement les types de tests et fournissez des connaissances de base pour la pratique de l’IA.

Test unitaire

Tester une seule fonction ou un seul composant, avec un retour rapide et une couverture élevée.

Tests d’intégration

Tester la collaboration de plusieurs modules et vérifier les interfaces et les flux de données.

Tests E2E

Tests de bout en bout, en simulant de véritables actions d’utilisateur.

Test de performance

Tester les performances et la capacité de charge du système.

Bonnes pratiques de l’IA dans les tests

Utiliser l’IA pour améliorer l’efficacité et la qualité des tests, avec des pratiques assistées par IA sur l’ensemble du processus, de la génération des cas de test à l’automatisation des tests.

Génération de cas de test assistée par IA

Utiliser l’IA pour générer des cas de test unitaires

Décrivez à l’IA la fonction et laissez-la générer des cas de test complets :

Modèle de prompt :

Je dois générer des cas de tests unitaires pour la fonction suivante :

// utils/calculateTotal.ts
export function calculateTotal(items: Item[]): number {
  if (!items || items.length === 0) return 0
  return items.reduce((sum, item) => {
    if (item.price && item.quantity) {
      return sum + item.price * item.quantity
    }
    return sum
  }, 0)
}

interface Item {
  price?: number
  quantity?: number
}

Veuillez utiliser Jest/Vitest pour générer des cas de test, notamment :
- Tests de cas normaux
- Tests de cas limites (tableau vide, null, undefined)
- Tests de cas exceptionnels (absence de price ou quantity)
- Organiser les tests avec describe et it
- Utiliser des descriptions de test claires

Exemples de cas de test générés par l’IA

// utils/calculateTotal.test.ts
import { describe, it, expect } from 'vitest'
import { calculateTotal } from './calculateTotal'

describe('calculateTotal', () => {
  it('should return 0 for empty array', () => {
    expect(calculateTotal([])).toBe(0)
  })

  it('should return 0 for null or undefined', () => {
    expect(calculateTotal(null as any)).toBe(0)
    expect(calculateTotal(undefined as any)).toBe(0)
  })

  it('should calculate total for valid items', () => {
    const items = [
      { price: 10, quantity: 2 },
      { price: 5, quantity: 3 }
    ]
    expect(calculateTotal(items)).toBe(35) // 10*2 + 5*3 = 35
  })

  it('should ignore items without price', () => {
    const items = [
      { price: 10, quantity: 2 },
      { quantity: 3 }
    ]
    expect(calculateTotal(items)).toBe(20)
  })

  it('should ignore items without quantity', () => {
    const items = [
      { price: 10, quantity: 2 },
      { price: 5 }
    ]
    expect(calculateTotal(items)).toBe(20)
  })

  it('should handle zero price or quantity', () => {
    const items = [
      { price: 0, quantity: 2 },
      { price: 10, quantity: 0 }
    ]
    expect(calculateTotal(items)).toBe(0)
  })
})

Scénarios de tests d’intégration générés par l’IA

Prompt :

J’ai besoin de générer des scénarios de tests d’intégration pour l’API d’inscription des utilisateurs :

API : POST /api/users/register
Corps de la requête : { email, password, name }
Réponse : { id, email, name, createdAt }

Veuillez générer des cas de test incluant :
- Scénario d’inscription réussie
- Scénario où l’adresse e-mail existe déjà
- Scénario de mot de passe trop faible
- Scénario de champ obligatoire manquant
- Utilisation de la base de données de test
- Nettoyage des données de test

L’IA génère le flux de tests E2E

Prompt :

J’ai besoin de générer des tests E2E pour le parcours du panier d’achat :

Parcours utilisateur :
1. Visiter la page d’accueil
2. Rechercher des produits
3. Ajouter un produit au panier
4. Consulter le panier
5. Passer à la caisse
6. Renseigner les informations de commande
7. Soumettre la commande

Veuillez utiliser Playwright pour générer un code de test E2E complet, comprenant :
- Navigation entre les pages
- Localisation des éléments
- Interactions utilisateur
- Vérifications par assertions
- Gestion des erreurs

Bases de la pratique du TDD

Conservez les concepts essentiels et mettez l’accent sur la manière dont l’IA aide le TDD. L’utilisation de l’IA permet de générer rapidement des cas de test, du code d’implémentation et des suggestions de refactorisation.

Rouge

Écrire des tests qui échouent et définir le comportement attendu

Vert (Green)

Écrire l’implémentation minimale pour faire passer les tests

Refactorisation (Refactor)

Optimisez le code et gardez les tests au vert

TDD assisté par l’IA

L'IA peut aider à chaque étape du TDD : génération de cas de test, implémentation rapide et suggestions de refactorisation. Consultez la section « Pratique du TDD assistée par l'IA » ci-dessus pour des exemples détaillés et des modèles de Prompt.

Bases des outils de test

Conserver la présentation des outils principaux et mettre l’accent sur la manière dont l’IA aide à choisir les outils.

Jest

Framework de test JavaScript avec assertions et mocks intégrés

Vitest

Framework de test rapide, prise en charge native de Vite, compatible TypeScript

Playwright

Framework de tests E2E, prise en charge de plusieurs navigateurs

Sélection d’outils assistés par IA

Utilisez l’IA pour choisir les bons outils de test en fonction des besoins du projet. Décrivez à l’IA les caractéristiques du projet (Next.js, TypeScript, besoin de tests E2E, etc.), et elle recommandera la bonne combinaison d’outils et un plan de configuration.

Bases de l’assurance qualité

Conservez les concepts clés et montrez surtout comment l’IA aide l’assurance qualité.

Stratégie de test

  • Pyramide de test : un grand nombre de tests unitaires + un nombre modéré de tests d’intégration + un petit nombre de tests E2E
  • Prioriser les chemins critiques: privilégier les tests de la logique métier principale
  • Test aux limites: Tester les conditions limites et les cas exceptionnels

Couverture du code

  • Couverture des lignes : proportion de lignes de code exécutées
  • Couverture des branches : Proportion des branches de code exécutées
  • Objectif:Code clé 80 %+, global 60 %+

Assurance qualité assistée par IA

L’IA peut analyser les stratégies de test, générer des rapports de qualité et identifier les chemins de code non couverts. Reportez-vous aux sections ci-dessus « Analyse de couverture assistée par IA » et « Automatisation des tests pilotée par IA » pour des exemples détaillés et des modèles de prompt.

Exemples pratiques

À travers des exemples de code réels, apprenez à utiliser l’IA pour améliorer l’efficacité et la qualité des tests.

Cas de test générés par l’IA

Exemple complet de génération de cas de test (Prompt + résultat) :

// 1. Fournir les exigences à l’IA
Prompt: "Générez des tests unitaires pour la fonction calculateTotal, en incluant les cas normaux, les cas limites et les cas d’exception..."

// 2. Cas de test générés par l’IA
describe('calculateTotal', () => {
  it('should return 0 for empty array', () => {
    expect(calculateTotal([])).toBe(0)
  })
  
  it('should calculate total for valid items', () => {
    const items = [
      { price: 10, quantity: 2 },
      { price: 5, quantity: 3 }
    ]
    expect(calculateTotal(items)).toBe(35)
  })
  
  // ... plus de cas de test
})

Code de test optimisé par l’IA

Exemple d'optimisation de code de test (comparaison avant/après optimisation) :

Avant l’optimisation (45 secondes)
// Chaque test appelle la véritable API
describe('UserService', () => {
  it('should fetch user', async () => {
    const user = await fetchUser('1') // appel API réel
    expect(user.id).toBe('1')
  })
  
  it('should update user', async () => {
    const user = await fetchUser('1') // appel répété
    await updateUser('1', { name: 'New' })
    expect(user.name).toBe('New')
  })
})
Après optimisation par l'IA (5 secondes)
// Suggestion de l’IA : utiliser un Mock au lieu de l’API réelle
vi.mock('./api', () => ({
  fetchUser: vi.fn().mockResolvedValue({ id: '1', name: 'Test' }),
  updateUser: vi.fn().mockResolvedValue({ id: '1', name: 'New' })
}))

describe('UserService', () => {
  it('should fetch user', async () => {
    const user = await fetchUser('1')
    expect(user.id).toBe('1')
  })
  
  it('should update user', async () => {
    await updateUser('1', { name: 'New' })
    expect(updateUser).toHaveBeenCalledWith('1', { name: 'New' })
  })
})

Couverture de l’analyse IA

Exemples d'analyse de couverture et de recommandations complémentaires :

// Rapport de couverture IA
Couverture : 65 %

Code non couvert :
- utils/validation.ts: 45 %
  - La branche de gestion des erreurs de validateEmail n’est pas testée
  - Les cas limites de validatePassword ne sont pas testés

Cas de test supplémentaires suggérés par l’IA :
it('should return false for invalid email', () => {
  expect(validateEmail('invalid')).toBe(false)
  expect(validateEmail('invalid@')).toBe(false)
  expect(validateEmail('@domain.com')).toBe(false)
})

Résultats d’apprentissage

À la fin de ce chapitre, vous pourrez :

  • 1Comprendre l’aperçu des types de tests (tests unitaires, tests d’intégration, tests E2E, tests de performance) et leurs cas d’usage
  • 2Maîtrisez l’utilisation de l’IA pour générer des cas de test (tests unitaires, tests d’intégration, génération de cas de test E2E)
  • 3Être capable d’utiliser l’IA pour aider à écrire du code de test (syntaxe des frameworks de test, génération de données Mock, préparation des données de test)
  • 4Capable d’utiliser l’IA pour analyser et optimiser les performances des tests (analyse des goulots d’étranglement des performances, optimisation de la vitesse d’exécution des tests, refactorisation des tests)
  • 5Maîtriser les méthodes d’analyse de couverture assistée par l’IA (analyse des rapports de couverture, identification des chemins de code non couverts, suggestions de cas de test supplémentaires)
  • 6Peut utiliser l’automatisation des tests pilotée par l’IA (génération de configurations CI/CD, analyse des rapports de test, prédiction des causes d’échec des tests)
  • 7Maîtriser les pratiques TDD assistées par l’IA (génération de cas de test, génération du code d’implémentation minimal, suggestions de refactorisation)