| // Copyright 2013 The Flutter Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| import 'dart:async'; |
| import 'dart:io' as io; |
| |
| import 'package:args/command_runner.dart'; |
| import 'package:file/file.dart'; |
| import 'package:flutter_plugin_tools/src/common/core.dart'; |
| import 'package:flutter_plugin_tools/src/common/output_utils.dart'; |
| import 'package:flutter_plugin_tools/src/common/package_looping_command.dart'; |
| import 'package:git/git.dart'; |
| import 'package:test/test.dart'; |
| |
| import '../mocks.dart'; |
| import '../util.dart'; |
| |
| // Constants for colorized output start and end. |
| const String _startElapsedTimeColor = '\x1B[90m'; |
| const String _startErrorColor = '\x1B[31m'; |
| const String _startHeadingColor = '\x1B[36m'; |
| const String _startSkipColor = '\x1B[90m'; |
| const String _startSkipWithWarningColor = '\x1B[93m'; |
| const String _startSuccessColor = '\x1B[32m'; |
| const String _startWarningColor = '\x1B[33m'; |
| const String _endColor = '\x1B[0m'; |
| |
| // The filename within a package containing warnings to log during runForPackage. |
| enum _ResultFileType { |
| /// A file containing errors to return. |
| errors, |
| |
| /// A file containing warnings that should be logged. |
| warns, |
| |
| /// A file indicating that the package should be skipped, and why. |
| skips, |
| |
| /// A file indicating that the package should throw. |
| throws, |
| } |
| |
| // The filename within a package containing errors to return from runForPackage. |
| const String _errorFile = 'errors'; |
| // The filename within a package indicating that it should be skipped. |
| const String _skipFile = 'skip'; |
| // The filename within a package containing warnings to log during runForPackage. |
| const String _warningFile = 'warnings'; |
| // The filename within a package indicating that it should throw. |
| const String _throwFile = 'throw'; |
| |
| /// Writes a file to [package] to control the behavior of |
| /// [TestPackageLoopingCommand] for that package. |
| void _addResultFile( |
| RepositoryPackage package, |
| _ResultFileType type, { |
| String? contents, |
| }) { |
| final File file = package.directory.childFile(_filenameForType(type)); |
| file.createSync(); |
| if (contents != null) { |
| file.writeAsStringSync(contents); |
| } |
| } |
| |
| String _filenameForType(_ResultFileType type) { |
| switch (type) { |
| case _ResultFileType.errors: |
| return _errorFile; |
| case _ResultFileType.warns: |
| return _warningFile; |
| case _ResultFileType.skips: |
| return _skipFile; |
| case _ResultFileType.throws: |
| return _throwFile; |
| } |
| } |
| |
| void main() { |
| late MockPlatform mockPlatform; |
| late Directory packagesDir; |
| late Directory thirdPartyPackagesDir; |
| late GitDir gitDir; |
| late RecordingProcessRunner gitProcessRunner; |
| |
| setUp(() { |
| mockPlatform = MockPlatform(); |
| (:packagesDir, processRunner: _, :gitProcessRunner, :gitDir) = |
| configureBaseCommandMocks(platform: mockPlatform); |
| // Correct color handling is part of the behavior being tested here. |
| useColorForOutput = true; |
| thirdPartyPackagesDir = packagesDir.parent |
| .childDirectory('third_party') |
| .childDirectory('packages'); |
| }); |
| |
| tearDown(() { |
| // Restore the default behavior. |
| useColorForOutput = io.stdout.supportsAnsiEscapes; |
| }); |
| |
| /// Creates a TestPackageLoopingCommand with the given configuration. |
| TestPackageLoopingCommand createTestCommand({ |
| bool hasLongOutput = true, |
| PackageLoopingType packageLoopingType = PackageLoopingType.topLevelOnly, |
| bool failsDuringInit = false, |
| bool warnsDuringInit = false, |
| bool captureOutput = false, |
| String? customFailureListHeader, |
| String? customFailureListFooter, |
| }) { |
| return TestPackageLoopingCommand( |
| packagesDir, |
| platform: mockPlatform, |
| hasLongOutput: hasLongOutput, |
| packageLoopingType: packageLoopingType, |
| failsDuringInit: failsDuringInit, |
| warnsDuringInit: warnsDuringInit, |
| customFailureListHeader: customFailureListHeader, |
| customFailureListFooter: customFailureListFooter, |
| captureOutput: captureOutput, |
| gitDir: gitDir, |
| ); |
| } |
| |
| /// Runs [command] with the given [arguments], and returns its output. |
| Future<List<String>> runCommand( |
| TestPackageLoopingCommand command, { |
| List<String> arguments = const <String>[], |
| void Function(Error error)? errorHandler, |
| }) async { |
| late CommandRunner<void> runner; |
| runner = CommandRunner<void>( |
| 'test_package_looping_command', |
| 'Test for base package looping functionality', |
| ); |
| runner.addCommand(command); |
| return runCapturingPrint(runner, <String>[ |
| command.name, |
| ...arguments, |
| ], errorHandler: errorHandler); |
| } |
| |
| group('tool exit', () { |
| test('is handled during initializeRun', () async { |
| final TestPackageLoopingCommand command = createTestCommand( |
| failsDuringInit: true, |
| ); |
| |
| expect(() => runCommand(command), throwsA(isA<ToolExit>())); |
| }); |
| |
| test('does not stop looping on error', () async { |
| createFakePackage('package_a', packagesDir); |
| final RepositoryPackage failingPackage = createFakePlugin( |
| 'package_b', |
| packagesDir, |
| ); |
| createFakePackage('package_c', packagesDir); |
| _addResultFile(failingPackage, _ResultFileType.errors); |
| |
| final TestPackageLoopingCommand command = createTestCommand( |
| hasLongOutput: false, |
| ); |
| Error? commandError; |
| final List<String> output = await runCommand( |
| command, |
| errorHandler: (Error e) { |
| commandError = e; |
| }, |
| ); |
| |
| expect(commandError, isA<ToolExit>()); |
| expect( |
| output, |
| containsAllInOrder(<String>[ |
| '${_startHeadingColor}Running for package_a...$_endColor', |
| '${_startHeadingColor}Running for package_b...$_endColor', |
| '${_startHeadingColor}Running for package_c...$_endColor', |
| ]), |
| ); |
| }); |
| |
| test('does not stop looping on exceptions', () async { |
| createFakePackage('package_a', packagesDir); |
| final RepositoryPackage failingPackage = createFakePlugin( |
| 'package_b', |
| packagesDir, |
| ); |
| createFakePackage('package_c', packagesDir); |
| _addResultFile(failingPackage, _ResultFileType.throws); |
| |
| final TestPackageLoopingCommand command = createTestCommand( |
| hasLongOutput: false, |
| ); |
| Error? commandError; |
| final List<String> output = await runCommand( |
| command, |
| errorHandler: (Error e) { |
| commandError = e; |
| }, |
| ); |
| |
| expect(commandError, isA<ToolExit>()); |
| expect( |
| output, |
| containsAllInOrder(<String>[ |
| '${_startHeadingColor}Running for package_a...$_endColor', |
| '${_startHeadingColor}Running for package_b...$_endColor', |
| '${_startHeadingColor}Running for package_c...$_endColor', |
| ]), |
| ); |
| }); |
| }); |
| |
| group('file filtering', () { |
| test('runs command if the changed files list is empty', () async { |
| createFakePackage('package_a', packagesDir); |
| |
| gitProcessRunner.mockProcessesForExecutable['git-diff'] = |
| <FakeProcessInfo>[FakeProcessInfo(MockProcess(stdout: ''))]; |
| |
| final TestPackageLoopingCommand command = createTestCommand( |
| hasLongOutput: false, |
| ); |
| final List<String> output = await runCommand(command); |
| |
| expect( |
| output, |
| containsAllInOrder(<String>[ |
| '${_startHeadingColor}Running for package_a...$_endColor', |
| ]), |
| ); |
| }); |
| |
| test('runs command if any files are not ignored', () async { |
| createFakePackage('package_a', packagesDir); |
| |
| gitProcessRunner.mockProcessesForExecutable['git-diff'] = |
| <FakeProcessInfo>[ |
| FakeProcessInfo( |
| MockProcess( |
| stdout: ''' |
| skip/a |
| other |
| skip/b |
| ''', |
| ), |
| ), |
| ]; |
| |
| final TestPackageLoopingCommand command = createTestCommand( |
| hasLongOutput: false, |
| ); |
| final List<String> output = await runCommand(command); |
| |
| expect( |
| output, |
| containsAllInOrder(<String>[ |
| '${_startHeadingColor}Running for package_a...$_endColor', |
| ]), |
| ); |
| }); |
| |
| test('skips commands if all files should be ignored', () async { |
| createFakePackage('package_a', packagesDir); |
| |
| gitProcessRunner.mockProcessesForExecutable['git-diff'] = |
| <FakeProcessInfo>[ |
| FakeProcessInfo( |
| MockProcess( |
| stdout: ''' |
| skip/a |
| skip/b |
| ''', |
| ), |
| ), |
| ]; |
| |
| final TestPackageLoopingCommand command = createTestCommand( |
| hasLongOutput: false, |
| ); |
| final List<String> output = await runCommand(command); |
| |
| expect( |
| output, |
| isNot(containsAllInOrder(<Matcher>[contains('Running for package_a')])), |
| ); |
| expect( |
| output, |
| containsAllInOrder(<String>[ |
| '${_startSkipColor}SKIPPING ALL PACKAGES: No changed files affect this command$_endColor', |
| ]), |
| ); |
| }); |
| }); |
| |
| group('package iteration', () { |
| test('includes plugins and packages', () async { |
| final RepositoryPackage plugin = createFakePlugin( |
| 'a_plugin', |
| packagesDir, |
| ); |
| final RepositoryPackage package = createFakePackage( |
| 'a_package', |
| packagesDir, |
| ); |
| |
| final TestPackageLoopingCommand command = createTestCommand(); |
| await runCommand(command); |
| |
| expect( |
| command.checkedPackages, |
| unorderedEquals(<String>[plugin.path, package.path]), |
| ); |
| }); |
| |
| test('includes third_party/packages', () async { |
| final RepositoryPackage package1 = createFakePackage( |
| 'a_package', |
| packagesDir, |
| ); |
| final RepositoryPackage package2 = createFakePackage( |
| 'another_package', |
| thirdPartyPackagesDir, |
| ); |
| |
| final TestPackageLoopingCommand command = createTestCommand(); |
| await runCommand(command); |
| |
| expect( |
| command.checkedPackages, |
| unorderedEquals(<String>[package1.path, package2.path]), |
| ); |
| }); |
| |
| test('includes all subpackages when requested', () async { |
| final RepositoryPackage plugin = createFakePlugin( |
| 'a_plugin', |
| packagesDir, |
| examples: <String>['example1', 'example2'], |
| ); |
| final RepositoryPackage package = createFakePackage( |
| 'a_package', |
| packagesDir, |
| ); |
| final RepositoryPackage subPackage = createFakePackage( |
| 'sub_package', |
| package.directory, |
| examples: <String>[], |
| ); |
| |
| final TestPackageLoopingCommand command = createTestCommand( |
| packageLoopingType: PackageLoopingType.includeAllSubpackages, |
| ); |
| await runCommand(command); |
| |
| expect( |
| command.checkedPackages, |
| unorderedEquals(<String>[ |
| plugin.path, |
| getExampleDir(plugin).childDirectory('example1').path, |
| getExampleDir(plugin).childDirectory('example2').path, |
| package.path, |
| getExampleDir(package).path, |
| subPackage.path, |
| ]), |
| ); |
| }); |
| |
| test('includes examples when requested', () async { |
| final RepositoryPackage plugin = createFakePlugin( |
| 'a_plugin', |
| packagesDir, |
| examples: <String>['example1', 'example2'], |
| ); |
| final RepositoryPackage package = createFakePackage( |
| 'a_package', |
| packagesDir, |
| ); |
| final RepositoryPackage subPackage = createFakePackage( |
| 'sub_package', |
| package.directory, |
| ); |
| |
| final TestPackageLoopingCommand command = createTestCommand( |
| packageLoopingType: PackageLoopingType.includeExamples, |
| ); |
| await runCommand(command); |
| |
| expect( |
| command.checkedPackages, |
| unorderedEquals(<String>[ |
| plugin.path, |
| getExampleDir(plugin).childDirectory('example1').path, |
| getExampleDir(plugin).childDirectory('example2').path, |
| package.path, |
| getExampleDir(package).path, |
| ]), |
| ); |
| expect(command.checkedPackages, isNot(contains(subPackage.path))); |
| }); |
| |
| test('excludes subpackages when main package is excluded', () async { |
| final RepositoryPackage excluded = createFakePlugin( |
| 'a_plugin', |
| packagesDir, |
| examples: <String>['example1', 'example2'], |
| ); |
| final RepositoryPackage included = createFakePackage( |
| 'a_package', |
| packagesDir, |
| ); |
| final RepositoryPackage subpackage = createFakePackage( |
| 'sub_package', |
| excluded.directory, |
| ); |
| |
| final TestPackageLoopingCommand command = createTestCommand( |
| packageLoopingType: PackageLoopingType.includeAllSubpackages, |
| ); |
| await runCommand(command, arguments: <String>['--exclude=a_plugin']); |
| |
| final Iterable<RepositoryPackage> examples = excluded.getExamples(); |
| |
| expect( |
| command.checkedPackages, |
| unorderedEquals(<String>[included.path, getExampleDir(included).path]), |
| ); |
| expect(command.checkedPackages, isNot(contains(excluded.path))); |
| expect(examples.length, 2); |
| for (final example in examples) { |
| expect(command.checkedPackages, isNot(contains(example.path))); |
| } |
| expect(command.checkedPackages, isNot(contains(subpackage.path))); |
| }); |
| |
| test('excludes examples when main package is excluded', () async { |
| final RepositoryPackage excluded = createFakePlugin( |
| 'a_plugin', |
| packagesDir, |
| examples: <String>['example1', 'example2'], |
| ); |
| final RepositoryPackage included = createFakePackage( |
| 'a_package', |
| packagesDir, |
| ); |
| |
| final TestPackageLoopingCommand command = createTestCommand( |
| packageLoopingType: PackageLoopingType.includeExamples, |
| ); |
| await runCommand(command, arguments: <String>['--exclude=a_plugin']); |
| |
| final Iterable<RepositoryPackage> examples = excluded.getExamples(); |
| |
| expect( |
| command.checkedPackages, |
| unorderedEquals(<String>[included.path, getExampleDir(included).path]), |
| ); |
| expect(command.checkedPackages, isNot(contains(excluded.path))); |
| expect(examples.length, 2); |
| for (final example in examples) { |
| expect(command.checkedPackages, isNot(contains(example.path))); |
| } |
| }); |
| |
| test('skips unsupported Flutter versions when requested', () async { |
| final RepositoryPackage excluded = createFakePlugin( |
| 'a_plugin', |
| packagesDir, |
| flutterConstraint: '>=2.10.0', |
| ); |
| final RepositoryPackage included = createFakePackage( |
| 'a_package', |
| packagesDir, |
| ); |
| |
| final TestPackageLoopingCommand command = createTestCommand( |
| packageLoopingType: PackageLoopingType.includeAllSubpackages, |
| hasLongOutput: false, |
| ); |
| final List<String> output = await runCommand( |
| command, |
| arguments: <String>['--skip-if-not-supporting-flutter-version=2.5.0'], |
| ); |
| |
| expect( |
| command.checkedPackages, |
| unorderedEquals(<String>[included.path, getExampleDir(included).path]), |
| ); |
| expect(command.checkedPackages, isNot(contains(excluded.path))); |
| |
| expect( |
| output, |
| containsAllInOrder(<String>[ |
| '${_startHeadingColor}Running for a_package...$_endColor', |
| '${_startHeadingColor}Running for a_plugin...$_endColor', |
| '$_startSkipColor SKIPPING: Does not support Flutter 2.5.0$_endColor', |
| ]), |
| ); |
| }); |
| |
| test('skips unsupported Dart versions when requested', () async { |
| final RepositoryPackage excluded = createFakePackage( |
| 'excluded_package', |
| packagesDir, |
| dartConstraint: '>=2.18.0 <4.0.0', |
| ); |
| final RepositoryPackage included = createFakePackage( |
| 'a_package', |
| packagesDir, |
| ); |
| |
| final TestPackageLoopingCommand command = createTestCommand( |
| packageLoopingType: PackageLoopingType.includeAllSubpackages, |
| hasLongOutput: false, |
| ); |
| final List<String> output = await runCommand( |
| command, |
| arguments: <String>[ |
| '--skip-if-not-supporting-flutter-version=3.0.0', // Flutter 3.0.0 -> Dart 2.17.0 |
| ], |
| ); |
| |
| expect( |
| command.checkedPackages, |
| unorderedEquals(<String>[included.path, getExampleDir(included).path]), |
| ); |
| expect(command.checkedPackages, isNot(contains(excluded.path))); |
| |
| expect( |
| output, |
| containsAllInOrder(<String>[ |
| '${_startHeadingColor}Running for a_package...$_endColor', |
| '${_startHeadingColor}Running for excluded_package...$_endColor', |
| '$_startSkipColor SKIPPING: Does not support Dart 2.17.0$_endColor', |
| ]), |
| ); |
| }); |
| }); |
| |
| group('output', () { |
| test('has the expected package headers for long-form output', () async { |
| createFakePlugin('package_a', packagesDir); |
| createFakePackage('package_b', packagesDir); |
| |
| final TestPackageLoopingCommand command = createTestCommand(); |
| final List<String> output = await runCommand(command); |
| |
| const separator = |
| '============================================================'; |
| expect( |
| output, |
| containsAllInOrder(<String>[ |
| '$_startHeadingColor\n$separator\n|| Running for package_a\n$separator\n$_endColor', |
| '$_startHeadingColor\n$separator\n|| Running for package_b\n$separator\n$_endColor', |
| ]), |
| ); |
| }); |
| |
| test('has the expected package headers for short-form output', () async { |
| createFakePlugin('package_a', packagesDir); |
| createFakePackage('package_b', packagesDir); |
| |
| final TestPackageLoopingCommand command = createTestCommand( |
| hasLongOutput: false, |
| ); |
| final List<String> output = await runCommand(command); |
| |
| expect( |
| output, |
| containsAllInOrder(<String>[ |
| '${_startHeadingColor}Running for package_a...$_endColor', |
| '${_startHeadingColor}Running for package_b...$_endColor', |
| ]), |
| ); |
| }); |
| |
| test('prints timing info in long-form output when requested', () async { |
| createFakePlugin('package_a', packagesDir); |
| createFakePackage('package_b', packagesDir); |
| |
| final TestPackageLoopingCommand command = createTestCommand(); |
| final List<String> output = await runCommand( |
| command, |
| arguments: <String>['--log-timing'], |
| ); |
| |
| const separator = |
| '============================================================'; |
| expect( |
| output, |
| containsAllInOrder(<String>[ |
| '$_startHeadingColor\n$separator\n|| Running for package_a [@0:00]\n$separator\n$_endColor', |
| '$_startElapsedTimeColor\n[package_a completed in 0m 0s]$_endColor', |
| '$_startHeadingColor\n$separator\n|| Running for package_b [@0:00]\n$separator\n$_endColor', |
| '$_startElapsedTimeColor\n[package_b completed in 0m 0s]$_endColor', |
| ]), |
| ); |
| }); |
| |
| test('prints timing info in short-form output when requested', () async { |
| createFakePlugin('package_a', packagesDir); |
| createFakePackage('package_b', packagesDir); |
| |
| final TestPackageLoopingCommand command = createTestCommand( |
| hasLongOutput: false, |
| ); |
| final List<String> output = await runCommand( |
| command, |
| arguments: <String>['--log-timing'], |
| ); |
| |
| expect( |
| output, |
| containsAllInOrder(<String>[ |
| '$_startHeadingColor[0:00] Running for package_a...$_endColor', |
| '$_startHeadingColor[0:00] Running for package_b...$_endColor', |
| ]), |
| ); |
| // Short-form output should not include elapsed time. |
| expect(output, isNot(contains('[package_a completed in 0m 0s]'))); |
| }); |
| |
| test('shows the success message when nothing fails', () async { |
| createFakePackage('package_a', packagesDir); |
| createFakePackage('package_b', packagesDir); |
| |
| final TestPackageLoopingCommand command = createTestCommand( |
| hasLongOutput: false, |
| ); |
| final List<String> output = await runCommand(command); |
| |
| expect( |
| output, |
| containsAllInOrder(<String>[ |
| '\n', |
| '${_startSuccessColor}No issues found!$_endColor', |
| ]), |
| ); |
| }); |
| |
| test( |
| 'shows failure summaries when something fails without extra details', |
| () async { |
| createFakePackage('package_a', packagesDir); |
| final RepositoryPackage failingPackage1 = createFakePlugin( |
| 'package_b', |
| packagesDir, |
| ); |
| createFakePackage('package_c', packagesDir); |
| final RepositoryPackage failingPackage2 = createFakePlugin( |
| 'package_d', |
| packagesDir, |
| ); |
| _addResultFile(failingPackage1, _ResultFileType.errors); |
| _addResultFile(failingPackage2, _ResultFileType.errors); |
| |
| final TestPackageLoopingCommand command = createTestCommand( |
| hasLongOutput: false, |
| ); |
| Error? commandError; |
| final List<String> output = await runCommand( |
| command, |
| errorHandler: (Error e) { |
| commandError = e; |
| }, |
| ); |
| |
| expect(commandError, isA<ToolExit>()); |
| expect( |
| output, |
| containsAllInOrder(<String>[ |
| '\n', |
| '${_startErrorColor}The following packages had errors:$_endColor', |
| '$_startErrorColor package_b$_endColor', |
| '$_startErrorColor package_d$_endColor', |
| '${_startErrorColor}See above for full details.$_endColor', |
| ]), |
| ); |
| }, |
| ); |
| |
| test('uses custom summary header and footer if provided', () async { |
| createFakePackage('package_a', packagesDir); |
| final RepositoryPackage failingPackage1 = createFakePlugin( |
| 'package_b', |
| packagesDir, |
| ); |
| createFakePackage('package_c', packagesDir); |
| final RepositoryPackage failingPackage2 = createFakePlugin( |
| 'package_d', |
| packagesDir, |
| ); |
| _addResultFile(failingPackage1, _ResultFileType.errors); |
| _addResultFile(failingPackage2, _ResultFileType.errors); |
| |
| final TestPackageLoopingCommand command = createTestCommand( |
| hasLongOutput: false, |
| customFailureListHeader: 'This is a custom header', |
| customFailureListFooter: 'And a custom footer!', |
| ); |
| Error? commandError; |
| final List<String> output = await runCommand( |
| command, |
| errorHandler: (Error e) { |
| commandError = e; |
| }, |
| ); |
| |
| expect(commandError, isA<ToolExit>()); |
| expect( |
| output, |
| containsAllInOrder(<String>[ |
| '\n', |
| '${_startErrorColor}This is a custom header$_endColor', |
| '$_startErrorColor package_b$_endColor', |
| '$_startErrorColor package_d$_endColor', |
| '${_startErrorColor}And a custom footer!$_endColor', |
| ]), |
| ); |
| }); |
| |
| test( |
| 'shows failure summaries when something fails with extra details', |
| () async { |
| createFakePackage('package_a', packagesDir); |
| final RepositoryPackage failingPackage1 = createFakePlugin( |
| 'package_b', |
| packagesDir, |
| ); |
| createFakePackage('package_c', packagesDir); |
| final RepositoryPackage failingPackage2 = createFakePlugin( |
| 'package_d', |
| packagesDir, |
| ); |
| _addResultFile( |
| failingPackage1, |
| _ResultFileType.errors, |
| contents: 'just one detail', |
| ); |
| _addResultFile( |
| failingPackage2, |
| _ResultFileType.errors, |
| contents: 'first detail\nsecond detail', |
| ); |
| |
| final TestPackageLoopingCommand command = createTestCommand( |
| hasLongOutput: false, |
| ); |
| Error? commandError; |
| final List<String> output = await runCommand( |
| command, |
| errorHandler: (Error e) { |
| commandError = e; |
| }, |
| ); |
| |
| expect(commandError, isA<ToolExit>()); |
| expect( |
| output, |
| containsAllInOrder(<String>[ |
| '\n', |
| '${_startErrorColor}The following packages had errors:$_endColor', |
| '$_startErrorColor package_b:\n just one detail$_endColor', |
| '$_startErrorColor package_d:\n first detail\n second detail$_endColor', |
| '${_startErrorColor}See above for full details.$_endColor', |
| ]), |
| ); |
| }, |
| ); |
| |
| test('is captured, not printed, when requested', () async { |
| createFakePlugin('package_a', packagesDir); |
| createFakePackage('package_b', packagesDir); |
| |
| final TestPackageLoopingCommand command = createTestCommand( |
| captureOutput: true, |
| ); |
| final List<String> output = await runCommand(command); |
| |
| expect(output, isEmpty); |
| |
| // None of the output should be colorized when captured. |
| const separator = |
| '============================================================'; |
| expect( |
| command.capturedOutput, |
| containsAllInOrder(<String>[ |
| '\n$separator\n|| Running for package_a\n$separator\n', |
| '\n$separator\n|| Running for package_b\n$separator\n', |
| 'No issues found!', |
| ]), |
| ); |
| }); |
| |
| test('logs skips', () async { |
| createFakePackage('package_a', packagesDir); |
| final RepositoryPackage skipPackage = createFakePackage( |
| 'package_b', |
| packagesDir, |
| ); |
| _addResultFile( |
| skipPackage, |
| _ResultFileType.skips, |
| contents: 'For a reason', |
| ); |
| |
| final TestPackageLoopingCommand command = createTestCommand( |
| hasLongOutput: false, |
| ); |
| final List<String> output = await runCommand(command); |
| |
| expect( |
| output, |
| containsAllInOrder(<String>[ |
| '${_startHeadingColor}Running for package_a...$_endColor', |
| '${_startHeadingColor}Running for package_b...$_endColor', |
| '$_startSkipColor SKIPPING: For a reason$_endColor', |
| ]), |
| ); |
| }); |
| |
| test('logs exclusions', () async { |
| createFakePackage('package_a', packagesDir); |
| createFakePackage('package_b', packagesDir); |
| |
| final TestPackageLoopingCommand command = createTestCommand( |
| hasLongOutput: false, |
| ); |
| final List<String> output = await runCommand( |
| command, |
| arguments: <String>['--exclude=package_b'], |
| ); |
| |
| expect( |
| output, |
| containsAllInOrder(<String>[ |
| '${_startHeadingColor}Running for package_a...$_endColor', |
| '${_startSkipColor}Not running for package_b; excluded$_endColor', |
| ]), |
| ); |
| }); |
| |
| test('logs warnings', () async { |
| final RepositoryPackage warnPackage = createFakePackage( |
| 'package_a', |
| packagesDir, |
| ); |
| _addResultFile( |
| warnPackage, |
| _ResultFileType.warns, |
| contents: 'Warning 1\nWarning 2', |
| ); |
| createFakePackage('package_b', packagesDir); |
| |
| final TestPackageLoopingCommand command = createTestCommand( |
| hasLongOutput: false, |
| ); |
| final List<String> output = await runCommand(command); |
| |
| expect( |
| output, |
| containsAllInOrder(<String>[ |
| '${_startHeadingColor}Running for package_a...$_endColor', |
| '${_startWarningColor}Warning 1$_endColor', |
| '${_startWarningColor}Warning 2$_endColor', |
| '${_startHeadingColor}Running for package_b...$_endColor', |
| ]), |
| ); |
| }); |
| |
| test('logs unhandled exceptions as errors', () async { |
| createFakePackage('package_a', packagesDir); |
| final RepositoryPackage failingPackage = createFakePlugin( |
| 'package_b', |
| packagesDir, |
| ); |
| createFakePackage('package_c', packagesDir); |
| _addResultFile(failingPackage, _ResultFileType.throws); |
| |
| final TestPackageLoopingCommand command = createTestCommand( |
| hasLongOutput: false, |
| ); |
| Error? commandError; |
| final List<String> output = await runCommand( |
| command, |
| errorHandler: (Error e) { |
| commandError = e; |
| }, |
| ); |
| |
| expect(commandError, isA<ToolExit>()); |
| expect( |
| output, |
| containsAllInOrder(<String>[ |
| '${_startErrorColor}Exception: Uh-oh$_endColor', |
| '${_startErrorColor}The following packages had errors:$_endColor', |
| '$_startErrorColor package_b:\n Unhandled exception$_endColor', |
| ]), |
| ); |
| }); |
| |
| test('prints run summary on success', () async { |
| final RepositoryPackage warnPackage1 = createFakePackage( |
| 'package_a', |
| packagesDir, |
| ); |
| _addResultFile( |
| warnPackage1, |
| _ResultFileType.warns, |
| contents: 'Warning 1\nWarning 2', |
| ); |
| |
| createFakePackage('package_b', packagesDir); |
| |
| final RepositoryPackage skipPackage = createFakePackage( |
| 'package_c', |
| packagesDir, |
| ); |
| _addResultFile( |
| skipPackage, |
| _ResultFileType.skips, |
| contents: 'For a reason', |
| ); |
| |
| final RepositoryPackage skipAndWarnPackage = createFakePackage( |
| 'package_d', |
| packagesDir, |
| ); |
| _addResultFile( |
| skipAndWarnPackage, |
| _ResultFileType.warns, |
| contents: 'Warning', |
| ); |
| _addResultFile( |
| skipAndWarnPackage, |
| _ResultFileType.skips, |
| contents: 'See warning', |
| ); |
| |
| final RepositoryPackage warnPackage2 = createFakePackage( |
| 'package_e', |
| packagesDir, |
| ); |
| _addResultFile( |
| warnPackage2, |
| _ResultFileType.warns, |
| contents: 'Warning 1\nWarning 2', |
| ); |
| |
| createFakePackage('package_f', packagesDir); |
| |
| final TestPackageLoopingCommand command = createTestCommand( |
| hasLongOutput: false, |
| ); |
| final List<String> output = await runCommand(command); |
| |
| expect( |
| output, |
| containsAllInOrder(<String>[ |
| '------------------------------------------------------------', |
| 'Ran for 4 package(s) (2 with warnings)', |
| 'Skipped 2 package(s) (1 with warnings)', |
| '\n', |
| '${_startSuccessColor}No issues found!$_endColor', |
| ]), |
| ); |
| // The long-form summary should not be printed for short-form commands. |
| expect(output, isNot(contains('Run summary:'))); |
| expect(output, isNot(contains(contains('package a - ran')))); |
| }); |
| |
| test('counts exclusions as skips in run summary', () async { |
| createFakePackage('package_a', packagesDir); |
| |
| final TestPackageLoopingCommand command = createTestCommand( |
| hasLongOutput: false, |
| ); |
| final List<String> output = await runCommand( |
| command, |
| arguments: <String>['--exclude=package_a'], |
| ); |
| |
| expect( |
| output, |
| containsAllInOrder(<String>[ |
| '------------------------------------------------------------', |
| 'Skipped 1 package(s)', |
| '\n', |
| '${_startSuccessColor}No issues found!$_endColor', |
| ]), |
| ); |
| }); |
| |
| test('prints long-form run summary for long-output commands', () async { |
| final RepositoryPackage warnPackage1 = createFakePackage( |
| 'package_a', |
| packagesDir, |
| ); |
| _addResultFile( |
| warnPackage1, |
| _ResultFileType.warns, |
| contents: 'Warning 1\nWarning 2', |
| ); |
| |
| createFakePackage('package_b', packagesDir); |
| |
| final RepositoryPackage skipPackage = createFakePackage( |
| 'package_c', |
| packagesDir, |
| ); |
| _addResultFile( |
| skipPackage, |
| _ResultFileType.skips, |
| contents: 'For a reason', |
| ); |
| |
| final RepositoryPackage skipAndWarnPackage = createFakePackage( |
| 'package_d', |
| packagesDir, |
| ); |
| _addResultFile( |
| skipAndWarnPackage, |
| _ResultFileType.warns, |
| contents: 'Warning', |
| ); |
| _addResultFile( |
| skipAndWarnPackage, |
| _ResultFileType.skips, |
| contents: 'See warning', |
| ); |
| |
| final RepositoryPackage warnPackage2 = createFakePackage( |
| 'package_e', |
| packagesDir, |
| ); |
| _addResultFile( |
| warnPackage2, |
| _ResultFileType.warns, |
| contents: 'Warning 1\nWarning 2', |
| ); |
| |
| createFakePackage('package_f', packagesDir); |
| |
| final TestPackageLoopingCommand command = createTestCommand(); |
| final List<String> output = await runCommand(command); |
| |
| expect( |
| output, |
| containsAllInOrder(<String>[ |
| '------------------------------------------------------------', |
| 'Run overview:', |
| ' package_a - ${_startWarningColor}ran (with warning)$_endColor', |
| ' package_b - ${_startSuccessColor}ran$_endColor', |
| ' package_c - ${_startSkipColor}skipped$_endColor', |
| ' package_d - ${_startSkipWithWarningColor}skipped (with warning)$_endColor', |
| ' package_e - ${_startWarningColor}ran (with warning)$_endColor', |
| ' package_f - ${_startSuccessColor}ran$_endColor', |
| '', |
| 'Ran for 4 package(s) (2 with warnings)', |
| 'Skipped 2 package(s) (1 with warnings)', |
| '\n', |
| '${_startSuccessColor}No issues found!$_endColor', |
| ]), |
| ); |
| }); |
| |
| test('prints exclusions as skips in long-form run summary', () async { |
| createFakePackage('package_a', packagesDir); |
| |
| final TestPackageLoopingCommand command = createTestCommand(); |
| final List<String> output = await runCommand( |
| command, |
| arguments: <String>['--exclude=package_a'], |
| ); |
| |
| expect( |
| output, |
| containsAllInOrder(<String>[ |
| ' package_a - ${_startSkipColor}excluded$_endColor', |
| '', |
| 'Skipped 1 package(s)', |
| '\n', |
| '${_startSuccessColor}No issues found!$_endColor', |
| ]), |
| ); |
| }); |
| |
| test('handles warnings outside of runForPackage', () async { |
| createFakePackage('package_a', packagesDir); |
| |
| final TestPackageLoopingCommand command = createTestCommand( |
| hasLongOutput: false, |
| warnsDuringInit: true, |
| ); |
| final List<String> output = await runCommand(command); |
| |
| expect( |
| output, |
| containsAllInOrder(<String>[ |
| '${_startWarningColor}Warning during initializeRun$_endColor', |
| '${_startHeadingColor}Running for package_a...$_endColor', |
| '${_startWarningColor}Warning during completeRun$_endColor', |
| '------------------------------------------------------------', |
| 'Ran for 1 package(s)', |
| '2 warnings not associated with a package', |
| '\n', |
| '${_startSuccessColor}No issues found!$_endColor', |
| ]), |
| ); |
| }); |
| }); |
| } |
| |
| class TestPackageLoopingCommand extends PackageLoopingCommand { |
| TestPackageLoopingCommand( |
| super.packagesDir, { |
| required super.platform, |
| this.hasLongOutput = true, |
| this.packageLoopingType = PackageLoopingType.topLevelOnly, |
| this.customFailureListHeader, |
| this.customFailureListFooter, |
| this.failsDuringInit = false, |
| this.warnsDuringInit = false, |
| this.captureOutput = false, |
| super.processRunner, |
| super.gitDir, |
| }); |
| |
| final List<String> checkedPackages = <String>[]; |
| final List<String> capturedOutput = <String>[]; |
| |
| final String? customFailureListHeader; |
| final String? customFailureListFooter; |
| |
| final bool failsDuringInit; |
| final bool warnsDuringInit; |
| |
| @override |
| bool hasLongOutput; |
| |
| @override |
| PackageLoopingType packageLoopingType; |
| |
| @override |
| String get failureListHeader => |
| customFailureListHeader ?? super.failureListHeader; |
| |
| @override |
| String get failureListFooter => |
| customFailureListFooter ?? super.failureListFooter; |
| |
| @override |
| bool captureOutput; |
| |
| @override |
| final String name = 'loop-test'; |
| |
| @override |
| final String description = 'sample package looping command'; |
| |
| @override |
| bool shouldIgnoreFile(String path) { |
| return path.startsWith('skip/'); |
| } |
| |
| @override |
| Future<void> initializeRun() async { |
| if (warnsDuringInit) { |
| logWarning('Warning during initializeRun'); |
| } |
| if (failsDuringInit) { |
| throw ToolExit(2); |
| } |
| } |
| |
| @override |
| Future<PackageResult> runForPackage(RepositoryPackage package) async { |
| checkedPackages.add(package.path); |
| final File warningFile = package.directory.childFile(_warningFile); |
| if (warningFile.existsSync()) { |
| final List<String> warnings = warningFile.readAsLinesSync(); |
| warnings.forEach(logWarning); |
| } |
| final File skipFile = package.directory.childFile(_skipFile); |
| if (skipFile.existsSync()) { |
| return PackageResult.skip(skipFile.readAsStringSync()); |
| } |
| final File errorFile = package.directory.childFile(_errorFile); |
| if (errorFile.existsSync()) { |
| return PackageResult.fail(errorFile.readAsLinesSync()); |
| } |
| final File throwFile = package.directory.childFile(_throwFile); |
| if (throwFile.existsSync()) { |
| throw Exception('Uh-oh'); |
| } |
| return PackageResult.success(); |
| } |
| |
| @override |
| Future<void> completeRun() async { |
| if (warnsDuringInit) { |
| logWarning('Warning during completeRun'); |
| } |
| } |
| |
| @override |
| Future<void> handleCapturedOutput(List<String> output) async { |
| capturedOutput.addAll(output); |
| } |
| } |
