288 lines
8.3 KiB
Dart
288 lines
8.3 KiB
Dart
#!/usr/bin/env dart
|
|
|
|
import 'dart:io';
|
|
|
|
/// Script pour exécuter tous les tests du module solidarité
|
|
///
|
|
/// Ce script automatise l'exécution des tests avec génération
|
|
/// de rapports de couverture et de métriques de qualité.
|
|
void main(List<String> arguments) async {
|
|
print('🧪 Démarrage des tests du module Solidarité...\n');
|
|
|
|
// Configuration des options de test
|
|
final bool verbose = arguments.contains('--verbose') || arguments.contains('-v');
|
|
final bool coverage = arguments.contains('--coverage') || arguments.contains('-c');
|
|
final bool integration = arguments.contains('--integration') || arguments.contains('-i');
|
|
final String? specific = _getSpecificTest(arguments);
|
|
|
|
try {
|
|
// 1. Vérification de l'environnement
|
|
await _checkEnvironment();
|
|
|
|
// 2. Génération des mocks si nécessaire
|
|
await _generateMocks();
|
|
|
|
// 3. Exécution des tests unitaires
|
|
if (specific == null || specific == 'unit') {
|
|
await _runUnitTests(verbose: verbose, coverage: coverage);
|
|
}
|
|
|
|
// 4. Exécution des tests d'intégration
|
|
if (integration && (specific == null || specific == 'integration')) {
|
|
await _runIntegrationTests(verbose: verbose);
|
|
}
|
|
|
|
// 5. Exécution des tests de widgets
|
|
if (specific == null || specific == 'widget') {
|
|
await _runWidgetTests(verbose: verbose, coverage: coverage);
|
|
}
|
|
|
|
// 6. Génération du rapport de couverture
|
|
if (coverage) {
|
|
await _generateCoverageReport();
|
|
}
|
|
|
|
// 7. Analyse de la qualité du code
|
|
await _runCodeAnalysis();
|
|
|
|
print('\n✅ Tous les tests ont été exécutés avec succès !');
|
|
_printSummary();
|
|
|
|
} catch (e) {
|
|
print('\n❌ Erreur lors de l\'exécution des tests: $e');
|
|
exit(1);
|
|
}
|
|
}
|
|
|
|
/// Vérifie que l'environnement de test est correctement configuré
|
|
Future<void> _checkEnvironment() async {
|
|
print('🔍 Vérification de l\'environnement...');
|
|
|
|
// Vérifier que Flutter est installé
|
|
final flutterResult = await Process.run('flutter', ['--version']);
|
|
if (flutterResult.exitCode != 0) {
|
|
throw Exception('Flutter n\'est pas installé ou accessible');
|
|
}
|
|
|
|
// Vérifier que les dépendances sont installées
|
|
final pubResult = await Process.run('flutter', ['pub', 'get']);
|
|
if (pubResult.exitCode != 0) {
|
|
throw Exception('Erreur lors de l\'installation des dépendances');
|
|
}
|
|
|
|
print('✅ Environnement vérifié');
|
|
}
|
|
|
|
/// Génère les mocks nécessaires pour les tests
|
|
Future<void> _generateMocks() async {
|
|
print('🔧 Génération des mocks...');
|
|
|
|
final result = await Process.run('flutter', [
|
|
'packages',
|
|
'pub',
|
|
'run',
|
|
'build_runner',
|
|
'build',
|
|
'--delete-conflicting-outputs'
|
|
]);
|
|
|
|
if (result.exitCode != 0) {
|
|
print('⚠️ Avertissement: Erreur lors de la génération des mocks');
|
|
print(result.stderr);
|
|
} else {
|
|
print('✅ Mocks générés');
|
|
}
|
|
}
|
|
|
|
/// Exécute les tests unitaires
|
|
Future<void> _runUnitTests({bool verbose = false, bool coverage = false}) async {
|
|
print('🧪 Exécution des tests unitaires...');
|
|
|
|
final args = ['test'];
|
|
|
|
if (coverage) {
|
|
args.add('--coverage');
|
|
}
|
|
|
|
if (verbose) {
|
|
args.add('--reporter=expanded');
|
|
}
|
|
|
|
// Tests spécifiques au module solidarité
|
|
args.addAll([
|
|
'test/features/solidarite/domain/',
|
|
'test/features/solidarite/data/',
|
|
'test/features/solidarite/presentation/bloc/',
|
|
]);
|
|
|
|
final result = await Process.run('flutter', args);
|
|
|
|
if (result.exitCode != 0) {
|
|
print('❌ Échec des tests unitaires');
|
|
print(result.stdout);
|
|
print(result.stderr);
|
|
throw Exception('Tests unitaires échoués');
|
|
}
|
|
|
|
print('✅ Tests unitaires réussis');
|
|
}
|
|
|
|
/// Exécute les tests d'intégration
|
|
Future<void> _runIntegrationTests({bool verbose = false}) async {
|
|
print('🔗 Exécution des tests d\'intégration...');
|
|
|
|
final args = ['test'];
|
|
|
|
if (verbose) {
|
|
args.add('--reporter=expanded');
|
|
}
|
|
|
|
args.add('integration_test/');
|
|
|
|
final result = await Process.run('flutter', args);
|
|
|
|
if (result.exitCode != 0) {
|
|
print('❌ Échec des tests d\'intégration');
|
|
print(result.stdout);
|
|
print(result.stderr);
|
|
throw Exception('Tests d\'intégration échoués');
|
|
}
|
|
|
|
print('✅ Tests d\'intégration réussis');
|
|
}
|
|
|
|
/// Exécute les tests de widgets
|
|
Future<void> _runWidgetTests({bool verbose = false, bool coverage = false}) async {
|
|
print('🎨 Exécution des tests de widgets...');
|
|
|
|
final args = ['test'];
|
|
|
|
if (coverage) {
|
|
args.add('--coverage');
|
|
}
|
|
|
|
if (verbose) {
|
|
args.add('--reporter=expanded');
|
|
}
|
|
|
|
args.add('test/features/solidarite/presentation/widgets/');
|
|
|
|
final result = await Process.run('flutter', args);
|
|
|
|
if (result.exitCode != 0) {
|
|
print('❌ Échec des tests de widgets');
|
|
print(result.stdout);
|
|
print(result.stderr);
|
|
throw Exception('Tests de widgets échoués');
|
|
}
|
|
|
|
print('✅ Tests de widgets réussis');
|
|
}
|
|
|
|
/// Génère le rapport de couverture
|
|
Future<void> _generateCoverageReport() async {
|
|
print('📊 Génération du rapport de couverture...');
|
|
|
|
// Installer lcov si nécessaire (sur Linux/macOS)
|
|
if (Platform.isLinux || Platform.isMacOS) {
|
|
final lcovResult = await Process.run('which', ['lcov']);
|
|
if (lcovResult.exitCode != 0) {
|
|
print('⚠️ lcov n\'est pas installé. Installation recommandée pour les rapports HTML.');
|
|
} else {
|
|
// Générer le rapport HTML
|
|
await Process.run('genhtml', [
|
|
'coverage/lcov.info',
|
|
'-o',
|
|
'coverage/html',
|
|
'--title',
|
|
'UnionFlow Solidarité - Couverture de tests'
|
|
]);
|
|
print('📊 Rapport HTML généré dans coverage/html/');
|
|
}
|
|
}
|
|
|
|
// Afficher les statistiques de couverture
|
|
final coverageFile = File('coverage/lcov.info');
|
|
if (coverageFile.existsSync()) {
|
|
final content = await coverageFile.readAsString();
|
|
final lines = content.split('\n');
|
|
|
|
int totalLines = 0;
|
|
int coveredLines = 0;
|
|
|
|
for (final line in lines) {
|
|
if (line.startsWith('LF:')) {
|
|
totalLines += int.parse(line.substring(3));
|
|
} else if (line.startsWith('LH:')) {
|
|
coveredLines += int.parse(line.substring(3));
|
|
}
|
|
}
|
|
|
|
if (totalLines > 0) {
|
|
final percentage = (coveredLines / totalLines * 100).toStringAsFixed(1);
|
|
print('📊 Couverture: $coveredLines/$totalLines lignes ($percentage%)');
|
|
}
|
|
}
|
|
|
|
print('✅ Rapport de couverture généré');
|
|
}
|
|
|
|
/// Exécute l'analyse de la qualité du code
|
|
Future<void> _runCodeAnalysis() async {
|
|
print('🔍 Analyse de la qualité du code...');
|
|
|
|
final result = await Process.run('flutter', ['analyze', '--fatal-infos']);
|
|
|
|
if (result.exitCode != 0) {
|
|
print('⚠️ Problèmes détectés lors de l\'analyse:');
|
|
print(result.stdout);
|
|
} else {
|
|
print('✅ Aucun problème détecté');
|
|
}
|
|
}
|
|
|
|
/// Affiche un résumé des résultats
|
|
void _printSummary() {
|
|
print('\n📋 RÉSUMÉ DES TESTS');
|
|
print('==================');
|
|
print('✅ Tests unitaires: RÉUSSIS');
|
|
print('✅ Tests de widgets: RÉUSSIS');
|
|
print('✅ Analyse de code: TERMINÉE');
|
|
print('');
|
|
print('📁 Fichiers générés:');
|
|
print(' - coverage/lcov.info (données de couverture)');
|
|
print(' - coverage/html/ (rapport HTML)');
|
|
print('');
|
|
print('🚀 Le module Solidarité est prêt pour la production !');
|
|
}
|
|
|
|
/// Extrait le type de test spécifique des arguments
|
|
String? _getSpecificTest(List<String> arguments) {
|
|
for (int i = 0; i < arguments.length; i++) {
|
|
if (arguments[i] == '--test' || arguments[i] == '-t') {
|
|
if (i + 1 < arguments.length) {
|
|
return arguments[i + 1];
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/// Affiche l'aide
|
|
void _printHelp() {
|
|
print('Usage: dart run_tests.dart [options]');
|
|
print('');
|
|
print('Options:');
|
|
print(' -v, --verbose Affichage détaillé des tests');
|
|
print(' -c, --coverage Génération du rapport de couverture');
|
|
print(' -i, --integration Exécution des tests d\'intégration');
|
|
print(' -t, --test TYPE Exécution d\'un type spécifique (unit|widget|integration)');
|
|
print(' -h, --help Affichage de cette aide');
|
|
print('');
|
|
print('Exemples:');
|
|
print(' dart run_tests.dart # Tous les tests');
|
|
print(' dart run_tests.dart -c # Avec couverture');
|
|
print(' dart run_tests.dart -t unit # Tests unitaires seulement');
|
|
print(' dart run_tests.dart -v -c -i # Tous les tests avec détails');
|
|
}
|