Tests unitaires Dart

Les tests unitaires sont un moyen fondamental de garantir la qualité du code.

Il vérifie si le comportement de chaque plus petite unité fonctionnelle (généralement une fonction ou une méthode) correspond aux attentes.

Ce chapitre présente l'utilisation du package test de Dart, l'écriture de cas de test avec test(), les assertions avec expect() et le regroupement des tests avec group().


Installation et configuration du package test

Dart fournit officiellement le paquet test pour écrire et exécuter des tests.

Tout d'abord, ajoutez la dépendance dans pubspec.yaml :

# 文件路径:pubspec.yaml
dev_dependencies:
  test: ^1.24.0

Ensuite, exécutez la commande suivante pour installer :

$ dart pub get

Les fichiers de test sont généralement placés dans le répertoire test/ du projet, avec des noms de fichiers se terminant par _test.dart.

Une structure de projet typique :

my_project/
├── lib/
│   └── calculator.dart       # 被测试的代码
├── test/
│   └── calculator_test.dart  # 测试文件
└── pubspec.yaml

Écriture de cas de test avec test()

La fonction test() est l'unité de base pour écrire des cas de test.

Elle prend deux paramètres : une description du test (chaîne) et un corps de fonction de test.

Exemple

Le code à tester (lib/calculator.dart) :

// Chemin du fichier : lib/calculator.dart
class Calculator {
  int add(int a, int b) => a + b;
  int subtract(int a, int b) => a - b;
  int multiply(int a, int b) => a * b;

  double divide(int a, int b) {
    if (b == 0) {
      throw ArgumentError(Le diviseur ne peut pas être 0);
    }
    return a / b;
  }

  bool isEven(int n) => n % 2 == 0;

  List<int> filterPositive(List<int> numbers) {
    return numbers.where((n) => n > 0).toList();
  }
}

Exemple

Fichier de test (test/calculator_test.dart) :

// Chemin du fichier : test/calculator_test.dart
import 'package:test/test.dart';
import 'package:my_project/calculator.dart';

void main() {
  // Créer une instance de Calculator pour les tests
  var calculator = Calculator();

  // fonction test() : le premier paramètre est la description du test, le second est la fonction de test
  test('add() additionne deux nombres positifs', () {
    var result = calculator.add(3, 5);
    // assertion expect() : vérifie si le résultat réel est égal à la valeur attendue
    expect(result, equals(8));
  });

  test('add() ajoute des nombres négatifs', () {
    expect(calculator.add(-3, 5), equals(2));
    expect(calculator.add(-3, -5), equals(-8));
  });

  test('subtract() opération de soustraction', () {
    expect(calculator.subtract(10, 3), equals(7));
  });

  test('multiply() opération de multiplication', () {
    expect(calculator.multiply(4, 5), equals(20));
    // Multiplier par zéro
    expect(calculator.multiply(100, 0), equals(0));
  });

  test(divide() division normale, () {
    expect(calculator.divide(10, 2), equals(5.0));
    expect(calculator.divide(7, 2), equals(3.5));
  });

  test(isEven() vérification de nombre pair, () {
    expect(calculator.isEven(4), isTrue);
    expect(calculator.isEven(5), isFalse);
  });
}

Exécuter les tests :

$ dart test
00:00 +6: All tests passed!

Assertions expect

expect() est la fonction la plus essentielle des tests ; elle vérifie si une valeur réelle satisfait une condition.

Syntaxe de base : expect(actual, matcher).

Matchers courants

MatcherObjectifExemple
equals(expected)Vérifier que les valeurs sont égalesexpect(result, equals(42))
isTrue / isFalseVérifier les valeurs booléennesexpect(flag, isTrue)
isNull / isNotNullVérifier nullexpect(value, isNull)
contains(value)Contient un élément (liste) ou une sous-chaîne (chaîne).expect(list, contains('a'))
isA()Vérifier les typesexpect(obj, isA())
throws()Vérifier qu'une exception est levéeexpect(() => f(), throwsException)
isNotEmptynon nulexpect(list, isNotEmpty)
hasLength(n)Vérifier la longueurexpect(list, hasLength(3))
greaterThan(n)supérieur àexpect(score, greaterThan(60))
closeTo(value, delta)Nombres à virgule flottante approximativement égauxexpect(3.14, closeTo(3.1, 0.1))

Exemple

Applications pratiques de divers Matchers :

import 'package:test/test.dart';

void main() {
  test(EXEMPLE Divers exemples d'assertions, () {
    // Égalité de base
    expect(2 + 2, equals(4));

    // Valeurs booléennes
    expect('hello'.contains('h'), isTrue);
    expect(''.isEmpty, isTrue);

    // Vérification de null
    String? name;
    expect(name, isNull);
    name = 'EXAMPLE';
    expect(name, isNotNull);

    // Vérification de type
    expect('EXAMPLE', isA<String>());
    expect(42, isA<int>());

    // Liste/chaîne contient
    expect([1, 2, 3], contains(2));
    expect('Hello, EXAMPLE!', contains('EXAMPLE'));

    // Longueur
    expect([1, 2, 3], hasLength(3));
    expect('Dart', hasLength(4));

    // Comparaison numérique
    expect(100, greaterThan(50));
    expect(30, lessThan(60));
    expect(75, greaterThanOrEqualTo(60));

    // Comparaison de nombres à virgule flottante (éviter les problèmes de précision)
    expect(0.1 + 0.2, closeTo(0.3, 0.001));

    // La collection n'est pas vide
    expect([1, 2], isNotEmpty);

    // Égalité de listes
    expect([1, 2, 3], equals([1, 2, 3]));

    // La Map contient une clé
    var user = {'name': 'example', 'age': 10};
    expect(user, containsPair('name', 'example'));
    expect(user.keys, contains('age'));
  });
}
00:00 +1: All tests passed!

Test des exceptions

Exemple

import 'package:test/test.dart';

int divide(int a, int b) {
  if (b == 0) throw ArgumentError(Le diviseur ne peut pas être 0);
  return a ~/ b;
}

void main() {
  test(divide() devrait lever une exception lors d'une division par zéro, () {
    // Vérifier qu'une exception est levée
    expect(() => divide(10, 0), throwsException);

    // Vérifier qu'un type spécifique d'exception est levé
    expect(() => divide(10, 0), throwsArgumentError);

    // Vérifier le message de l'exception
    expect(
      () => divide(10, 0),
      throwsA(predicate((e) =>
          e is ArgumentError &&
          e.message.contains(divisor))),
    );
  });

  test(divide() ne lève pas d'exception dans les cas normaux, () {
    expect(() => divide(10, 2), returnsNormally);
    expect(divide(10, 2), equals(5));
  });
}
00:00 +2: All tests passed!

Lorsque vous testez des exceptions, vous devez envelopper le code susceptible de lever une exception dans une fonction anonyme (() => code), plutôt que de l'appeler directement. Si vous écrivez expect(divide(10, 0), throwsException) directement, divide lèvera immédiatement une exception, et expect n'aura jamais la chance de s'exécuter.


Regrouper les tests avec group()

group() est utilisé pour organiser les cas de test associés, ce qui rend la structure de test plus claire.

Exemple

import 'package:test/test.dart';

// Fonction à tester
class StringUtils {
  static String capitalize(String s) {
    if (s.isEmpty) return s;
    return s[0].toUpperCase() + s.substring(1);
  }

  static String reverse(String s) {
    return s.split('').reversed.join('');
  }

  static bool isPalindrome(String s) {
    var clean = s.toLowerCase().replaceAll(' ', '');
    return clean == reverse(clean);
  }

  static int countWords(String s) {
    if (s.trim().isEmpty) return 0;
    return s.trim().split(RegExp(r'\s+')).length;
  }
}

void main() {
  // group() organisation des tests imbriqués
  group('StringUtils', () {
    // Sous-groupe
    group('capitalize()', () {
      test(Met en majuscule la première lettre d’un mot normal, () {
        expect(StringUtils.capitalize('hello'), equals('Hello'));
      });

      test(Un mot déjà capitalisé reste inchangé, () {
        expect(StringUtils.capitalize('Hello'), equals('Hello'));
      });

      test(Une chaîne vide renvoie une chaîne vide, () {
        expect(StringUtils.capitalize(''), equals(''));
      });

      test(Caractère unique, () {
        expect(StringUtils.capitalize('a'), equals('A'));
      });
    });

    group('reverse()', () {
      test(Inverse une chaîne normale, () {
        expect(StringUtils.reverse('EXAMPLE'), equals('BOONUR'));
      });

      test(Inverser une chaîne palindrome la laisse inchangée, () {
        expect(StringUtils.reverse('aba'), equals('aba'));
      });

      test(Chaîne vide, () {
        expect(StringUtils.reverse(''), equals(''));
      });
    });

    group('isPalindrome()', () {
      test(Chaîne palindrome renvoie vrai, () {
        expect(StringUtils.isPalindrome('racecar'), isTrue);
        expect(StringUtils.isPalindrome('A man a plan a canal Panama'), isTrue);
      });

      test(Une chaîne non palindrome renvoie false, () {
        expect(StringUtils.isPalindrome('hello'), isFalse);
      });

      test(Une chaîne vide est considérée comme un palindrome, () {
        expect(StringUtils.isPalindrome(''), isTrue);
      });
    });

    group('countWords()', () {
      test(Phrase normale, () {
        expect(StringUtils.countWords('Hello World Dart'), equals(3));
      });

      test(Espaces supplémentaires, () {
        expect(StringUtils.countWords(' Hello World '), equals(2));
      });

      test(Chaîne vide, () {
        expect(StringUtils.countWords(''), equals(0));
        expect(StringUtils.countWords('   '), equals(0));
      });
    });
  });
}
00:00 +12: All tests passed!

group() peut être imbriqué pour créer une structure de test hiérarchique.

Cela rend les rapports de test plus faciles à lire et aide aussi à localiser rapidement les tests en échec.

Une bonne stratégie de regroupement consiste à organiser par "module/classe/méthode testé". Ainsi, lorsqu'un test échoue, vous savez immédiatement quelle fonctionnalité pose problème.

setUp et tearDown

setUp s'exécute avant chaque test, tearDown s'exécute après chaque test.

Ils sont utilisés pour préparer l'environnement de test et nettoyer les ressources.

Exemple

import 'package:test/test.dart';

// Simuler une classe qui a besoin d'initialisation et de nettoyage
class Database {
  bool isConnected = false;

  void connect() {
    isConnected⟧true = true;
    print(Database connected);
  }

  void disconnect() {
    isConnected = false;
    print(Base de données déconnectée);
  }

  String query(String sql) {
    if (!isConnected) throw Exception(Base de données non connectée);
    return Résultat de la requête : $sql;
  }
}

void main() {
  group(Test de base de données, () {
    late Database db;  // initialisation paresseuse tardive

    // Exécuter avant chaque test
    setUp(() {
      db = Database();
      db.connect();
      print([setUp] Préparer l'environnement de test);
    });

    // Exécuter après chaque test
    tearDown(() {
      db.disconnect();
      print([tearDown] Nettoyer l'environnement de test);
    });

    test(query() requête normale, () {
      var result = db.query('SELECT * FROM users');
      expect(result, contains('EXAMPLE') ? result.contains('users') : result.contains('users'));
      // Simplifier les assertions
      expect(result, isNotEmpty);
    });

    test(query() peut exécuter plusieurs requêtes après la connexion, () {
      var r1 = db.query('SELECT 1');
      var r2 = db.query('SELECT 2');
      expect(r1, isNotEmpty);
      expect(r2, isNotEmpty);
    });

    test(La requête lève une exception lorsqu'elle n'est pas connectée, () {
      db.disconnect();  // Déconnexion manuelle
      expect(() => db.query('SELECT 1'), throwsException);
    });
  });
}
  数据库已连接
  [setUp] 准备测试环境
  数据库已断开
  [tearDown] 清理测试环境
  数据库已连接
  [setUp] 准备测试环境
  数据库已断开
  [tearDown] 清理测试环境
  数据库已连接
  [setUp] 准备测试环境
  数据库已断开
  [tearDown] 清理测试环境
00:00 +3: All tests passed!

Notez l'ordre d'exécution de setUp et tearDown dans la sortie — ils s'exécutent une fois avant et après chaque test.

setUp et tearDown garantissent que chaque test démarre dans un état propre et n'est pas affecté par les autres tests. C'est une garantie clé de l'indépendance des tests.


Test asynchrone

Le package de test Dart prend nativement en charge les tests asynchrones.

Une fonction de test peut retourner un Future, et le framework attendra automatiquement que le Future se termine.

Exemple

import 'package:test/test.dart';

// Fonction asynchrone : simuler une requête réseau
Future<String> fetchUserData(int userId) async {
  await Future.delayed(Duration(milliseconds: 100));

  if (userId <= 0) {
    throw Exception(Identifiant utilisateur invalide);
  }

  return Données de l'utilisateur $userId;
}

Future<List<int>> fetchNumbers() async {
  await Future.delayed(Duration(milliseconds: 50));
  return [1, 2, 3, 4, 5];
}

void main() {
  group(Test asynchrone, () {
    test(fetchUserData() récupère les données normalement, () async {
      var data = await fetchUserData(1);
      expect(data, equals(Données de l'utilisateur 1));
    });

    test(fetchUserData() lève une exception pour un ID invalide, () async {
      expect(
        () => fetchUserData(-1),
        throwsA(isA<Exception>()),
      );
    });

    test('fetchNumbers() renvoie la liste correcte', () async {
      var numbers = await fetchNumbers();
      expect(numbers, hasLength(5));
      expect(numbers, contains(3));
      expect(numbers.first, equals(1));
    });

    // Test de plusieurs opérations asynchrones
    test('Opérations asynchrones séquentielles', () async {
      var data1 = await fetchUserData(1);
      var data2 = await fetchUserData(2);

      expect(data1, isNot(equals(data2)));
      expect(data1, contains('1'));
      expect(data2, contains('2'));
    });
  });
}
00:00 +4: All tests passed!

Commandes courantes pour exécuter des tests

CommandeFonctionnalités
dart testExécuter tous les tests
dart test test/calculator_test.dartExécuter un fichier de test spécifié
dart test --name="add"Exécuter uniquement les tests dont les noms contiennent "add"
dart test --concurrency=4Exécuter les tests en parallèle (pour accélérer)
dart test --reporter=expandedMode de sortie verbeux
dart test --coverage=coverageGénérer les données de couverture de test

Bonnes pratiques de test

PratiqueDescription
Chaque test ne doit vérifier qu'une seule choseUn test() correspond à un comportement, ce qui accélère la localisation de l'échec.
Les noms des tests décrivent le comportement, pas l'implémentation« add() ajoute deux nombres positifs » est préférable à « test add() ».
Modèle AAAArrange (Mettre en place) → Act (Exécuter) → Assert (Vérifier)
Écrire d'abord des tests qui échouentConfirmer que le test peut détecter les erreurs, puis écrire le code pour le faire passer.
Test des conditions aux limitesNull, zéro, nombres négatifs, très grandes valeurs, très petites valeurs.
Garder les tests indépendants les uns des autresLe résultat d'un test ne doit pas affecter un autre test

Les tests ne sont pas un fardeau mais une assurance. Plus vous écrivez de tests, plus vous êtes confiant lors d'un refactoring. Lorsqu'un test échoue, vous n'avez pas besoin de deviner ce qui n'a pas fonctionné — le test vous le dira précisément.


Résumé du chapitre

Ce chapitre présente le flux de travail complet des tests unitaires Dart : installer le package test, écrire des cas de test avec test(), utiliser les assertions expect(), organiser avec group(), gérer l'environnement avec setUp/tearDown, et les tests asynchrones.

Les tests unitaires sont un passage obligé pour les développeurs professionnels ; développer l'habitude d'écrire des tests améliorera continuellement la qualité de votre code.


Résumé complet du tutoriel

Félicitations pour avoir terminé votre apprentissage d'introduction au langage de programmation Dart !

Passons en revue le parcours d'apprentissage de ces 21 chapitres :

PhaseChapitreContenu principal
1. Bases pour démarrerChapitres 1-4Présentation de Dart, configuration de l'environnement, premier programme, syntaxe de base.
2. Types fondamentaux et flux de contrôleChapitres 5-8Variables et types de données, opérateurs, flux de contrôle, collections.
3. Fonctions et programmation orientée objetChapitres 9-13Fonctions, classes et objets, héritage et polymorphisme, interfaces et Mixin, génériques.
4. Fonctionnalités avancéesChapitres 14-17Énumérations et symboles, gestion des exceptions, gestion des packages et bibliothèques, typedef.
5. Programmation asynchrone et testsChapitres 18-21Programmation asynchrone, Streams, concurrence et Isolate, tests unitaires.

Après avoir maîtrisé tout ce contenu, vous avez déjà la capacité d'utiliser Dart pour le développement quotidien.

Étape suivante : vous pouvez approfondir.Framework FlutterAppliquer les connaissances Dart au développement d'interfaces utilisateur sur mobile et web.

autres extensions