diff --git a/bricks/test_optimizer/brick.yaml b/bricks/test_optimizer/brick.yaml index 07aa58c3d..3c2b80b62 100644 --- a/bricks/test_optimizer/brick.yaml +++ b/bricks/test_optimizer/brick.yaml @@ -12,3 +12,11 @@ vars: default: "." description: The path to the package root. prompt: Please enter the path to the package root. + shard-index: + type: number + description: The 1-based index of the shard to generate tests for. + prompt: Please enter the shard index. + total-shards: + type: number + description: The total number of shards the test suite is split into. + prompt: Please enter the total number of shards. diff --git a/bricks/test_optimizer/hooks/lib/pre_gen.dart b/bricks/test_optimizer/hooks/lib/pre_gen.dart index d2361e265..d7573a1b1 100644 --- a/bricks/test_optimizer/hooks/lib/pre_gen.dart +++ b/bricks/test_optimizer/hooks/lib/pre_gen.dart @@ -40,6 +40,22 @@ Future run(HookContext context) async { final flutterSdkRegExp = RegExp(r'sdk:\s*flutter$', multiLine: true); final isFlutter = flutterSdkRegExp.hasMatch(pubspecContents); + final shardIndex = context.vars['shard-index'] as int?; + final totalShards = context.vars['total-shards'] as int?; + + // The CLI validates these before it gets here, but `mason make` prompts for + // them directly, so guard the round-robin below against values that would + // never terminate or index out of range. + if (shardIndex != null && + totalShards != null && + (totalShards < 1 || shardIndex < 1 || shardIndex > totalShards)) { + context.logger.err( + 'shard-index must be between 1 and total-shards, but got ' + 'shard-index $shardIndex and total-shards $totalShards', + ); + exitFn(1); + } + final identifierGenerator = DartIdentifierGenerator(); final optimizedTests = >[]; final notOptimizedTests = []; @@ -48,13 +64,23 @@ Future run(HookContext context) async { .listSync(recursive: true) .where((entity) => entity.isTest) .cast(); - final parsedTests = await Future.wait(tests.map(_parse)); - - for (final (file, content, metadata) in parsedTests) { - final relativePath = path - .relative(file.path, from: testDir.path) - .replaceAll(r'\', '/'); - + final parsedTests = await Future.wait( + tests.map((file) => _parse(file, testDir: testDir.path)), + ); + + // Sorting guarantees a deterministic order across machines, which is what + // makes sharding reproducible: `Directory.listSync` order is filesystem + // dependent, so without this two runners could disagree on the partition + // and either skip or duplicate tests. Tests kept out of the bundle are + // dealt out in the same round as the optimized ones, which keeps every + // shard within one file of the others. + final shard = _shardOf( + parsedTests..sort((a, b) => a.relativePath.compareTo(b.relativePath)), + shardIndex: shardIndex, + totalShards: totalShards, + ); + + for (final (:relativePath, :content, :metadata) in shard) { if (metadata.skipsOptimization) { notOptimizedTests.add(relativePath); continue; @@ -89,11 +115,39 @@ Future run(HookContext context) async { }; } -typedef _ParsedTest = (File file, String content, TestMetadata metadata); +typedef _ParsedTest = ({ + String relativePath, + String content, + TestMetadata metadata, +}); -Future<_ParsedTest> _parse(File file) async { +/// Reads and parses [file], keyed by its POSIX path relative to [testDir]. +Future<_ParsedTest> _parse(File file, {required String testDir}) async { final content = await file.readAsString(); - return (file, content, parseTestMetadata(content, path: file.path)); + return ( + relativePath: path.relative(file.path, from: testDir).replaceAll(r'\', '/'), + content: content, + metadata: parseTestMetadata(content, path: file.path), + ); +} + +/// Returns the subset of [items] that belongs to the shard [shardIndex] out of +/// [totalShards], or [items] unchanged when sharding is not enabled (either +/// value is `null`). +/// +/// Items are dealt out round-robin (index modulo [totalShards]) over the +/// already sorted [items], which keeps shards balanced in file count and makes +/// the partition stable for a given test suite. +List _shardOf( + List items, { + required int? shardIndex, + required int? totalShards, +}) { + if (shardIndex == null || totalShards == null) return items; + + return [ + for (var i = shardIndex - 1; i < items.length; i += totalShards) items[i], + ]; } extension on FileSystemEntity { diff --git a/bricks/test_optimizer/hooks/test/pre_gen_test.dart b/bricks/test_optimizer/hooks/test/pre_gen_test.dart index d86e17bb0..54f909d59 100644 --- a/bricks/test_optimizer/hooks/test/pre_gen_test.dart +++ b/bricks/test_optimizer/hooks/test/pre_gen_test.dart @@ -1,4 +1,5 @@ import 'dart:io'; +import 'dart:math'; import 'package:hooks/pre_gen.dart' as pre_gen; import 'package:hooks/test_metadata.dart'; @@ -305,6 +306,33 @@ void main() {} expect(context.vars['isFlutter'], isNull); }); + test('when the shard values are out of range', () async { + File(path.join(tempDirectory.path, 'pubspec.yaml')).createSync(); + Directory(path.join(tempDirectory.path, 'test')).createSync(); + + context.vars['package-root'] = tempDirectory.absolute.path; + context.vars['shard-index'] = 1; + context.vars['total-shards'] = 0; + + await expectLater( + () => pre_gen.run(context), + throwsA( + isA().having( + (ex) => ex.arguments.first, + 'error code', + equals('1'), + ), + ), + ); + + verify( + () => context.logger.err( + 'shard-index must be between 1 and total-shards, but got ' + 'shard-index 1 and total-shards 0', + ), + ).called(1); + }); + test('when target dir does not contain a pubspec.yaml', () async { final testDir = Directory(path.join(tempDirectory.path, 'test')) ..createSync(); @@ -412,5 +440,142 @@ void main() {} expect(metadata.skipsOptimization, isFalse); }); }); + group('Sharding', () { + /// Creates a package with [count] optimizable test files, plus any + /// [notOptimized] files carrying the skip optimization tag. + Directory createPackage(int count, {int notOptimized = 0}) { + File(path.join(tempDirectory.path, 'pubspec.yaml')).createSync(); + final testDir = Directory(path.join(tempDirectory.path, 'test')) + ..createSync(); + for (var i = 0; i < count; i++) { + File(path.join(testDir.path, 'test${i}_test.dart')).createSync(); + } + for (var i = 0; i < notOptimized; i++) { + File(path.join(testDir.path, 'skip${i}_test.dart')) + .writeAsStringSync(notOptimizedTestContent); + } + return testDir; + } + + List pathsOf(HookContext context) { + final tests = context.vars['tests'] as List>; + return tests.map((e) => e['path']!).toList(); + } + + Future> runShard(int index, int total) async { + final context = _FakeContext() + ..vars['package-root'] = tempDirectory.absolute.path + ..vars['shard-index'] = index + ..vars['total-shards'] = total; + await pre_gen.run(context); + return [ + ...pathsOf(context), + ...(context.vars['notOptimizedTests']! as List).cast(), + ]; + } + + test('runs every test exactly once across all shards', () async { + createPackage(7, notOptimized: 2); + + final shards = [for (var i = 1; i <= 3; i++) await runShard(i, 3)]; + final union = shards.expand((shard) => shard).toList(); + + expect( + union..sort(), + [ + for (var i = 0; i < 7; i++) 'test${i}_test.dart', + for (var i = 0; i < 2; i++) 'skip${i}_test.dart', + ]..sort(), + reason: 'Shards must be a complete and disjoint partition', + ); + }); + + test('shards non optimized tests as well', () async { + createPackage(0, notOptimized: 4); + + final first = await runShard(1, 2); + final second = await runShard(2, 2); + + expect(first, ['skip0_test.dart', 'skip2_test.dart']); + expect(second, ['skip1_test.dart', 'skip3_test.dart']); + }); + + test('deals optimized and non optimized tests out together', () async { + createPackage(2, notOptimized: 3); + + final sizes = [ + for (var i = 1; i <= 6; i++) (await runShard(i, 6)).length, + ]; + + expect( + sizes, + [1, 1, 1, 1, 1, 0], + reason: + 'Sharding the two lists separately would give the first ' + 'shards a file from each while later shards stay empty', + ); + }); + + test('is deterministic across runs', () async { + createPackage(9); + + expect(await runShard(2, 4), await runShard(2, 4)); + }); + + test('balances shards within one file of each other', () async { + createPackage(10); + + final sizes = [ + for (var i = 1; i <= 4; i++) (await runShard(i, 4)).length, + ]; + + expect(sizes.reduce(max) - sizes.reduce(min), lessThanOrEqualTo(1)); + }); + + test( + 'yields an empty shard when there are more shards than tests', + () async { + createPackage(2); + + expect(await runShard(3, 3), isEmpty); + }, + ); + + test( + 'excludes nested non optimized tests from the optimized set', + () async { + File(path.join(tempDirectory.path, 'pubspec.yaml')).createSync(); + final testDir = Directory(path.join(tempDirectory.path, 'test')) + ..createSync(); + final nested = Directory(path.join(testDir.path, 'sub')) + ..createSync(); + File(path.join(nested.path, 'skip_test.dart')) + .writeAsStringSync(notOptimizedTestContent); + + final context = _FakeContext() + ..vars['package-root'] = tempDirectory.absolute.path; + await pre_gen.run(context); + + expect( + pathsOf(context), + isEmpty, + reason: + 'A tagged test in a subdirectory must not be optimized, ' + 'otherwise it runs both inlined and standalone', + ); + expect(context.vars['notOptimizedTests'], ['sub/skip_test.dart']); + }, + ); + + test('includes every test when sharding is not requested', () async { + createPackage(3); + + final context = _FakeContext() + ..vars['package-root'] = tempDirectory.absolute.path; + await pre_gen.run(context); + + expect(pathsOf(context), hasLength(3)); + }); + }); }); } diff --git a/lib/src/cli/dart_cli.dart b/lib/src/cli/dart_cli.dart index d31664405..ea0ee1715 100644 --- a/lib/src/cli/dart_cli.dart +++ b/lib/src/cli/dart_cli.dart @@ -137,6 +137,8 @@ class Dart { void Function(String)? stderr, GeneratorBuilder buildGenerator = MasonGenerator.fromBundle, List? reportOn, + int? shardIndex, + int? totalShards, }) { return TestCLIRunner.test( logger: logger, @@ -150,6 +152,8 @@ class Dart { enabled: optimizePerformance, exclude: excludeOptimization, buildGenerator: buildGenerator, + shardIndex: shardIndex, + totalShards: totalShards, ), ignore: ignore, minCoverage: minCoverage, diff --git a/lib/src/cli/flutter_cli.dart b/lib/src/cli/flutter_cli.dart index 9cedc920c..2a922c8f9 100644 --- a/lib/src/cli/flutter_cli.dart +++ b/lib/src/cli/flutter_cli.dart @@ -214,6 +214,8 @@ class Flutter { void Function(String)? stderr, GeneratorBuilder buildGenerator = MasonGenerator.fromBundle, List? reportOn, + int? shardIndex, + int? totalShards, }) { return TestCLIRunner.test( logger: logger, @@ -225,6 +227,8 @@ class Flutter { enabled: optimizePerformance, exclude: excludeOptimization, buildGenerator: buildGenerator, + shardIndex: shardIndex, + totalShards: totalShards, ), ignore: ignore, minCoverage: minCoverage, diff --git a/lib/src/cli/templates/test_optimizer_bundle.dart b/lib/src/cli/templates/test_optimizer_bundle.dart index 0cf3785c1..a555b4e36 100644 --- a/lib/src/cli/templates/test_optimizer_bundle.dart +++ b/lib/src/cli/templates/test_optimizer_bundle.dart @@ -20,7 +20,7 @@ final testOptimizerBundle = MasonBundle.fromJson({ }, { "path": "lib/pre_gen.dart", - "data": "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", + "data": "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", "type": "text", }, { @@ -45,7 +45,7 @@ final testOptimizerBundle = MasonBundle.fromJson({ }, { "path": "test/pre_gen_test.dart", - "data": "import 'dart:io';

import 'package:hooks/pre_gen.dart' as pre_gen;
import 'package:hooks/test_metadata.dart';
import 'package:mason/mason.dart';
import 'package:mocktail/mocktail.dart';
import 'package:path/path.dart' as path;
import 'package:test/test.dart';

class _MockLogger extends Mock implements Logger;

class _FakeContext extends Fake implements HookContext {
  @override
  final logger = _MockLogger();

  @override
  Map<String, Object?> vars = {};
}

const notOptimizedTestContent =
    '''
@Tags(['${pre_gen.skipVeryGoodOptimizationTag}'])
library;

void main() {
  test('test', () {
    expect(1, 1);
  });
}
''';

const anotherNotOptimizedTestContent =
    '''
@Tags(['${pre_gen.skipVeryGoodOptimizationTag}', 'another_tag'])
import 'package:test/test.dart';

void main() {
  test('another test', () {
    expect(1, 1);
  });
}
''';

void main() {
  late Directory tempDirectory;

  setUp(() {
    tempDirectory = Directory.systemTemp.createTempSync('test_optimizer');
  });

  tearDown(() {
    tempDirectory.deleteSync(recursive: true);
  });

  group('Pre gen hook', () {
    late HookContext context;

    setUp(() {
      context = _FakeContext();
    });

    group('Completes', () {
      test('with test files list', () async {
        File(path.join(tempDirectory.path, 'pubspec.yaml')).createSync();

        final testDir = Directory(path.join(tempDirectory.path, 'test'))
          ..createSync();
        File(path.join(testDir.path, 'test1_test.dart')).createSync();
        File(path.join(testDir.path, 'test2_test.dart')).createSync();
        File(path.join(testDir.path, 'no_test_here.dart')).createSync();

        context.vars['package-root'] = tempDirectory.absolute.path;

        await pre_gen.run(context);

        final tests = context.vars['tests'] as List<Map<String, String>>;
        final testsMap = <String, String>{};
        for (final test in tests) {
          final path = test['path']!;
          final identifier = test['identifier']!;
          testsMap[path] = identifier;
        }

        final paths = testsMap.keys;
        expect(paths, contains('test1_test.dart'));
        expect(paths, contains('test2_test.dart'));
        expect(paths, isNot(contains('no_test_here.dart')));

        expect(
          testsMap.values.toSet().length,
          equals(tests.length),
          reason: 'All tests files should have unique identifiers',
        );

        expect(
          tests.map((test) => test['groupArguments']),
          everyElement(isEmpty),
          reason: 'Files without annotations forward no group arguments',
        );

        expect(context.vars['isFlutter'], false);
      });

      test('with proper isFlutter identification', () async {
        File(path.join(tempDirectory.path, 'pubspec.yaml'))
          ..createSync()
          ..writeAsStringSync('''
dependencies:
  flutter:
    sdk: flutter''');

        Directory(path.join(tempDirectory.path, 'test')).createSync();

        context.vars['package-root'] = tempDirectory.absolute.path;

        await pre_gen.run(context);

        expect(context.vars['isFlutter'], true);
      });

      test('with proper not optimized tests identification', () async {
        File(path.join(tempDirectory.path, 'pubspec.yaml')).createSync();

        final testDir = Directory(path.join(tempDirectory.path, 'test'))
          ..createSync();
        File(path.join(testDir.path, 'test1_test.dart')).createSync();
        File(path.join(testDir.path, 'test2_test.dart')).createSync();
        File(path.join(testDir.path, 'no_test_here.dart')).createSync();
        File(path.join(testDir.path, 'not_optimized_test.dart'))
            .writeAsStringSync(notOptimizedTestContent);
        File(path.join(testDir.path, 'another_not_optimized_test.dart'))
            .writeAsStringSync(anotherNotOptimizedTestContent);

        context.vars['package-root'] = tempDirectory.absolute.path;

        await pre_gen.run(context);

        final tests = context.vars['tests'] as List<Map<String, String>>;
        final testsMap = <String, String>{};
        for (final test in tests) {
          final path = test['path']!;
          final identifier = test['identifier']!;
          testsMap[path] = identifier;
        }

        final paths = testsMap.keys;
        expect(paths, contains('test1_test.dart'));
        expect(paths, contains('test2_test.dart'));
        expect(paths, isNot(contains('no_test_here.dart')));
        expect(paths, isNot(contains('not_optimized_test.dart')));
        expect(paths, isNot(contains('another_not_optimized_test.dart')));

        expect(
          testsMap.values.toSet().length,
          equals(tests.length),
          reason: 'All tests files should have unique identifiers',
        );
        final notOptimizedTests =
            context.vars['notOptimizedTests'] as List<String>;
        expect(notOptimizedTests, contains('not_optimized_test.dart'));
        expect(notOptimizedTests, contains('another_not_optimized_test.dart'));
      });

      test(
        'with file level annotations forwarded as group arguments',
        () async {
          File(path.join(tempDirectory.path, 'pubspec.yaml')).createSync();

          final testDir = Directory(path.join(tempDirectory.path, 'test'))
            ..createSync();
          File(path.join(testDir.path, 'annotated_test.dart'))
              .writeAsStringSync('''
@Tags(['slow'])
@Timeout(Duration(minutes: 5))
library;

void main() {}
''');

          context.vars['package-root'] = tempDirectory.absolute.path;

          await pre_gen.run(context);

          final tests = context.vars['tests'] as List<Map<String, String>>;
          expect(tests, hasLength(1));
          expect(
            tests.single['groupArguments'],
            equals(", timeout: Timeout(Duration(minutes: 5)), tags: ['slow']"),
          );
        },
      );

      test(
        'with a skip tag package:test would ignore left optimized',
        () async {
          File(path.join(tempDirectory.path, 'pubspec.yaml')).createSync();

          final testDir = Directory(path.join(tempDirectory.path, 'test'))
            ..createSync();
          File(path.join(testDir.path, 'no_directive_test.dart'))
              .writeAsStringSync('''
@Tags(['${pre_gen.skipVeryGoodOptimizationTag}'])
void main() {}
''');

          context.vars['package-root'] = tempDirectory.absolute.path;

          await pre_gen.run(context);

          final tests = context.vars['tests'] as List<Map<String, String>>;
          expect(
            tests.map((test) => test['path']),
            contains('no_directive_test.dart'),
          );
          expect(context.vars['notOptimizedTests'], isEmpty);

          verify(
            () => context.logger.warn(
              any(
                that: allOf(
                  contains('no_directive_test.dart'),
                  contains(pre_gen.skipVeryGoodOptimizationTag),
                ),
              ),
            ),
          ).called(1);
        },
      );

      test(
        'with an unresolvable annotation left out and warned about',
        () async {
          File(path.join(tempDirectory.path, 'pubspec.yaml')).createSync();

          final testDir = Directory(path.join(tempDirectory.path, 'test'))
            ..createSync();
          File(path.join(testDir.path, 'unresolvable_test.dart'))
              .writeAsStringSync('''
@Timeout(kSlowSuite)
@Retry(2)
library;

void main() {}
''');

          context.vars['package-root'] = tempDirectory.absolute.path;

          await pre_gen.run(context);

          final tests = context.vars['tests'] as List<Map<String, String>>;
          expect(
            tests.single['groupArguments'],
            equals(', retry: 2'),
            reason: 'The resolvable sibling is still forwarded',
          );

          verify(
            () => context.logger.warn(
              any(
                that: allOf(
                  contains('unresolvable_test.dart'),
                  contains('@Timeout(kSlowSuite)'),
                ),
              ),
            ),
          ).called(1);
        },
      );
    });

    group('Fails', () {
      setUp(() {
        pre_gen.exitFn = (code) {
          throw ProcessException('exit', [code.toString()]);
        };
      });

      tearDown(() {
        pre_gen.exitFn = exit;
      });

      test('when target test dir does not exist', () async {
        File(path.join(tempDirectory.path, 'pubspec.yaml')).createSync();

        final testDir = Directory(path.join(tempDirectory.path, 'test'));

        context.vars['package-root'] = tempDirectory.absolute.path;

        await expectLater(
          () => pre_gen.run(context),
          throwsA(
            isA<ProcessException>().having(
              (ex) => ex.arguments.first,
              'error code',
              equals('1'),
            ),
          ),
        );

        verify(
          () => context.logger.err('Could not find directory ${testDir.path}'),
        ).called(1);

        expect(context.vars['tests'], isNull);
        expect(context.vars['isFlutter'], isNull);
      });

      test('when target dir does not contain a pubspec.yaml', () async {
        final testDir = Directory(path.join(tempDirectory.path, 'test'))
          ..createSync();
        File(path.join(testDir.path, 'test1_test.dart')).createSync();
        File(path.join(testDir.path, 'test2_test.dart')).createSync();
        File(path.join(testDir.path, 'no_test_here.dart')).createSync();

        context.vars['package-root'] = tempDirectory.absolute.path;

        await expectLater(
          () => pre_gen.run(context),
          throwsA(
            isA<ProcessException>().having(
              (ex) => ex.arguments.first,
              'error code',
              equals('1'),
            ),
          ),
        );

        verify(
          () => context.logger.err(
            'Could not find pubspec.yaml at ${testDir.path}',
          ),
        ).called(1);

        expect(context.vars['tests'], isNull);
        expect(context.vars['isFlutter'], isNull);
      });
    });
  });

  group('TestMetadataBundle', () {
    group('groupArguments', () {
      test('is empty without annotations', () {
        final metadata = parseTestMetadata('void main() {}');

        expect(metadata.groupArguments, isEmpty);
      });

      test('emits a single annotation', () {
        final metadata = parseTestMetadata("@Skip('not ready')\nlibrary;");

        expect(metadata.groupArguments, equals(", skip: 'not ready'"));
      });

      test('emits a fixed order regardless of source order', () {
        final metadata = parseTestMetadata('''
@Retry(3)
@Tags(['slow'])
@Skip()
@Timeout.none
@TestOn('vm')
library;
''');

        expect(
          metadata.groupArguments,
          equals(
            ", testOn: 'vm', timeout: Timeout.none, skip: true, "
            "tags: ['slow'], retry: 3",
          ),
        );
      });
    });

    group('skipsOptimization', () {
      test('is true for the skip tag on its own', () {
        final metadata = parseTestMetadata(
          "@Tags(['${pre_gen.skipVeryGoodOptimizationTag}'])\nlibrary;",
        );

        expect(metadata.skipsOptimization, isTrue);
      });

      test('is true when the skip tag is not first', () {
        final metadata = parseTestMetadata(
          "@Tags(['other', '${pre_gen.skipVeryGoodOptimizationTag}'])\n"
          'library;',
        );

        expect(metadata.skipsOptimization, isTrue);
      });

      test('is false without the tag', () {
        final metadata = parseTestMetadata("@Tags(['other'])\nlibrary;");

        expect(metadata.skipsOptimization, isFalse);
      });

      test('is false when the tag is only a substring', () {
        final metadata = parseTestMetadata(
          "@Tags(['${pre_gen.skipVeryGoodOptimizationTag},test'])\nlibrary;",
        );

        expect(metadata.skipsOptimization, isFalse);
      });

      test('is false when the annotation is not on the first directive', () {
        final metadata = parseTestMetadata('''
@Tags(['${pre_gen.skipVeryGoodOptimizationTag}'])
void main() {}
''');

        expect(metadata.skipsOptimization, isFalse);
      });
    });
  });
}
", + "data": "import 'dart:io';
import 'dart:math';

import 'package:hooks/pre_gen.dart' as pre_gen;
import 'package:hooks/test_metadata.dart';
import 'package:mason/mason.dart';
import 'package:mocktail/mocktail.dart';
import 'package:path/path.dart' as path;
import 'package:test/test.dart';

class _MockLogger extends Mock implements Logger;

class _FakeContext extends Fake implements HookContext {
  @override
  final logger = _MockLogger();

  @override
  Map<String, Object?> vars = {};
}

const notOptimizedTestContent =
    '''
@Tags(['${pre_gen.skipVeryGoodOptimizationTag}'])
library;

void main() {
  test('test', () {
    expect(1, 1);
  });
}
''';

const anotherNotOptimizedTestContent =
    '''
@Tags(['${pre_gen.skipVeryGoodOptimizationTag}', 'another_tag'])
import 'package:test/test.dart';

void main() {
  test('another test', () {
    expect(1, 1);
  });
}
''';

void main() {
  late Directory tempDirectory;

  setUp(() {
    tempDirectory = Directory.systemTemp.createTempSync('test_optimizer');
  });

  tearDown(() {
    tempDirectory.deleteSync(recursive: true);
  });

  group('Pre gen hook', () {
    late HookContext context;

    setUp(() {
      context = _FakeContext();
    });

    group('Completes', () {
      test('with test files list', () async {
        File(path.join(tempDirectory.path, 'pubspec.yaml')).createSync();

        final testDir = Directory(path.join(tempDirectory.path, 'test'))
          ..createSync();
        File(path.join(testDir.path, 'test1_test.dart')).createSync();
        File(path.join(testDir.path, 'test2_test.dart')).createSync();
        File(path.join(testDir.path, 'no_test_here.dart')).createSync();

        context.vars['package-root'] = tempDirectory.absolute.path;

        await pre_gen.run(context);

        final tests = context.vars['tests'] as List<Map<String, String>>;
        final testsMap = <String, String>{};
        for (final test in tests) {
          final path = test['path']!;
          final identifier = test['identifier']!;
          testsMap[path] = identifier;
        }

        final paths = testsMap.keys;
        expect(paths, contains('test1_test.dart'));
        expect(paths, contains('test2_test.dart'));
        expect(paths, isNot(contains('no_test_here.dart')));

        expect(
          testsMap.values.toSet().length,
          equals(tests.length),
          reason: 'All tests files should have unique identifiers',
        );

        expect(
          tests.map((test) => test['groupArguments']),
          everyElement(isEmpty),
          reason: 'Files without annotations forward no group arguments',
        );

        expect(context.vars['isFlutter'], false);
      });

      test('with proper isFlutter identification', () async {
        File(path.join(tempDirectory.path, 'pubspec.yaml'))
          ..createSync()
          ..writeAsStringSync('''
dependencies:
  flutter:
    sdk: flutter''');

        Directory(path.join(tempDirectory.path, 'test')).createSync();

        context.vars['package-root'] = tempDirectory.absolute.path;

        await pre_gen.run(context);

        expect(context.vars['isFlutter'], true);
      });

      test('with proper not optimized tests identification', () async {
        File(path.join(tempDirectory.path, 'pubspec.yaml')).createSync();

        final testDir = Directory(path.join(tempDirectory.path, 'test'))
          ..createSync();
        File(path.join(testDir.path, 'test1_test.dart')).createSync();
        File(path.join(testDir.path, 'test2_test.dart')).createSync();
        File(path.join(testDir.path, 'no_test_here.dart')).createSync();
        File(path.join(testDir.path, 'not_optimized_test.dart'))
            .writeAsStringSync(notOptimizedTestContent);
        File(path.join(testDir.path, 'another_not_optimized_test.dart'))
            .writeAsStringSync(anotherNotOptimizedTestContent);

        context.vars['package-root'] = tempDirectory.absolute.path;

        await pre_gen.run(context);

        final tests = context.vars['tests'] as List<Map<String, String>>;
        final testsMap = <String, String>{};
        for (final test in tests) {
          final path = test['path']!;
          final identifier = test['identifier']!;
          testsMap[path] = identifier;
        }

        final paths = testsMap.keys;
        expect(paths, contains('test1_test.dart'));
        expect(paths, contains('test2_test.dart'));
        expect(paths, isNot(contains('no_test_here.dart')));
        expect(paths, isNot(contains('not_optimized_test.dart')));
        expect(paths, isNot(contains('another_not_optimized_test.dart')));

        expect(
          testsMap.values.toSet().length,
          equals(tests.length),
          reason: 'All tests files should have unique identifiers',
        );
        final notOptimizedTests =
            context.vars['notOptimizedTests'] as List<String>;
        expect(notOptimizedTests, contains('not_optimized_test.dart'));
        expect(notOptimizedTests, contains('another_not_optimized_test.dart'));
      });

      test(
        'with file level annotations forwarded as group arguments',
        () async {
          File(path.join(tempDirectory.path, 'pubspec.yaml')).createSync();

          final testDir = Directory(path.join(tempDirectory.path, 'test'))
            ..createSync();
          File(path.join(testDir.path, 'annotated_test.dart'))
              .writeAsStringSync('''
@Tags(['slow'])
@Timeout(Duration(minutes: 5))
library;

void main() {}
''');

          context.vars['package-root'] = tempDirectory.absolute.path;

          await pre_gen.run(context);

          final tests = context.vars['tests'] as List<Map<String, String>>;
          expect(tests, hasLength(1));
          expect(
            tests.single['groupArguments'],
            equals(", timeout: Timeout(Duration(minutes: 5)), tags: ['slow']"),
          );
        },
      );

      test(
        'with a skip tag package:test would ignore left optimized',
        () async {
          File(path.join(tempDirectory.path, 'pubspec.yaml')).createSync();

          final testDir = Directory(path.join(tempDirectory.path, 'test'))
            ..createSync();
          File(path.join(testDir.path, 'no_directive_test.dart'))
              .writeAsStringSync('''
@Tags(['${pre_gen.skipVeryGoodOptimizationTag}'])
void main() {}
''');

          context.vars['package-root'] = tempDirectory.absolute.path;

          await pre_gen.run(context);

          final tests = context.vars['tests'] as List<Map<String, String>>;
          expect(
            tests.map((test) => test['path']),
            contains('no_directive_test.dart'),
          );
          expect(context.vars['notOptimizedTests'], isEmpty);

          verify(
            () => context.logger.warn(
              any(
                that: allOf(
                  contains('no_directive_test.dart'),
                  contains(pre_gen.skipVeryGoodOptimizationTag),
                ),
              ),
            ),
          ).called(1);
        },
      );

      test(
        'with an unresolvable annotation left out and warned about',
        () async {
          File(path.join(tempDirectory.path, 'pubspec.yaml')).createSync();

          final testDir = Directory(path.join(tempDirectory.path, 'test'))
            ..createSync();
          File(path.join(testDir.path, 'unresolvable_test.dart'))
              .writeAsStringSync('''
@Timeout(kSlowSuite)
@Retry(2)
library;

void main() {}
''');

          context.vars['package-root'] = tempDirectory.absolute.path;

          await pre_gen.run(context);

          final tests = context.vars['tests'] as List<Map<String, String>>;
          expect(
            tests.single['groupArguments'],
            equals(', retry: 2'),
            reason: 'The resolvable sibling is still forwarded',
          );

          verify(
            () => context.logger.warn(
              any(
                that: allOf(
                  contains('unresolvable_test.dart'),
                  contains('@Timeout(kSlowSuite)'),
                ),
              ),
            ),
          ).called(1);
        },
      );
    });

    group('Fails', () {
      setUp(() {
        pre_gen.exitFn = (code) {
          throw ProcessException('exit', [code.toString()]);
        };
      });

      tearDown(() {
        pre_gen.exitFn = exit;
      });

      test('when target test dir does not exist', () async {
        File(path.join(tempDirectory.path, 'pubspec.yaml')).createSync();

        final testDir = Directory(path.join(tempDirectory.path, 'test'));

        context.vars['package-root'] = tempDirectory.absolute.path;

        await expectLater(
          () => pre_gen.run(context),
          throwsA(
            isA<ProcessException>().having(
              (ex) => ex.arguments.first,
              'error code',
              equals('1'),
            ),
          ),
        );

        verify(
          () => context.logger.err('Could not find directory ${testDir.path}'),
        ).called(1);

        expect(context.vars['tests'], isNull);
        expect(context.vars['isFlutter'], isNull);
      });

      test('when the shard values are out of range', () async {
        File(path.join(tempDirectory.path, 'pubspec.yaml')).createSync();
        Directory(path.join(tempDirectory.path, 'test')).createSync();

        context.vars['package-root'] = tempDirectory.absolute.path;
        context.vars['shard-index'] = 1;
        context.vars['total-shards'] = 0;

        await expectLater(
          () => pre_gen.run(context),
          throwsA(
            isA<ProcessException>().having(
              (ex) => ex.arguments.first,
              'error code',
              equals('1'),
            ),
          ),
        );

        verify(
          () => context.logger.err(
            'shard-index must be between 1 and total-shards, but got '
            'shard-index 1 and total-shards 0',
          ),
        ).called(1);
      });

      test('when target dir does not contain a pubspec.yaml', () async {
        final testDir = Directory(path.join(tempDirectory.path, 'test'))
          ..createSync();
        File(path.join(testDir.path, 'test1_test.dart')).createSync();
        File(path.join(testDir.path, 'test2_test.dart')).createSync();
        File(path.join(testDir.path, 'no_test_here.dart')).createSync();

        context.vars['package-root'] = tempDirectory.absolute.path;

        await expectLater(
          () => pre_gen.run(context),
          throwsA(
            isA<ProcessException>().having(
              (ex) => ex.arguments.first,
              'error code',
              equals('1'),
            ),
          ),
        );

        verify(
          () => context.logger.err(
            'Could not find pubspec.yaml at ${testDir.path}',
          ),
        ).called(1);

        expect(context.vars['tests'], isNull);
        expect(context.vars['isFlutter'], isNull);
      });
    });
  });

  group('TestMetadataBundle', () {
    group('groupArguments', () {
      test('is empty without annotations', () {
        final metadata = parseTestMetadata('void main() {}');

        expect(metadata.groupArguments, isEmpty);
      });

      test('emits a single annotation', () {
        final metadata = parseTestMetadata("@Skip('not ready')\nlibrary;");

        expect(metadata.groupArguments, equals(", skip: 'not ready'"));
      });

      test('emits a fixed order regardless of source order', () {
        final metadata = parseTestMetadata('''
@Retry(3)
@Tags(['slow'])
@Skip()
@Timeout.none
@TestOn('vm')
library;
''');

        expect(
          metadata.groupArguments,
          equals(
            ", testOn: 'vm', timeout: Timeout.none, skip: true, "
            "tags: ['slow'], retry: 3",
          ),
        );
      });
    });

    group('skipsOptimization', () {
      test('is true for the skip tag on its own', () {
        final metadata = parseTestMetadata(
          "@Tags(['${pre_gen.skipVeryGoodOptimizationTag}'])\nlibrary;",
        );

        expect(metadata.skipsOptimization, isTrue);
      });

      test('is true when the skip tag is not first', () {
        final metadata = parseTestMetadata(
          "@Tags(['other', '${pre_gen.skipVeryGoodOptimizationTag}'])\n"
          'library;',
        );

        expect(metadata.skipsOptimization, isTrue);
      });

      test('is false without the tag', () {
        final metadata = parseTestMetadata("@Tags(['other'])\nlibrary;");

        expect(metadata.skipsOptimization, isFalse);
      });

      test('is false when the tag is only a substring', () {
        final metadata = parseTestMetadata(
          "@Tags(['${pre_gen.skipVeryGoodOptimizationTag},test'])\nlibrary;",
        );

        expect(metadata.skipsOptimization, isFalse);
      });

      test('is false when the annotation is not on the first directive', () {
        final metadata = parseTestMetadata('''
@Tags(['${pre_gen.skipVeryGoodOptimizationTag}'])
void main() {}
''');

        expect(metadata.skipsOptimization, isFalse);
      });
    });
    group('Sharding', () {
      /// Creates a package with [count] optimizable test files, plus any
      /// [notOptimized] files carrying the skip optimization tag.
      Directory createPackage(int count, {int notOptimized = 0}) {
        File(path.join(tempDirectory.path, 'pubspec.yaml')).createSync();
        final testDir = Directory(path.join(tempDirectory.path, 'test'))
          ..createSync();
        for (var i = 0; i < count; i++) {
          File(path.join(testDir.path, 'test${i}_test.dart')).createSync();
        }
        for (var i = 0; i < notOptimized; i++) {
          File(path.join(testDir.path, 'skip${i}_test.dart'))
              .writeAsStringSync(notOptimizedTestContent);
        }
        return testDir;
      }

      List<String> pathsOf(HookContext context) {
        final tests = context.vars['tests'] as List<Map<String, String>>;
        return tests.map((e) => e['path']!).toList();
      }

      Future<List<String>> runShard(int index, int total) async {
        final context = _FakeContext()
          ..vars['package-root'] = tempDirectory.absolute.path
          ..vars['shard-index'] = index
          ..vars['total-shards'] = total;
        await pre_gen.run(context);
        return [
          ...pathsOf(context),
          ...(context.vars['notOptimizedTests']! as List).cast<String>(),
        ];
      }

      test('runs every test exactly once across all shards', () async {
        createPackage(7, notOptimized: 2);

        final shards = [for (var i = 1; i <= 3; i++) await runShard(i, 3)];
        final union = shards.expand((shard) => shard).toList();

        expect(
          union..sort(),
          [
            for (var i = 0; i < 7; i++) 'test${i}_test.dart',
            for (var i = 0; i < 2; i++) 'skip${i}_test.dart',
          ]..sort(),
          reason: 'Shards must be a complete and disjoint partition',
        );
      });

      test('shards non optimized tests as well', () async {
        createPackage(0, notOptimized: 4);

        final first = await runShard(1, 2);
        final second = await runShard(2, 2);

        expect(first, ['skip0_test.dart', 'skip2_test.dart']);
        expect(second, ['skip1_test.dart', 'skip3_test.dart']);
      });

      test('deals optimized and non optimized tests out together', () async {
        createPackage(2, notOptimized: 3);

        final sizes = [
          for (var i = 1; i <= 6; i++) (await runShard(i, 6)).length,
        ];

        expect(
          sizes,
          [1, 1, 1, 1, 1, 0],
          reason:
              'Sharding the two lists separately would give the first '
              'shards a file from each while later shards stay empty',
        );
      });

      test('is deterministic across runs', () async {
        createPackage(9);

        expect(await runShard(2, 4), await runShard(2, 4));
      });

      test('balances shards within one file of each other', () async {
        createPackage(10);

        final sizes = [
          for (var i = 1; i <= 4; i++) (await runShard(i, 4)).length,
        ];

        expect(sizes.reduce(max) - sizes.reduce(min), lessThanOrEqualTo(1));
      });

      test(
        'yields an empty shard when there are more shards than tests',
        () async {
          createPackage(2);

          expect(await runShard(3, 3), isEmpty);
        },
      );

      test(
        'excludes nested non optimized tests from the optimized set',
        () async {
          File(path.join(tempDirectory.path, 'pubspec.yaml')).createSync();
          final testDir = Directory(path.join(tempDirectory.path, 'test'))
            ..createSync();
          final nested = Directory(path.join(testDir.path, 'sub'))
            ..createSync();
          File(path.join(nested.path, 'skip_test.dart'))
              .writeAsStringSync(notOptimizedTestContent);

          final context = _FakeContext()
            ..vars['package-root'] = tempDirectory.absolute.path;
          await pre_gen.run(context);

          expect(
            pathsOf(context),
            isEmpty,
            reason:
                'A tagged test in a subdirectory must not be optimized, '
                'otherwise it runs both inlined and standalone',
          );
          expect(context.vars['notOptimizedTests'], ['sub/skip_test.dart']);
        },
      );

      test('includes every test when sharding is not requested', () async {
        createPackage(3);

        final context = _FakeContext()
          ..vars['package-root'] = tempDirectory.absolute.path;
        await pre_gen.run(context);

        expect(pathsOf(context), hasLength(3));
      });
    });
  });
}
", "type": "text", }, { @@ -71,5 +71,15 @@ final testOptimizerBundle = MasonBundle.fromJson({ "default": ".", "prompt": "Please enter the path to the package root.", }, + "shard-index": { + "type": "number", + "description": "The 1-based index of the shard to generate tests for.", + "prompt": "Please enter the shard index.", + }, + "total-shards": { + "type": "number", + "description": "The total number of shards the test suite is split into.", + "prompt": "Please enter the total number of shards.", + }, }, }); diff --git a/lib/src/cli/test_cli_runner.dart b/lib/src/cli/test_cli_runner.dart index 13f1b1df0..2b3fba6cc 100644 --- a/lib/src/cli/test_cli_runner.dart +++ b/lib/src/cli/test_cli_runner.dart @@ -83,6 +83,65 @@ class TestCLIRunner { return rest.where((arg) => !arg.startsWith('-')).isNotEmpty; } + /// Validates the `--shard-index` / `--total-shards` combination. + /// + /// Returns an error message describing the problem, or `null` when the + /// configuration is valid. + /// + /// [rawShardIndex], [rawTotalShards] and [rawMinCoverage] are the unparsed + /// command line values, so that "not provided" can be told apart from + /// "provided but not a number", and an explicit `--min-coverage` from one + /// inherited from `very_good.yaml`. [optimizePerformance] is the effective + /// value, after every option that disables the optimizer is accounted for. + static String? validateSharding({ + required String? rawShardIndex, + required String? rawTotalShards, + required String? rawMinCoverage, + required bool optimizePerformance, + }) { + if (rawShardIndex == null && rawTotalShards == null) return null; + + if (rawShardIndex == null || rawTotalShards == null) { + return '--shard-index and --total-shards must be used together.'; + } + + final totalShards = int.tryParse(rawTotalShards); + if (totalShards == null || totalShards < 1) { + return '--total-shards must be a positive integer, ' + 'but got "$rawTotalShards".'; + } + + final shardIndex = int.tryParse(rawShardIndex); + if (shardIndex == null || shardIndex < 1) { + return '--shard-index must be a positive integer, ' + 'but got "$rawShardIndex".'; + } + + if (shardIndex > totalShards) { + return '--shard-index ($shardIndex) must be less than or equal to ' + '--total-shards ($totalShards).'; + } + + // Sharding partitions the test files consolidated by the optimizer, so it + // cannot work when the optimization is turned off. + if (!optimizePerformance) { + return 'Sharding requires the test optimizer, which is disabled by ' + '--no-optimization, --platform, --update-goldens or by targeting ' + 'specific test files.'; + } + + // Each shard only exercises a fraction of the codebase, so its coverage is + // not representative of the whole suite. Merge the lcov files from every + // shard and enforce the threshold in a separate job instead. + if (rawMinCoverage != null) { + return '--min-coverage cannot be combined with sharding. Collect ' + 'coverage per shard with --coverage, merge the lcov reports, then ' + 'check the threshold in a separate job.'; + } + + return null; + } + /// Run tests (`flutter test`). /// Returns a list of exit codes for each test process. static Future> test({ @@ -145,6 +204,17 @@ class TestCLIRunner { logger: logger, ); + if (optimization.isEmptyShard) { + stdout?.call( + 'No tests found for shard ${optimization.shardIndex} in $path\n', + ); + await optimization.cleanUp(); + // The merge step downstream still expects a report from every + // shard, so leave an empty one behind. + if (collectCoverage) await lcovFile.create(recursive: true); + return ExitCode.success.code; + } + return await _overrideAnsiOutput( forceAnsi, () => @@ -425,6 +495,10 @@ class TestCLIRunner { } } +/// The exit code `dart test` and `flutter test` use when no test ran, for +/// example because `--exclude-tags` filtered out every test. +const _noTestsRanExitCode = 79; + Future _testCommand({ required void Function(String) stdout, required void Function(String) stderr, @@ -605,8 +679,14 @@ Future _testCommand({ unawaited(subscription.cancel()); unawaited(sigintWatchSubscription.cancel()); + // A shard can end up holding only tests that the given tags + // filter out, which is expected and not a failure. + final noTestsRanInShard = + optimization.shardIndex != null && + event.exitCode == _noTestsRanExitCode; + completer.complete( - event.exitCode == ExitCode.success.code + event.exitCode == ExitCode.success.code || noTestsRanInShard ? ExitCode.success.code : ExitCode.unavailable.code, ); diff --git a/lib/src/commands/dart/commands/dart_test_command.dart b/lib/src/commands/dart/commands/dart_test_command.dart index 3abd54465..ebcfbf509 100644 --- a/lib/src/commands/dart/commands/dart_test_command.dart +++ b/lib/src/commands/dart/commands/dart_test_command.dart @@ -31,6 +31,9 @@ class DartTestOptions { required this.runSkipped, required this.checkIgnore, required this.fileReporter, + required this.shardIndex, + required this.totalShards, + required this.rawMinCoverage, }); /// Parses [ArgResults] into a [DartTestOptions] instance. @@ -107,6 +110,9 @@ class DartTestOptions { 'file-reporter', testConfig.fileReporter, ); + final shardIndex = argResults['shard-index'] as String?; + final totalShards = argResults['total-shards'] as String?; + final rawMinCoverage = argResults['min-coverage'] as String?; final rest = argResults.rest; return DartTestOptions._( @@ -128,6 +134,9 @@ class DartTestOptions { runSkipped: runSkipped, checkIgnore: checkIgnore, fileReporter: fileReporter, + shardIndex: shardIndex, + totalShards: totalShards, + rawMinCoverage: rawMinCoverage, rest: rest, ); } @@ -188,6 +197,19 @@ class DartTestOptions { /// `:` (e.g. `json:reports/tests.json`). final String? fileReporter; + /// The raw `--shard-index` value, validated by + /// [TestCLIRunner.validateSharding]. + final String? shardIndex; + + /// The raw `--total-shards` value, validated by + /// [TestCLIRunner.validateSharding]. + final String? totalShards; + + /// The raw `--min-coverage` value, without the `very_good.yaml` fallback + /// that [minCoverage] applies, so sharding can reject an explicit threshold + /// while ignoring an inherited one. + final String? rawMinCoverage; + /// The remaining arguments passed to the `dart test` command. final List rest; @@ -224,6 +246,8 @@ typedef DartTestCommandCall = Future> Function({ void Function(String)? stderr, List? reportOn, bool checkIgnore, + int? shardIndex, + int? totalShards, }); /// {@template dart_test_command} @@ -366,6 +390,23 @@ class DartTestCommand extends Command { 'Enable an additional reporter writing test results to a file. ' 'Should be in the form : (e.g. "json:reports/tests.json").', valueHelp: 'name:path', + ) + ..addOption( + 'shard-index', + help: + 'The 1-based index of the shard to run. ' + 'Must be used together with --total-shards. ' + 'Requires optimization to be enabled. ' + 'When omitted, no sharding is applied.', + valueHelp: 'index', + ) + ..addOption( + 'total-shards', + help: + 'Split the test suite into this many shards and run only the one ' + 'selected by --shard-index. Useful to parallelize tests across ' + 'multiple CI runners. When omitted, no sharding is applied.', + valueHelp: 'count', ); } @@ -416,14 +457,26 @@ This command should be run from the root of your Dart project.'''); final options = DartTestOptions.parse(_argResults, config: config); + final shardingError = TestCLIRunner.validateSharding( + rawShardIndex: options.shardIndex, + rawTotalShards: options.totalShards, + rawMinCoverage: options.rawMinCoverage, + optimizePerformance: options.shouldOptimize, + ); + if (shardingError != null) { + _logger.err(shardingError); + return ExitCode.usage.code; + } + + // A threshold inherited from very_good.yaml only applies to un-sharded + // runs: a single shard covers a fraction of the code and would fail it. + final minCoverage = options.totalShards == null + ? options.minCoverage + : null; + try { final results = await _dartTest( - optimizePerformance: - options.optimizePerformance && - !TestCLIRunner.isTargettingTestFiles(options.rest) && - // Disabled optimization when platform is specified - // https://github.com/VeryGoodOpenSource/very_good_cli/issues/1363 - options.platform == null, + optimizePerformance: options.shouldOptimize, excludeOptimization: options.excludeOptimization, recursive: recursive, logger: _logger, @@ -431,9 +484,9 @@ This command should be run from the root of your Dart project.'''); stderr: _logger.err, collectCoverage: options.collectCoverage || - options.minCoverage != null || + minCoverage != null || options.showUncovered, - minCoverage: options.minCoverage, + minCoverage: minCoverage, showUncovered: options.showUncovered, excludeFromCoverage: options.excludeFromCoverage, collectCoverageFrom: options.collectCoverageFrom, @@ -452,6 +505,8 @@ This command should be run from the root of your Dart project.'''); ], reportOn: options.reportOn.isEmpty ? null : options.reportOn, checkIgnore: options.checkIgnore, + shardIndex: int.tryParse(options.shardIndex ?? ''), + totalShards: int.tryParse(options.totalShards ?? ''), ); if (results.any((code) => code != ExitCode.success.code)) { @@ -461,7 +516,7 @@ This command should be run from the root of your Dart project.'''); return TestCLIRunner.handleMinCoverageNotMet( error, logger: _logger, - minCoverage: options.minCoverage, + minCoverage: minCoverage, ); } on InvalidOptimizationGlob catch (error) { _logger.err('$error'); diff --git a/lib/src/commands/test/test.dart b/lib/src/commands/test/test.dart index f7280d913..8cbe2ea1f 100644 --- a/lib/src/commands/test/test.dart +++ b/lib/src/commands/test/test.dart @@ -34,6 +34,9 @@ class FlutterTestOptions { required this.flavor, required this.timeout, required this.fileReporter, + required this.shardIndex, + required this.totalShards, + required this.rawMinCoverage, required this.rest, }); @@ -129,6 +132,9 @@ class FlutterTestOptions { 'file-reporter', testConfig.fileReporter, ); + final shardIndex = argResults['shard-index'] as String?; + final totalShards = argResults['total-shards'] as String?; + final rawMinCoverage = argResults['min-coverage'] as String?; final rest = argResults.rest; return FlutterTestOptions._( @@ -154,6 +160,9 @@ class FlutterTestOptions { flavor: flavor, timeout: effectiveTimeout, fileReporter: fileReporter, + shardIndex: shardIndex, + totalShards: totalShards, + rawMinCoverage: rawMinCoverage, rest: rest, ); } @@ -227,6 +236,19 @@ class FlutterTestOptions { /// `:` (e.g. `json:reports/tests.json`). final String? fileReporter; + /// The raw `--shard-index` value, validated by + /// [TestCLIRunner.validateSharding]. + final String? shardIndex; + + /// The raw `--total-shards` value, validated by + /// [TestCLIRunner.validateSharding]. + final String? totalShards; + + /// The raw `--min-coverage` value, without the `very_good.yaml` fallback + /// that [minCoverage] applies, so sharding can reject an explicit threshold + /// while ignoring an inherited one. + final String? rawMinCoverage; + /// The remaining arguments passed to the test command. final List rest; @@ -265,6 +287,8 @@ typedef FlutterTestCommand = Future> Function({ void Function(String)? stdout, void Function(String)? stderr, List? reportOn, + int? shardIndex, + int? totalShards, }); /// {@template test_command} @@ -443,6 +467,23 @@ class TestCommand extends Command { 'Enable an additional reporter writing test results to a file. ' 'Should be in the form : (e.g. "json:reports/tests.json").', valueHelp: 'name:path', + ) + ..addOption( + 'shard-index', + help: + 'The 1-based index of the shard to run. ' + 'Must be used together with --total-shards. ' + 'Requires optimization to be enabled. ' + 'When omitted, no sharding is applied.', + valueHelp: 'index', + ) + ..addOption( + 'total-shards', + help: + 'Split the test suite into this many shards and run only the one ' + 'selected by --shard-index. Useful to parallelize tests across ' + 'multiple CI runners. When omitted, no sharding is applied.', + valueHelp: 'count', ); } @@ -495,15 +536,26 @@ This command should be run from the root of your Flutter project.'''); final options = FlutterTestOptions.parse(_argResults, config: config); + final shardingError = TestCLIRunner.validateSharding( + rawShardIndex: options.shardIndex, + rawTotalShards: options.totalShards, + rawMinCoverage: options.rawMinCoverage, + optimizePerformance: options.shouldOptimize, + ); + if (shardingError != null) { + _logger.err(shardingError); + return ExitCode.usage.code; + } + + // A threshold inherited from very_good.yaml only applies to un-sharded + // runs: a single shard covers a fraction of the code and would fail it. + final minCoverage = options.totalShards == null + ? options.minCoverage + : null; + try { final results = await _flutterTest( - optimizePerformance: - options.optimizePerformance && - !TestCLIRunner.isTargettingTestFiles(options.rest) && - !options.updateGoldens && - // Disabled optimization when platform is specified - // https://github.com/VeryGoodOpenSource/very_good_cli/issues/1363 - options.platform == null, + optimizePerformance: options.shouldOptimize, excludeOptimization: options.excludeOptimization, recursive: recursive, logger: _logger, @@ -511,15 +563,17 @@ This command should be run from the root of your Flutter project.'''); stderr: _logger.err, collectCoverage: options.collectCoverage || - options.minCoverage != null || + minCoverage != null || options.showUncovered, - minCoverage: options.minCoverage, + minCoverage: minCoverage, showUncovered: options.showUncovered, excludeFromCoverage: options.excludeFromCoverage, collectCoverageFrom: options.collectCoverageFrom, randomSeed: options.randomSeed, forceAnsi: options.forceAnsi, reportOn: options.reportOn.isEmpty ? null : options.reportOn, + shardIndex: int.tryParse(options.shardIndex ?? ''), + totalShards: int.tryParse(options.totalShards ?? ''), arguments: [ if (options.excludeTags != null) ...['-x', options.excludeTags!], if (options.tags != null) ...['-t', options.tags!], @@ -550,7 +604,7 @@ This command should be run from the root of your Flutter project.'''); return TestCLIRunner.handleMinCoverageNotMet( error, logger: _logger, - minCoverage: options.minCoverage, + minCoverage: minCoverage, ); } on InvalidOptimizationGlob catch (error) { _logger.err('$error'); diff --git a/lib/src/test_optimizer/test_optimizer.dart b/lib/src/test_optimizer/test_optimizer.dart index 0445a26c2..13befdb49 100644 --- a/lib/src/test_optimizer/test_optimizer.dart +++ b/lib/src/test_optimizer/test_optimizer.dart @@ -64,13 +64,23 @@ class TestOptimizer { required bool enabled, List? exclude, GeneratorBuilder buildGenerator = MasonGenerator.fromBundle, + int? shardIndex, + int? totalShards, }) : this._( enabled, (exclude ?? const []).map((str) => str.toGlob).toList(), buildGenerator, + shardIndex: shardIndex, + totalShards: totalShards, ); - const new _(this._enabled, this._exclusions, this._buildGenerator); + const new _( + this._enabled, + this._exclusions, + this._buildGenerator, { + this.shardIndex, + this.totalShards, + }); /// An optimizer that generates nothing and always yields /// [TestOptimization.none]. @@ -81,6 +91,15 @@ class TestOptimizer { final List _exclusions; final GeneratorBuilder _buildGenerator; + /// The 1-based shard to keep out of [totalShards], or `null` to keep every + /// test. The brick's pre-gen hook deals the sorted test files out + /// round-robin, so every shard holds a disjoint slice of the suite. + final int? shardIndex; + + /// The number of shards the suite is split into, or `null` when not + /// sharding. + final int? totalShards; + /// Generates the entrypoint for the package rooted at [packageRoot], which /// must be absolute: the brick's pre-gen hook resolves the package's `test` /// directory and `pubspec.yaml` from it. @@ -94,7 +113,11 @@ class TestOptimizer { if (!_enabled) return TestOptimization.none; final progress = logger.progress('Optimizing tests'); - var vars = {'package-root': packageRoot}; + var vars = { + 'package-root': packageRoot, + 'shard-index': ?shardIndex, + 'total-shards': ?totalShards, + }; try { final generator = await _buildGenerator(testOptimizerBundle); await generator.hooks.preGen( @@ -118,6 +141,7 @@ class TestOptimizer { return TestOptimization._( hasOptimizedTests, packageRoot: packageRoot, + shardIndex: shardIndex, serialTests: [ ...?(vars['notOptimizedTests'] as List?)?.map( (test) => test.toString(), @@ -163,6 +187,7 @@ class TestOptimization { const new _( this._hasOptimizedTests, { this.packageRoot, + this.shardIndex, this.serialTests = const [], }); @@ -176,15 +201,28 @@ class TestOptimization { /// Test files kept out of the bundle, which run as their own suites. final List serialTests; + /// The shard the bundle was generated for, or `null` when the run is not + /// sharded. + final int? shardIndex; + final bool _hasOptimizedTests; + /// Whether a sharded run ended up with nothing to do, which happens when + /// there are more shards than test files. That is not a failure: the runner + /// reports success instead of letting the test runner exit with "No tests + /// were found", which would fail the CI job. + bool get isEmptyShard => + shardIndex != null && !_hasOptimizedTests && serialTests.isEmpty; + /// The paths to append to the test runner's arguments, empty for [none]. List get testTargets { if (packageRoot == null) return const []; return [ if (_hasOptimizedTests || serialTests.isEmpty) p.join('test', testOptimizerFileName), - for (final test in serialTests) p.join('test', test), + // The hook emits POSIX paths; keep the argument native. + for (final test in serialTests) + p.joinAll(['test', ...p.posix.split(test)]), ]; } diff --git a/site/docs/commands/test.md b/site/docs/commands/test.md index a46c7a052..6c9447fff 100644 --- a/site/docs/commands/test.md +++ b/site/docs/commands/test.md @@ -52,6 +52,14 @@ very_good test [arguments] Useful when tests hang due to an unbounded pumpAndSettle() call. --file-reporter= Enable an additional reporter writing test results to a file. Should be in the form : (e.g. "json:reports/tests.json"). + --shard-index= The 1-based index of the shard to run. + Must be used together with --total-shards. + Requires optimization to be enabled. + When omitted, no sharding is applied. + --total-shards= Split the test suite into this many shards and run only the one + selected by --shard-index. + Useful to parallelize tests across multiple CI runners. + When omitted, no sharding is applied. Run "very_good help" to see global options. ``` @@ -75,6 +83,55 @@ For **Dart** projects, use **`very_good dart test`** instead. All test parameters and options work identically with this command. ::: +### Sharding tests across CI runners + +When the test phase is your CI bottleneck, split the suite across several +runners with `--shard-index` and `--total-shards`. Each runner generates its own +optimized entrypoint containing only its slice of the test files, so the shards +together run every test exactly once. + +```yaml +jobs: + test: + strategy: + matrix: + shard: [1, 2, 3] + steps: + - run: very_good test --shard-index ${{ matrix.shard }} --total-shards 3 +``` + +Test files are sorted and then dealt out round-robin, which keeps the partition +deterministic: the same suite always produces the same shards, on every machine. +Files kept out of the bundle, whether tagged `skip_very_good_optimization` or +matched by `--exclude-optimization`, are sharded as well, so they do not run on +every runner. + +A shard with no test files (more shards than test files) succeeds without +running anything, so an oversized matrix will not fail your build. The same +applies to a shard whose tests are all filtered out, for example by +`--exclude-tags golden` on a shard that only holds golden tests. + +When combined with `--recursive`, each package is sharded independently, so a +given runner executes a slice of every package. Balance therefore degrades when +a workspace contains many packages with few tests each. + +:::caution +Sharding cannot be combined with `--min-coverage`, and a `min_coverage` set in +`very_good.yaml` is ignored while sharding. Each shard only exercises a subset +of the codebase, so its coverage is not representative of the whole suite. +Collect coverage per shard with `--coverage`, merge the resulting lcov reports +once every shard has finished, and enforce the threshold on the merged report +in a separate job. A shard without tests still writes an empty +`coverage/lcov.info`; pass `--ignore-errors empty` to `lcov` when merging so it +is accepted. +::: + +:::info +Sharding requires the test optimizer, so it is rejected whenever the optimizer +is off: with `--no-optimization`, `--platform`, `--update-goldens`, or when +targeting specific test files. +::: + ### Passing Flutter specific arguments The `dart test` and `flutter test` commands expose more arguments than those available through `very_good dart test` or `very_good test`. However, you can use the argument terminator `--` to pass additional arguments directly to the underlying test commands. Any arguments after `--` will be forwarded to `dart test` or `flutter test`, making all their options available. diff --git a/test/src/cli/test_cli_runner_test.dart b/test/src/cli/test_cli_runner_test.dart index 0d49df490..e847bfc91 100644 --- a/test/src/cli/test_cli_runner_test.dart +++ b/test/src/cli/test_cli_runner_test.dart @@ -1135,6 +1135,298 @@ void main() { expect(testRunnerArgs, equals(['--coverage', '--coverage'])); }); + test('passes shard vars to the generator', () async { + final tempDirectory = Directory.systemTemp.createTempSync(); + addTearDown(() => tempDirectory.deleteSync(recursive: true)); + + File(p.join(tempDirectory.path, 'pubspec.yaml')).createSync(); + Directory(p.join(tempDirectory.path, 'test')).createSync(); + when( + () => hooks.preGen( + vars: any(named: 'vars'), + onVarsChanged: any(named: 'onVarsChanged'), + workingDirectory: any(named: 'workingDirectory'), + ), + ).thenAnswer((invocation) async { + (invocation.namedArguments[#onVarsChanged] + as void Function(Map vars)) + .call({ + 'package-root': tempDirectory.path, + 'tests': [ + {'path': 'a_test.dart', 'identifier': 'a'}, + ], + }); + }); + + await expectLater( + TestCLIRunner.test( + testType: TestRunType.flutter, + cwd: tempDirectory.path, + logger: logger, + stdout: stdoutLogs.add, + stderr: stderrLogs.add, + optimizer: TestOptimizer( + enabled: true, + buildGenerator: generatorBuilder(), + shardIndex: 2, + totalShards: 3, + ), + overrideTestRunner: testRunner( + Stream.fromIterable([ + const DoneTestEvent(success: true, time: 0), + const ExitTestEvent(exitCode: 0, time: 0), + ]), + ), + ), + completion(equals([ExitCode.success.code])), + ); + + verify( + () => hooks.preGen( + vars: { + 'package-root': tempDirectory.path, + 'shard-index': 2, + 'total-shards': 3, + }, + onVarsChanged: any(named: 'onVarsChanged'), + workingDirectory: tempDirectory.path, + ), + ).called(1); + }); + + test( + 'writes an empty lcov file for an empty shard with coverage', + () async { + final tempDirectory = Directory.systemTemp.createTempSync(); + addTearDown(() => tempDirectory.deleteSync(recursive: true)); + + File(p.join(tempDirectory.path, 'pubspec.yaml')).createSync(); + Directory(p.join(tempDirectory.path, 'test')).createSync(); + when( + () => hooks.preGen( + vars: any(named: 'vars'), + onVarsChanged: any(named: 'onVarsChanged'), + workingDirectory: any(named: 'workingDirectory'), + ), + ).thenAnswer((invocation) async { + (invocation.namedArguments[#onVarsChanged] + as void Function(Map vars)) + .call({ + 'package-root': tempDirectory.path, + 'tests': >[], + 'notOptimizedTests': [], + }); + }); + + await expectLater( + TestCLIRunner.test( + testType: TestRunType.flutter, + cwd: tempDirectory.path, + logger: logger, + stdout: stdoutLogs.add, + stderr: stderrLogs.add, + optimizer: TestOptimizer( + enabled: true, + buildGenerator: generatorBuilder(), + shardIndex: 3, + totalShards: 3, + ), + collectCoverage: true, + overrideTestRunner: testRunner(const Stream.empty()), + ), + completion(equals([ExitCode.success.code])), + ); + + final lcov = File( + p.join(tempDirectory.path, 'coverage', 'lcov.info'), + ); + expect(lcov.existsSync(), isTrue); + expect(lcov.lengthSync(), 0); + expect(testRunnerArgs, isEmpty); + }, + ); + + test('succeeds without running tests when the shard is empty', () async { + final tempDirectory = Directory.systemTemp.createTempSync(); + addTearDown(() => tempDirectory.deleteSync(recursive: true)); + + File(p.join(tempDirectory.path, 'pubspec.yaml')).createSync(); + Directory(p.join(tempDirectory.path, 'test')).createSync(); + when( + () => hooks.preGen( + vars: any(named: 'vars'), + onVarsChanged: any(named: 'onVarsChanged'), + workingDirectory: any(named: 'workingDirectory'), + ), + ).thenAnswer((invocation) async { + (invocation.namedArguments[#onVarsChanged] + as void Function(Map vars)) + .call({ + 'package-root': tempDirectory.path, + 'tests': >[], + 'notOptimizedTests': [], + }); + }); + + await expectLater( + TestCLIRunner.test( + testType: TestRunType.flutter, + cwd: tempDirectory.path, + logger: logger, + stdout: stdoutLogs.add, + stderr: stderrLogs.add, + optimizer: TestOptimizer( + enabled: true, + buildGenerator: generatorBuilder(), + shardIndex: 9, + totalShards: 9, + ), + overrideTestRunner: testRunner(const Stream.empty()), + ), + completion(equals([ExitCode.success.code])), + ); + + expect( + stdoutLogs, + equals([ + 'Running "flutter test" in . ...\n', + 'No tests found for shard 9 in .\n', + ]), + ); + expect(testRunnerArgs, isEmpty); + }); + + test( + 'runs the shard when it only contains non optimized tests', + () async { + final tempDirectory = Directory.systemTemp.createTempSync(); + addTearDown(() => tempDirectory.deleteSync(recursive: true)); + + File(p.join(tempDirectory.path, 'pubspec.yaml')).createSync(); + Directory(p.join(tempDirectory.path, 'test')).createSync(); + when( + () => hooks.preGen( + vars: any(named: 'vars'), + onVarsChanged: any(named: 'onVarsChanged'), + workingDirectory: any(named: 'workingDirectory'), + ), + ).thenAnswer((invocation) async { + (invocation.namedArguments[#onVarsChanged] + as void Function(Map vars)) + .call({ + 'package-root': tempDirectory.path, + 'tests': >[], + 'notOptimizedTests': ['skip0_test.dart'], + }); + }); + + await expectLater( + TestCLIRunner.test( + testType: TestRunType.flutter, + cwd: tempDirectory.path, + logger: logger, + stdout: stdoutLogs.add, + stderr: stderrLogs.add, + optimizer: TestOptimizer( + enabled: true, + buildGenerator: generatorBuilder(), + shardIndex: 2, + totalShards: 2, + ), + overrideTestRunner: testRunner( + Stream.fromIterable([ + const DoneTestEvent(success: true, time: 0), + const ExitTestEvent(exitCode: 0, time: 0), + ]), + ), + ), + completion(equals([ExitCode.success.code])), + ); + + expect(testRunnerArgs, contains(p.join('test', 'skip0_test.dart'))); + }, + ); + + group('when no tests ran', () { + // The exit code of `dart test` and `flutter test` when every test was + // filtered out, for example by `--exclude-tags`. + const noTestsRanExitCode = 79; + + late Directory tempDirectory; + + setUp(() { + tempDirectory = Directory.systemTemp.createTempSync(); + addTearDown(() => tempDirectory.deleteSync(recursive: true)); + + File(p.join(tempDirectory.path, 'pubspec.yaml')).createSync(); + Directory(p.join(tempDirectory.path, 'test')).createSync(); + when( + () => hooks.preGen( + vars: any(named: 'vars'), + onVarsChanged: any(named: 'onVarsChanged'), + workingDirectory: any(named: 'workingDirectory'), + ), + ).thenAnswer((invocation) async { + (invocation.namedArguments[#onVarsChanged] + as void Function(Map vars)) + .call({ + 'package-root': tempDirectory.path, + 'tests': [ + {'path': 'golden_test.dart', 'identifier': 'golden'}, + ], + }); + }); + }); + + test('succeeds when sharding', () async { + await expectLater( + TestCLIRunner.test( + testType: TestRunType.flutter, + cwd: tempDirectory.path, + logger: logger, + stdout: stdoutLogs.add, + stderr: stderrLogs.add, + optimizer: TestOptimizer( + enabled: true, + buildGenerator: generatorBuilder(), + shardIndex: 2, + totalShards: 3, + ), + arguments: ['--exclude-tags', 'golden'], + overrideTestRunner: testRunner( + Stream.fromIterable([ + const ExitTestEvent(exitCode: noTestsRanExitCode, time: 0), + ]), + ), + ), + completion(equals([ExitCode.success.code])), + ); + }); + + test('fails when not sharding', () async { + await expectLater( + TestCLIRunner.test( + testType: TestRunType.flutter, + cwd: tempDirectory.path, + logger: logger, + stdout: stdoutLogs.add, + stderr: stderrLogs.add, + optimizer: TestOptimizer( + enabled: true, + buildGenerator: generatorBuilder(), + ), + arguments: ['--exclude-tags', 'golden'], + overrideTestRunner: testRunner( + Stream.fromIterable([ + const ExitTestEvent(exitCode: noTestsRanExitCode, time: 0), + ]), + ), + ), + completion(equals([ExitCode.unavailable.code])), + ); + }); + }); + test('runs tests w/optimizations (passing)', () async { final tempDirectory = Directory.systemTemp.createTempSync(); addTearDown(() => tempDirectory.deleteSync(recursive: true)); @@ -1482,7 +1774,7 @@ void main() { testRunnerArgs, equals([ p.join('test', '.test_optimizer.dart'), - p.join('test', 'integration/login_test.dart'), + p.joinAll(['test', 'integration', 'login_test.dart']), ]), ); verify( @@ -1518,7 +1810,9 @@ void main() { expect( testRunnerArgs, - equals([p.join('test', 'app/view/app_test.dart')]), + equals([ + p.joinAll(['test', 'app', 'view', 'app_test.dart']), + ]), ); }, ); diff --git a/test/src/commands/dart/commands/dart_test_test.dart b/test/src/commands/dart/commands/dart_test_test.dart index de8fcfd2c..974fc0213 100644 --- a/test/src/commands/dart/commands/dart_test_test.dart +++ b/test/src/commands/dart/commands/dart_test_test.dart @@ -51,6 +51,8 @@ const expectedTestUsage = [ ' --[no-]check-ignore Whether to check for and respect coverage ignore comments (e.g. // coverage:ignore-line).\n' ' (defaults to on)\n' ' --file-reporter= Enable an additional reporter writing test results to a file. Should be in the form : (e.g. "json:reports/tests.json").\n' + ' --shard-index= The 1-based index of the shard to run. Must be used together with --total-shards. Requires optimization to be enabled. When omitted, no sharding is applied.\n' + ' --total-shards= Split the test suite into this many shards and run only the one selected by --shard-index. Useful to parallelize tests across multiple CI runners. When omitted, no sharding is applied.\n' '\n' 'Run "very_good help" to see global options.', ]; @@ -76,6 +78,8 @@ abstract class DartTestCommandCall { void Function(String)? stderr, bool? forceAnsi, List? reportOn, + int? shardIndex, + int? totalShards, }); } @@ -124,6 +128,8 @@ void main() { stderr: any(named: 'stderr'), forceAnsi: any(named: 'forceAnsi'), reportOn: any(named: 'reportOn'), + shardIndex: any(named: 'shardIndex'), + totalShards: any(named: 'totalShards'), ), ).thenAnswer((_) async => [0]); when(() => argResults['concurrency']).thenReturn(concurrency); @@ -135,6 +141,8 @@ void main() { when(() => argResults['run-skipped']).thenReturn(false); when(() => argResults['optimization']).thenReturn(true); when(() => argResults['platform']).thenReturn(null); + when(() => argResults['shard-index']).thenReturn(null); + when(() => argResults['total-shards']).thenReturn(null); when(() => argResults['collect-coverage-from']) .thenReturn('imports'); when(() => argResults['report-on']).thenReturn([]); @@ -917,6 +925,143 @@ void main() { ).called(1); }); + group('sharding', () { + void withShards(String? index, String? total) { + when(() => argResults['shard-index']).thenReturn(index); + when(() => argResults['total-shards']).thenReturn(total); + } + + test('forwards shard values to the test runner', () async { + withShards('2', '3'); + + final result = await testCommand.run(); + + expect(result, equals(ExitCode.success.code)); + verify( + () => dartTest( + shardIndex: 2, + totalShards: 3, + optimizePerformance: true, + arguments: defaultArguments, + logger: logger, + stdout: logger.write, + stderr: logger.err, + ), + ).called(1); + }); + + test('fails when only one shard option is provided', () async { + withShards('1', null); + + final result = await testCommand.run(); + + expect(result, equals(ExitCode.usage.code)); + verify( + () => logger.err( + '--shard-index and --total-shards must be used together.', + ), + ).called(1); + }); + + test('fails when --shard-index exceeds --total-shards', () async { + withShards('4', '3'); + + final result = await testCommand.run(); + + expect(result, equals(ExitCode.usage.code)); + verify( + () => logger.err( + '--shard-index (4) must be less than or equal to ' + '--total-shards (3).', + ), + ).called(1); + }); + + const optimizerDisabledError = + 'Sharding requires the test optimizer, which is disabled by ' + '--no-optimization, --platform, --update-goldens or by targeting ' + 'specific test files.'; + + test('fails when sharding with optimization disabled', () async { + withShards('1', '3'); + when(() => argResults['optimization']).thenReturn(false); + + final result = await testCommand.run(); + + expect(result, equals(ExitCode.usage.code)); + verify(() => logger.err(optimizerDisabledError)).called(1); + verifyNever(() => dartTest(shardIndex: 1, totalShards: 3)); + }); + + test('fails when sharding with --platform', () async { + withShards('1', '3'); + when(() => argResults['platform']).thenReturn('chrome'); + + final result = await testCommand.run(); + + expect(result, equals(ExitCode.usage.code)); + verify(() => logger.err(optimizerDisabledError)).called(1); + }); + + test('fails when sharding while targeting test files', () async { + withShards('1', '3'); + when(() => argResults.rest).thenReturn(['test/foo_test.dart']); + + final result = await testCommand.run(); + + expect(result, equals(ExitCode.usage.code)); + verify(() => logger.err(optimizerDisabledError)).called(1); + }); + + test( + 'ignores a min_coverage from very_good.yaml when sharding', + () async { + final tempDirectory = Directory.systemTemp.createTempSync(); + addTearDown(() { + Directory.current = cwd; + tempDirectory.deleteSync(recursive: true); + }); + Directory.current = tempDirectory.path; + File(path.join(tempDirectory.path, 'pubspec.yaml')).createSync(); + File(path.join(tempDirectory.path, 'very_good.yaml')) + .writeAsStringSync('dart:\n test:\n min_coverage: 90\n'); + when(() => argResults.wasParsed(any())).thenReturn(false); + withShards('1', '3'); + + final result = await testCommand.run(); + + expect(result, equals(ExitCode.success.code)); + verify( + () => dartTest( + shardIndex: 1, + totalShards: 3, + optimizePerformance: true, + arguments: defaultArguments, + logger: logger, + stdout: logger.write, + stderr: logger.err, + ), + ).called(1); + }, + ); + + test('fails when sharding is combined with --min-coverage', () async { + withShards('1', '3'); + when(() => argResults['min-coverage']).thenReturn('100'); + + final result = await testCommand.run(); + + expect(result, equals(ExitCode.usage.code)); + verify( + () => logger.err( + '--min-coverage cannot be combined with sharding. Collect ' + 'coverage per shard with --coverage, merge the lcov reports, ' + 'then check the threshold in a separate job.', + ), + ).called(1); + }); + }); + group('DartTestOptions.shouldOptimize', () { test('is true for a plain run', () { expect(DartTestOptions.parse(argResults).shouldOptimize, isTrue); @@ -1090,6 +1235,7 @@ void main() { ), ); expect(options.minCoverage, equals(50)); + expect(options.rawMinCoverage, equals('50')); }); test('CLI --file-reporter takes precedence over config value', () { diff --git a/test/src/commands/test/test_test.dart b/test/src/commands/test/test_test.dart index b7a369044..4233e6a40 100644 --- a/test/src/commands/test/test_test.dart +++ b/test/src/commands/test/test_test.dart @@ -54,6 +54,8 @@ const expectedTestUsage = [ ' --flavor Build a custom app flavor as defined by platform-specific build setup. Supports the use of product flavors in Android Gradle scripts, and the use of custom Xcode schemes.\n' ' --timeout= Maximum seconds to let tests run before killing the process. Useful when tests hang due to an unbounded pumpAndSettle() call.\n' ' --file-reporter= Enable an additional reporter writing test results to a file. Should be in the form : (e.g. "json:reports/tests.json").\n' + ' --shard-index= The 1-based index of the shard to run. Must be used together with --total-shards. Requires optimization to be enabled. When omitted, no sharding is applied.\n' + ' --total-shards= Split the test suite into this many shards and run only the one selected by --shard-index. Useful to parallelize tests across multiple CI runners. When omitted, no sharding is applied.\n' '\n' 'Run "very_good help" to see global options.', ]; @@ -78,6 +80,8 @@ abstract class FlutterTestCommand { void Function(String)? stderr, bool? forceAnsi, List? reportOn, + int? shardIndex, + int? totalShards, }); } @@ -125,6 +129,8 @@ void main() { stderr: any(named: 'stderr'), forceAnsi: any(named: 'forceAnsi'), reportOn: any(named: 'reportOn'), + shardIndex: any(named: 'shardIndex'), + totalShards: any(named: 'totalShards'), ), ).thenAnswer((_) async => [0]); when(() => argResults['concurrency']).thenReturn(concurrency); @@ -135,6 +141,8 @@ void main() { when(() => argResults['fail-fast']).thenReturn(false); when(() => argResults['optimization']).thenReturn(true); when(() => argResults['platform']).thenReturn(null); + when(() => argResults['shard-index']).thenReturn(null); + when(() => argResults['total-shards']).thenReturn(null); when(() => argResults['report-on']).thenReturn([]); when(() => argResults['run-skipped']).thenReturn(false); when(() => argResults['flavor']).thenReturn(null); @@ -1013,6 +1021,216 @@ void main() { ); }); + group('sharding', () { + void withShards(String? index, String? total) { + when(() => argResults['shard-index']).thenReturn(index); + when(() => argResults['total-shards']).thenReturn(total); + } + + test('forwards shard values to the test runner', () async { + withShards('2', '3'); + + final result = await testCommand.run(); + + expect(result, equals(ExitCode.success.code)); + verify( + () => flutterTest( + shardIndex: 2, + totalShards: 3, + optimizePerformance: true, + arguments: defaultArguments, + logger: logger, + stdout: logger.write, + stderr: logger.err, + ), + ).called(1); + }); + + test('does not forward shard values when not sharding', () async { + final result = await testCommand.run(); + + expect(result, equals(ExitCode.success.code)); + verify( + () => flutterTest( + optimizePerformance: true, + arguments: defaultArguments, + logger: logger, + stdout: logger.write, + stderr: logger.err, + ), + ).called(1); + }); + + test('fails when --shard-index is used without --total-shards', () async { + withShards('1', null); + + final result = await testCommand.run(); + + expect(result, equals(ExitCode.usage.code)); + verify( + () => logger.err( + '--shard-index and --total-shards must be used together.', + ), + ).called(1); + verifyNever( + () => flutterTest( + shardIndex: any(named: 'shardIndex'), + totalShards: any(named: 'totalShards'), + ), + ); + }); + + test('fails when --total-shards is used without --shard-index', () async { + withShards(null, '3'); + + final result = await testCommand.run(); + + expect(result, equals(ExitCode.usage.code)); + verify( + () => logger.err( + '--shard-index and --total-shards must be used together.', + ), + ).called(1); + }); + + test('fails when --shard-index exceeds --total-shards', () async { + withShards('4', '3'); + + final result = await testCommand.run(); + + expect(result, equals(ExitCode.usage.code)); + verify( + () => logger.err( + '--shard-index (4) must be less than or equal to ' + '--total-shards (3).', + ), + ).called(1); + }); + + test('fails when --shard-index is not a positive integer', () async { + withShards('0', '3'); + + final result = await testCommand.run(); + + expect(result, equals(ExitCode.usage.code)); + verify( + () => logger.err( + '--shard-index must be a positive integer, but got "0".', + ), + ).called(1); + }); + + test('fails when --shard-index is not a number', () async { + withShards('abc', '3'); + + final result = await testCommand.run(); + + expect(result, equals(ExitCode.usage.code)); + verify( + () => logger.err( + '--shard-index must be a positive integer, but got "abc".', + ), + ).called(1); + }); + + test('fails when --total-shards is not a positive integer', () async { + withShards('1', '0'); + + final result = await testCommand.run(); + + expect(result, equals(ExitCode.usage.code)); + verify( + () => logger.err( + '--total-shards must be a positive integer, but got "0".', + ), + ).called(1); + }); + + const optimizerDisabledError = + 'Sharding requires the test optimizer, which is disabled by ' + '--no-optimization, --platform, --update-goldens or by targeting ' + 'specific test files.'; + + test('fails when sharding with optimization disabled', () async { + withShards('1', '3'); + when(() => argResults['optimization']).thenReturn(false); + + final result = await testCommand.run(); + + expect(result, equals(ExitCode.usage.code)); + verify(() => logger.err(optimizerDisabledError)).called(1); + verifyNever(() => flutterTest(shardIndex: 1, totalShards: 3)); + }); + + test('fails when sharding with --platform', () async { + withShards('1', '3'); + when(() => argResults['platform']).thenReturn('chrome'); + + final result = await testCommand.run(); + + expect(result, equals(ExitCode.usage.code)); + verify(() => logger.err(optimizerDisabledError)).called(1); + }); + + test('fails when sharding with --update-goldens', () async { + withShards('1', '3'); + when(() => argResults['update-goldens']).thenReturn(true); + + final result = await testCommand.run(); + + expect(result, equals(ExitCode.usage.code)); + verify(() => logger.err(optimizerDisabledError)).called(1); + }); + + test( + 'ignores a min_coverage from very_good.yaml when sharding', + () async { + final tempDirectory = Directory.systemTemp.createTempSync(); + addTearDown(() { + Directory.current = cwd; + tempDirectory.deleteSync(recursive: true); + }); + Directory.current = tempDirectory.path; + File(path.join(tempDirectory.path, 'pubspec.yaml')).createSync(); + File(path.join(tempDirectory.path, 'very_good.yaml')) + .writeAsStringSync('test:\n min_coverage: 90\n'); + when(() => argResults.wasParsed(any())).thenReturn(false); + withShards('1', '3'); + + final result = await testCommand.run(); + + expect(result, equals(ExitCode.success.code)); + verify( + () => flutterTest( + shardIndex: 1, + totalShards: 3, + optimizePerformance: true, + arguments: defaultArguments, + logger: logger, + stdout: logger.write, + stderr: logger.err, + ), + ).called(1); + }, + ); + + test('fails when sharding is combined with --min-coverage', () async { + withShards('1', '3'); + when(() => argResults['min-coverage']).thenReturn('100'); + + final result = await testCommand.run(); + + expect(result, equals(ExitCode.usage.code)); + verify( + () => logger.err( + '--min-coverage cannot be combined with sharding. Collect ' + 'coverage per shard with --coverage, merge the lcov reports, ' + 'then check the threshold in a separate job.', + ), + ).called(1); + }); + }); + group('FlutterTestOptions.shouldOptimize', () { test('is true for a plain run', () { expect(FlutterTestOptions.parse(argResults).shouldOptimize, isTrue); @@ -1089,6 +1307,7 @@ void main() { ), ); expect(options.minCoverage, equals(90)); + expect(options.rawMinCoverage, isNull); expect(options.excludeFromCoverage, equals('**/*.g.dart')); expect(options.reportOn, equals(['lib/'])); expect(options.fileReporter, equals('json:reports/tests.json')); @@ -1106,6 +1325,7 @@ void main() { ), ); expect(options.minCoverage, equals(50)); + expect(options.rawMinCoverage, equals('50')); }); test('CLI --file-reporter takes precedence over config value', () { diff --git a/test/src/test_optimizer/test_optimizer_test.dart b/test/src/test_optimizer/test_optimizer_test.dart index d0afbc02b..85154bb71 100644 --- a/test/src/test_optimizer/test_optimizer_test.dart +++ b/test/src/test_optimizer/test_optimizer_test.dart @@ -180,6 +180,44 @@ void main() { expect(optimization.serialTests, equals(['tagged_test.dart'])); }); + test('forwards the shard to the hook', () async { + final optimization = await TestOptimizer( + enabled: true, + buildGenerator: (_) async => generator, + shardIndex: 2, + totalShards: 3, + ).apply(packageRoot: tempDirectory.path, logger: logger); + + verify( + () => hooks.preGen( + vars: { + 'package-root': tempDirectory.path, + 'shard-index': 2, + 'total-shards': 3, + }, + onVarsChanged: any(named: 'onVarsChanged'), + workingDirectory: tempDirectory.path, + ), + ).called(1); + expect(optimization.shardIndex, equals(2)); + }); + + test('leaves the shard vars out when not sharding', () async { + final optimization = await buildOptimizer().apply( + packageRoot: tempDirectory.path, + logger: logger, + ); + + verify( + () => hooks.preGen( + vars: {'package-root': tempDirectory.path}, + onVarsChanged: any(named: 'onVarsChanged'), + workingDirectory: tempDirectory.path, + ), + ).called(1); + expect(optimization.shardIndex, isNull); + }); + test('moves tests matching a glob out of the bundle', () async { preGenVars['tests'] = [ { @@ -275,6 +313,49 @@ void main() { }); }); + group('.isEmptyShard', () { + Future shard(int index) { + return TestOptimizer( + enabled: true, + buildGenerator: (_) async => generator, + shardIndex: index, + totalShards: 3, + ).apply(packageRoot: tempDirectory.path, logger: logger); + } + + test('is true when the shard holds no tests at all', () async { + preGenVars['tests'] = []; + + expect((await shard(3)).isEmptyShard, isTrue); + }); + + test('is false when the shard holds bundled tests', () async { + expect((await shard(1)).isEmptyShard, isFalse); + }); + + test('is false when the shard only holds tests kept out', () async { + preGenVars['tests'] = []; + preGenVars['notOptimizedTests'] = ['tagged_test.dart']; + + expect((await shard(2)).isEmptyShard, isFalse); + }); + + test('is false for an empty package that is not sharded', () async { + preGenVars['tests'] = []; + + final optimization = await buildOptimizer().apply( + packageRoot: tempDirectory.path, + logger: logger, + ); + + expect(optimization.isEmptyShard, isFalse); + }); + + test('is false when nothing was optimized', () { + expect(TestOptimization.none.isEmptyShard, isFalse); + }); + }); + group('.testTargets', () { Future optimize({List? exclude}) { return buildOptimizer(exclude: exclude) @@ -311,7 +392,9 @@ void main() { expect( (await optimize(exclude: const ['test/integration'])).testTargets, - equals([p.join('test', 'integration/login_test.dart')]), + equals([ + p.joinAll(['test', 'integration', 'login_test.dart']), + ]), ); });