feat(test): add --coverage and --min coverage options (#305)

README.md

@@ -155,8 +155,10 @@ very_good test -r
 Run tests in a Dart or Flutter project.
 
 Usage: very_good test [arguments]
--h, --help Print this usage information.
--r, --recursive Run tests recursively for all nested packages.
+-h, --help Print this usage information.
+-r, --recursive Run tests recursively for all nested packages.
+ --coverage Whether to collect coverage information.
+ --min-coverage Whether to enforce a minimum coverage percentage.
 
 Run "very_good help" to see global options.
 ```

lib/src/cli/cli.dart

@@ -1,5 +1,6 @@
 import 'dart:async';
 
+import 'package:lcov_parser/lcov_parser.dart';
 import 'package:mason/mason.dart';
 import 'package:path/path.dart' as p;
 import 'package:universal_io/io.dart';

lib/src/cli/flutter_cli.dart

@@ -4,6 +4,49 @@ part of 'cli.dart';
 /// is executed without a `pubspec.yaml`.
 class PubspecNotFound implements Exception {}
 
+/// {@template coverage_not_met}
+/// Thrown when `flutter test ---coverage --min-coverage`
+/// does not meet the provided minimum coverage threshold.
+/// {@endtemplate}
+class MinCoverageNotMet implements Exception {
+ /// {@macro coverage_not_met}
+ const MinCoverageNotMet(this.coverage);
+
+ /// The measured coverage percentage (total hits / total found * 100).
+ final double coverage;
+}
+
+/// Thrown when `flutter test ---coverage --min-coverage value`
+/// does not generate the coverage file within the timeout threshold.
+class GenerateCoverageTimeout implements Exception {
+ @override
+ String toString() => 'Timed out waiting for coverage to be generated.';
+}
+
+class _CoverageMetrics {
+ const _CoverageMetrics._({this.totalHits = 0, this.totalFound = 0});
+
+ /// Generate coverage metrics from a list of lcov records.
+ factory _CoverageMetrics.fromLcovRecords(List<Record> records) {
+ return records.fold<_CoverageMetrics>(
+ const _CoverageMetrics._(),
+ (current, record) {
+ final found = record.lines?.found ?? 0;
+ final hit = record.lines?.hit ?? 0;
+ return _CoverageMetrics._(
+ totalFound: current.totalFound + found,
+ totalHits: current.totalHits + hit,
+ );
+ },
+ );
+ }
+
+ final int totalHits;
+ final int totalFound;
+
+ double get percentage => totalFound < 1 ? 0 : (totalHits / totalFound * 100);
+}
+
 /// Flutter CLI
 class Flutter {
  /// Determine whether flutter is installed.
@@ -62,22 +105,40 @@ class Flutter {
  static Future<void> test({
  String cwd = '.',
  bool recursive = false,
+ bool collectCoverage = false,
+ double? minCoverage,
  void Function(String)? stdout,
  void Function(String)? stderr,
- }) {
- return _runCommand(
+ }) async {
+ final lcovPath = p.join(cwd, 'coverage', 'lcov.info');
+ final lcovFile = File(lcovPath);
+
+ if (collectCoverage && lcovFile.existsSync()) {
+ await lcovFile.delete();
+ }
+
+ await _runCommand(
  cmd: (cwd) {
  void noop(String? _) {}
  stdout?.call('Running "flutter test" in $cwd...\n');
  return _flutterTest(
  cwd: cwd,
+ collectCoverage: collectCoverage,
  stdout: stdout ?? noop,
  stderr: stderr ?? noop,
  );
  },
  cwd: cwd,
  recursive: recursive,
  );
+
+ if (collectCoverage) await lcovFile.ensureCreated();
+ if (minCoverage != null) {
+ final records = await Parser.parse(lcovPath);
+ final coverageMetrics = _CoverageMetrics.fromLcovRecords(records);
+ final coverage = coverageMetrics.percentage;
+ if (coverage < minCoverage) throw MinCoverageNotMet(coverage);
+ }
  }
 }
 
@@ -110,6 +171,7 @@ Future<void> _runCommand<T>({
 
 Future<void> _flutterTest({
  String cwd = '.',
+ bool collectCoverage = false,
  required void Function(String) stdout,
  required void Function(String) stderr,
 }) {
@@ -142,7 +204,13 @@ Future<void> _flutterTest({
  },
  );
 
- flutterTest(workingDirectory: cwd, runInShell: true).listen(
+ flutterTest(
+ workingDirectory: cwd,
+ arguments: [
+ if (collectCoverage) '--coverage',
+ ],
+ runInShell: true,
+ ).listen(
  (event) {
  if (event.shouldCancelTimer()) timerSubscription.cancel();
  if (event is SuiteTestEvent) suites[event.suite.id] = event.suite;
@@ -217,6 +285,20 @@ final int _lineLength = () {
  }
 }();
 
+extension on File {
+ Future<void> ensureCreated({
+ Duration timeout = const Duration(seconds: 1),
+ Duration interval = const Duration(milliseconds: 50),
+ }) async {
+ var elapsedTime = Duration.zero;
+ while (!existsSync()) {
+ await Future<void>.delayed(interval);
+ elapsedTime += interval;
+ if (elapsedTime >= timeout) throw GenerateCoverageTimeout();
+ }
+ }
+}
+
 extension on TestEvent {
  bool shouldCancelTimer() {
  final event = this;

lib/src/commands/test.dart

@@ -12,12 +12,22 @@ import 'package:very_good_cli/src/cli/cli.dart';
 class TestCommand extends Command<int> {
  /// {@macro test_command}
  TestCommand({Logger? logger}) : _logger = logger ?? Logger() {
- argParser.addFlag(
- 'recursive',
- abbr: 'r',
- help: 'Run tests recursively for all nested packages.',
- negatable: false,
- );
+ argParser
+ ..addFlag(
+ 'recursive',
+ abbr: 'r',
+ help: 'Run tests recursively for all nested packages.',
+ negatable: false,
+ )
+ ..addFlag(
+ 'coverage',
+ help: 'Whether to collect coverage information.',
+ negatable: false,
+ )
+ ..addOption(
+ 'min-coverage',
+ help: 'Whether to enforce a minimum coverage percentage.',
+ );
  }
 
  final Logger _logger;
@@ -43,6 +53,10 @@ class TestCommand extends Command<int> {
  final recursive = _argResults['recursive'] as bool;
  final target = _argResults.rest.length == 1 ? _argResults.rest[0] : '.';
  final targetPath = path.normalize(Directory(target).absolute.path);
+ final collectCoverage = _argResults['coverage'] as bool;
+ final minCoverage = double.tryParse(
+ _argResults['min-coverage'] as String? ?? '',
+ );
  final isFlutterInstalled = await Flutter.installed();
  if (isFlutterInstalled) {
  try {
@@ -51,10 +65,17 @@ class TestCommand extends Command<int> {
  recursive: recursive,
  stdout: _logger.write,
  stderr: _logger.err,
+ collectCoverage: collectCoverage,
+ minCoverage: minCoverage,
  );
  } on PubspecNotFound catch (_) {
  _logger.err('Could not find a pubspec.yaml in $targetPath');
  return ExitCode.noInput.code;
+ } on MinCoverageNotMet catch (e) {
+ _logger.err(
+ '''Expected coverage >= ${minCoverage!.toStringAsFixed(2)}% but actual is ${e.coverage.toStringAsFixed(2)}%.''',
+ );
+ return ExitCode.unavailable.code;
  } catch (error) {
  _logger.err('$error');
  return ExitCode.unavailable.code;

pubspec.yaml

@@ -8,6 +8,7 @@ environment:
 
 dependencies:
  args: ^2.1.0
+ lcov_parser: ^0.1.2
  mason: ">=0.1.0-dev.9 <0.1.0-dev.10"
  mason_logger: ^0.1.0-dev.6
  meta: ^1.3.0