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) :
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) :
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
| Matcher | Objectif | Exemple |
|---|---|---|
| equals(expected) | Vérifier que les valeurs sont égales | expect(result, equals(42)) |
| isTrue / isFalse | Vérifier les valeurs booléennes | expect(flag, isTrue) |
| isNull / isNotNull | Vérifier null | expect(value, isNull) |
| contains(value) | Contient un élément (liste) ou une sous-chaîne (chaîne). | expect(list, contains('a')) |
| isA | Vérifier les types | expect(obj, isA |
| throws | Vérifier qu'une exception est levée | expect(() => f(), throwsException) |
| isNotEmpty | non nul | expect(list, isNotEmpty) |
| hasLength(n) | Vérifier la longueur | expect(list, hasLength(3)) |
| greaterThan(n) | supérieur à | expect(score, greaterThan(60)) |
| closeTo(value, delta) | Nombres à virgule flottante approximativement égaux | expect(3.14, closeTo(3.1, 0.1)) |
Exemple
Applications pratiques de divers Matchers :
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
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
// 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
// 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
// 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
| Commande | Fonctionnalités |
|---|---|
| dart test | Exécuter tous les tests |
| dart test test/calculator_test.dart | Exécuter un fichier de test spécifié |
| dart test --name="add" | Exécuter uniquement les tests dont les noms contiennent "add" |
| dart test --concurrency=4 | Exécuter les tests en parallèle (pour accélérer) |
| dart test --reporter=expanded | Mode de sortie verbeux |
| dart test --coverage=coverage | Générer les données de couverture de test |
Bonnes pratiques de test
| Pratique | Description |
|---|---|
| Chaque test ne doit vérifier qu'une seule chose | Un 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 AAA | Arrange (Mettre en place) → Act (Exécuter) → Assert (Vérifier) |
| Écrire d'abord des tests qui échouent | Confirmer que le test peut détecter les erreurs, puis écrire le code pour le faire passer. |
| Test des conditions aux limites | Null, zéro, nombres négatifs, très grandes valeurs, très petites valeurs. |
| Garder les tests indépendants les uns des autres | Le 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 :
| Phase | Chapitre | Contenu principal |
|---|---|---|
| 1. Bases pour démarrer | Chapitres 1-4 | Présentation de Dart, configuration de l'environnement, premier programme, syntaxe de base. |
| 2. Types fondamentaux et flux de contrôle | Chapitres 5-8 | Variables et types de données, opérateurs, flux de contrôle, collections. |
| 3. Fonctions et programmation orientée objet | Chapitres 9-13 | Fonctions, classes et objets, héritage et polymorphisme, interfaces et Mixin, génériques. |
| 4. Fonctionnalités avancées | Chapitres 14-17 | Énumérations et symboles, gestion des exceptions, gestion des packages et bibliothèques, typedef. |
| 5. Programmation asynchrone et tests | Chapitres 18-21 | Programmation 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