Move tools tests into a general.shard directory in preparation to changing how we shard tools tests (#36108)
diff --git a/packages/flutter_tools/test/general.shard/commands/analyze_continuously_test.dart b/packages/flutter_tools/test/general.shard/commands/analyze_continuously_test.dart
new file mode 100644
index 0000000..05a49bf
--- /dev/null
+++ b/packages/flutter_tools/test/general.shard/commands/analyze_continuously_test.dart
@@ -0,0 +1,105 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'dart:async';
+
+import 'package:flutter_tools/src/base/file_system.dart';
+import 'package:flutter_tools/src/base/os.dart';
+import 'package:flutter_tools/src/dart/analysis.dart';
+import 'package:flutter_tools/src/dart/pub.dart';
+import 'package:flutter_tools/src/dart/sdk.dart';
+import 'package:flutter_tools/src/runner/flutter_command_runner.dart';
+
+import '../../src/common.dart';
+import '../../src/context.dart';
+
+void main() {
+ AnalysisServer server;
+ Directory tempDir;
+
+ setUp(() {
+ FlutterCommandRunner.initFlutterRoot();
+ tempDir = fs.systemTempDirectory.createTempSync('flutter_analysis_test.');
+ });
+
+ tearDown(() {
+ tryToDelete(tempDir);
+ return server?.dispose();
+ });
+
+ group('analyze --watch', () {
+ testUsingContext('AnalysisServer success', () async {
+ _createSampleProject(tempDir);
+
+ await pubGet(context: PubContext.flutterTests, directory: tempDir.path);
+
+ server = AnalysisServer(dartSdkPath, <String>[tempDir.path]);
+
+ int errorCount = 0;
+ final Future<bool> onDone = server.onAnalyzing.where((bool analyzing) => analyzing == false).first;
+ server.onErrors.listen((FileAnalysisErrors errors) => errorCount += errors.errors.length);
+
+ await server.start();
+ await onDone;
+
+ expect(errorCount, 0);
+ }, overrides: <Type, Generator>{
+ OperatingSystemUtils: () => os,
+ });
+ });
+
+ testUsingContext('AnalysisServer errors', () async {
+ _createSampleProject(tempDir, brokenCode: true);
+
+ await pubGet(context: PubContext.flutterTests, directory: tempDir.path);
+
+ server = AnalysisServer(dartSdkPath, <String>[tempDir.path]);
+
+ int errorCount = 0;
+ final Future<bool> onDone = server.onAnalyzing.where((bool analyzing) => analyzing == false).first;
+ server.onErrors.listen((FileAnalysisErrors errors) {
+ errorCount += errors.errors.length;
+ });
+
+ await server.start();
+ await onDone;
+
+ expect(errorCount, greaterThan(0));
+ }, overrides: <Type, Generator>{
+ OperatingSystemUtils: () => os,
+ });
+
+ testUsingContext('Returns no errors when source is error-free', () async {
+ const String contents = "StringBuffer bar = StringBuffer('baz');";
+ tempDir.childFile('main.dart').writeAsStringSync(contents);
+ server = AnalysisServer(dartSdkPath, <String>[tempDir.path]);
+
+ int errorCount = 0;
+ final Future<bool> onDone = server.onAnalyzing.where((bool analyzing) => analyzing == false).first;
+ server.onErrors.listen((FileAnalysisErrors errors) {
+ errorCount += errors.errors.length;
+ });
+ await server.start();
+ await onDone;
+ expect(errorCount, 0);
+ }, overrides: <Type, Generator>{
+ OperatingSystemUtils: () => os,
+ });
+}
+
+void _createSampleProject(Directory directory, { bool brokenCode = false }) {
+ final File pubspecFile = fs.file(fs.path.join(directory.path, 'pubspec.yaml'));
+ pubspecFile.writeAsStringSync('''
+name: foo_project
+''');
+
+ final File dartFile = fs.file(fs.path.join(directory.path, 'lib', 'main.dart'));
+ dartFile.parent.createSync();
+ dartFile.writeAsStringSync('''
+void main() {
+ print('hello world');
+ ${brokenCode ? 'prints("hello world");' : ''}
+}
+''');
+}
diff --git a/packages/flutter_tools/test/general.shard/commands/analyze_once_test.dart b/packages/flutter_tools/test/general.shard/commands/analyze_once_test.dart
new file mode 100644
index 0000000..d783d64
--- /dev/null
+++ b/packages/flutter_tools/test/general.shard/commands/analyze_once_test.dart
@@ -0,0 +1,242 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'dart:async';
+
+import 'package:flutter_tools/src/base/common.dart';
+import 'package:flutter_tools/src/base/file_system.dart';
+import 'package:flutter_tools/src/base/platform.dart';
+import 'package:flutter_tools/src/cache.dart';
+import 'package:flutter_tools/src/commands/analyze.dart';
+import 'package:flutter_tools/src/commands/create.dart';
+import 'package:flutter_tools/src/runner/flutter_command.dart';
+
+import '../../src/common.dart';
+import '../../src/context.dart';
+
+/// Test case timeout for tests involving project analysis.
+const Timeout allowForSlowAnalyzeTests = Timeout.factor(5.0);
+
+final Generator _kNoColorTerminalPlatform = () => FakePlatform.fromPlatform(const LocalPlatform())..stdoutSupportsAnsi = false;
+final Map<Type, Generator> noColorTerminalOverride = <Type, Generator>{
+ Platform: _kNoColorTerminalPlatform,
+};
+
+void main() {
+ final String analyzerSeparator = platform.isWindows ? '-' : '•';
+
+ group('analyze once', () {
+ Directory tempDir;
+ String projectPath;
+ File libMain;
+
+ setUpAll(() {
+ Cache.disableLocking();
+ tempDir = fs.systemTempDirectory.createTempSync('flutter_analyze_once_test_1.').absolute;
+ projectPath = fs.path.join(tempDir.path, 'flutter_project');
+ libMain = fs.file(fs.path.join(projectPath, 'lib', 'main.dart'));
+ });
+
+ tearDownAll(() {
+ tryToDelete(tempDir);
+ });
+
+ // Create a project to be analyzed
+ testUsingContext('flutter create', () async {
+ await runCommand(
+ command: CreateCommand(),
+ arguments: <String>['--no-wrap', 'create', projectPath],
+ statusTextContains: <String>[
+ 'All done!',
+ 'Your application code is in ${fs.path.normalize(fs.path.join(fs.path.relative(projectPath), 'lib', 'main.dart'))}',
+ ],
+ );
+ expect(libMain.existsSync(), isTrue);
+ }, timeout: allowForRemotePubInvocation);
+
+ // Analyze in the current directory - no arguments
+ testUsingContext('working directory', () async {
+ await runCommand(
+ command: AnalyzeCommand(workingDirectory: fs.directory(projectPath)),
+ arguments: <String>['analyze'],
+ statusTextContains: <String>['No issues found!'],
+ );
+ }, timeout: allowForSlowAnalyzeTests);
+
+ // Analyze a specific file outside the current directory
+ testUsingContext('passing one file throws', () async {
+ await runCommand(
+ command: AnalyzeCommand(),
+ arguments: <String>['analyze', libMain.path],
+ toolExit: true,
+ exitMessageContains: 'is not a directory',
+ );
+ });
+
+ // Analyze in the current directory - no arguments
+ testUsingContext('working directory with errors', () async {
+ // Break the code to produce the "The parameter 'onPressed' is required" hint
+ // that is upgraded to a warning in package:flutter/analysis_options_user.yaml
+ // to assert that we are using the default Flutter analysis options.
+ // Also insert a statement that should not trigger a lint here
+ // but will trigger a lint later on when an analysis_options.yaml is added.
+ String source = await libMain.readAsString();
+ source = source.replaceFirst(
+ 'onPressed: _incrementCounter,',
+ '// onPressed: _incrementCounter,',
+ );
+ source = source.replaceFirst(
+ '_counter++;',
+ '_counter++; throw "an error message";',
+ );
+ await libMain.writeAsString(source);
+
+ // Analyze in the current directory - no arguments
+ await runCommand(
+ command: AnalyzeCommand(workingDirectory: fs.directory(projectPath)),
+ arguments: <String>['analyze'],
+ statusTextContains: <String>[
+ 'Analyzing',
+ 'warning $analyzerSeparator The parameter \'onPressed\' is required',
+ 'info $analyzerSeparator The method \'_incrementCounter\' isn\'t used',
+ ],
+ exitMessageContains: '2 issues found.',
+ toolExit: true,
+ );
+ }, timeout: allowForSlowAnalyzeTests, overrides: noColorTerminalOverride);
+
+ // Analyze in the current directory - no arguments
+ testUsingContext('working directory with local options', () async {
+ // Insert an analysis_options.yaml file in the project
+ // which will trigger a lint for broken code that was inserted earlier
+ final File optionsFile = fs.file(fs.path.join(projectPath, 'analysis_options.yaml'));
+ await optionsFile.writeAsString('''
+ include: package:flutter/analysis_options_user.yaml
+ linter:
+ rules:
+ - only_throw_errors
+ ''');
+
+ // Analyze in the current directory - no arguments
+ await runCommand(
+ command: AnalyzeCommand(workingDirectory: fs.directory(projectPath)),
+ arguments: <String>['analyze'],
+ statusTextContains: <String>[
+ 'Analyzing',
+ 'warning $analyzerSeparator The parameter \'onPressed\' is required',
+ 'info $analyzerSeparator The method \'_incrementCounter\' isn\'t used',
+ 'info $analyzerSeparator Only throw instances of classes extending either Exception or Error',
+ ],
+ exitMessageContains: '3 issues found.',
+ toolExit: true,
+ );
+ }, timeout: allowForSlowAnalyzeTests, overrides: noColorTerminalOverride);
+
+ testUsingContext('no duplicate issues', () async {
+ final Directory tempDir = fs.systemTempDirectory.createTempSync('flutter_analyze_once_test_2.').absolute;
+
+ try {
+ final File foo = fs.file(fs.path.join(tempDir.path, 'foo.dart'));
+ foo.writeAsStringSync('''
+import 'bar.dart';
+
+void foo() => bar();
+''');
+
+ final File bar = fs.file(fs.path.join(tempDir.path, 'bar.dart'));
+ bar.writeAsStringSync('''
+import 'dart:async'; // unused
+
+void bar() {
+}
+''');
+
+ // Analyze in the current directory - no arguments
+ await runCommand(
+ command: AnalyzeCommand(workingDirectory: tempDir),
+ arguments: <String>['analyze'],
+ statusTextContains: <String>[
+ 'Analyzing',
+ ],
+ exitMessageContains: '1 issue found.',
+ toolExit: true,
+ );
+ } finally {
+ tryToDelete(tempDir);
+ }
+ }, overrides: noColorTerminalOverride);
+
+ testUsingContext('returns no issues when source is error-free', () async {
+ const String contents = '''
+StringBuffer bar = StringBuffer('baz');
+''';
+ final Directory tempDir = fs.systemTempDirectory.createTempSync('flutter_analyze_once_test_3.');
+ tempDir.childFile('main.dart').writeAsStringSync(contents);
+ try {
+ await runCommand(
+ command: AnalyzeCommand(workingDirectory: fs.directory(tempDir)),
+ arguments: <String>['analyze'],
+ statusTextContains: <String>['No issues found!'],
+ );
+ } finally {
+ tryToDelete(tempDir);
+ }
+ }, overrides: noColorTerminalOverride);
+
+ testUsingContext('returns no issues for todo comments', () async {
+ const String contents = '''
+// TODO(foobar):
+StringBuffer bar = StringBuffer('baz');
+''';
+ final Directory tempDir = fs.systemTempDirectory.createTempSync('flutter_analyze_once_test_4.');
+ tempDir.childFile('main.dart').writeAsStringSync(contents);
+ try {
+ await runCommand(
+ command: AnalyzeCommand(workingDirectory: fs.directory(tempDir)),
+ arguments: <String>['analyze'],
+ statusTextContains: <String>['No issues found!'],
+ );
+ } finally {
+ tryToDelete(tempDir);
+ }
+ }, overrides: noColorTerminalOverride);
+ });
+}
+
+void assertContains(String text, List<String> patterns) {
+ if (patterns == null) {
+ expect(text, isEmpty);
+ } else {
+ for (String pattern in patterns) {
+ expect(text, contains(pattern));
+ }
+ }
+}
+
+Future<void> runCommand({
+ FlutterCommand command,
+ List<String> arguments,
+ List<String> statusTextContains,
+ List<String> errorTextContains,
+ bool toolExit = false,
+ String exitMessageContains,
+}) async {
+ try {
+ arguments.insert(0, '--flutter-root=${Cache.flutterRoot}');
+ await createTestCommandRunner(command).run(arguments);
+ expect(toolExit, isFalse, reason: 'Expected ToolExit exception');
+ } on ToolExit catch (e) {
+ if (!toolExit) {
+ testLogger.clear();
+ rethrow;
+ }
+ if (exitMessageContains != null) {
+ expect(e.message, contains(exitMessageContains));
+ }
+ }
+ assertContains(testLogger.statusText, statusTextContains);
+ assertContains(testLogger.errorText, errorTextContains);
+
+ testLogger.clear();
+}
diff --git a/packages/flutter_tools/test/general.shard/commands/analyze_test.dart b/packages/flutter_tools/test/general.shard/commands/analyze_test.dart
new file mode 100644
index 0000000..ee24615
--- /dev/null
+++ b/packages/flutter_tools/test/general.shard/commands/analyze_test.dart
@@ -0,0 +1,53 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'package:file/file.dart';
+import 'package:file/memory.dart';
+import 'package:flutter_tools/src/cache.dart';
+import 'package:flutter_tools/src/commands/analyze_base.dart';
+
+import '../../src/common.dart';
+import '../../src/context.dart';
+
+const String _kFlutterRoot = '/data/flutter';
+
+void main() {
+ FileSystem fs;
+ Directory tempDir;
+
+ setUp(() {
+ fs = MemoryFileSystem();
+ fs.directory(_kFlutterRoot).createSync(recursive: true);
+ Cache.flutterRoot = _kFlutterRoot;
+ tempDir = fs.systemTempDirectory.createTempSync('flutter_analysis_test.');
+ });
+
+ tearDown(() {
+ tryToDelete(tempDir);
+ });
+
+ group('analyze', () {
+ testUsingContext('inRepo', () {
+ // Absolute paths
+ expect(inRepo(<String>[tempDir.path]), isFalse);
+ expect(inRepo(<String>[fs.path.join(tempDir.path, 'foo')]), isFalse);
+ expect(inRepo(<String>[Cache.flutterRoot]), isTrue);
+ expect(inRepo(<String>[fs.path.join(Cache.flutterRoot, 'foo')]), isTrue);
+
+ // Relative paths
+ fs.currentDirectory = Cache.flutterRoot;
+ expect(inRepo(<String>['.']), isTrue);
+ expect(inRepo(<String>['foo']), isTrue);
+ fs.currentDirectory = tempDir.path;
+ expect(inRepo(<String>['.']), isFalse);
+ expect(inRepo(<String>['foo']), isFalse);
+
+ // Ensure no exceptions
+ inRepo(null);
+ inRepo(<String>[]);
+ }, overrides: <Type, Generator>{
+ FileSystem: () => fs,
+ });
+ });
+}
diff --git a/packages/flutter_tools/test/general.shard/commands/assemble_test.dart b/packages/flutter_tools/test/general.shard/commands/assemble_test.dart
new file mode 100644
index 0000000..e18ebb5
--- /dev/null
+++ b/packages/flutter_tools/test/general.shard/commands/assemble_test.dart
@@ -0,0 +1,84 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'package:args/command_runner.dart';
+import 'package:flutter_tools/src/base/file_system.dart';
+import 'package:flutter_tools/src/base/logger.dart';
+import 'package:flutter_tools/src/build_info.dart';
+import 'package:flutter_tools/src/build_system/build_system.dart';
+import 'package:flutter_tools/src/cache.dart';
+import 'package:flutter_tools/src/commands/assemble.dart';
+import 'package:flutter_tools/src/globals.dart';
+import 'package:mockito/mockito.dart';
+
+import '../../src/common.dart';
+import '../../src/testbed.dart';
+
+void main() {
+ group('Assemble', () {
+ Testbed testbed;
+ MockBuildSystem mockBuildSystem;
+
+ setUpAll(() {
+ Cache.disableLocking();
+ });
+
+ setUp(() {
+ mockBuildSystem = MockBuildSystem();
+ testbed = Testbed(overrides: <Type, Generator>{
+ BuildSystem: () => mockBuildSystem,
+ });
+ });
+
+ test('Can list the output directory relative to project root', () => testbed.run(() async {
+ final CommandRunner<void> commandRunner = createTestCommandRunner(AssembleCommand());
+ await commandRunner.run(<String>['assemble', '--flutter-root=.', 'build-dir', '-dBuildMode=debug']);
+ final BufferLogger bufferLogger = logger;
+ final Environment environment = Environment(
+ defines: <String, String>{
+ 'BuildMode': 'debug'
+ }, projectDir: fs.currentDirectory,
+ buildDir: fs.directory(getBuildDirectory()),
+ );
+
+ expect(bufferLogger.statusText.trim(),
+ fs.path.relative(environment.buildDir.path, from: fs.currentDirectory.path));
+ }));
+
+ test('Can describe a target', () => testbed.run(() async {
+ when(mockBuildSystem.describe('foobar', any)).thenReturn(<Map<String, Object>>[
+ <String, Object>{'fizz': 'bar'},
+ ]);
+ final CommandRunner<void> commandRunner = createTestCommandRunner(AssembleCommand());
+ await commandRunner.run(<String>['assemble', '--flutter-root=.', 'describe', 'foobar']);
+ final BufferLogger bufferLogger = logger;
+
+ expect(bufferLogger.statusText.trim(), '[{"fizz":"bar"}]');
+ }));
+
+ test('Can describe a target\'s inputs', () => testbed.run(() async {
+ when(mockBuildSystem.describe('foobar', any)).thenReturn(<Map<String, Object>>[
+ <String, Object>{'name': 'foobar', 'inputs': <String>['bar', 'baz']},
+ ]);
+ final CommandRunner<void> commandRunner = createTestCommandRunner(AssembleCommand());
+ await commandRunner.run(<String>['assemble', '--flutter-root=.', 'inputs', 'foobar']);
+ final BufferLogger bufferLogger = logger;
+
+ expect(bufferLogger.statusText.trim(), 'bar\nbaz');
+ }));
+
+ test('Can run a build', () => testbed.run(() async {
+ when(mockBuildSystem.build('foobar', any, any)).thenAnswer((Invocation invocation) async {
+ return BuildResult(true, const <String, ExceptionMeasurement>{}, const <String, PerformanceMeasurement>{});
+ });
+ final CommandRunner<void> commandRunner = createTestCommandRunner(AssembleCommand());
+ await commandRunner.run(<String>['assemble', 'run', 'foobar']);
+ final BufferLogger bufferLogger = logger;
+
+ expect(bufferLogger.statusText.trim(), 'build succeeded');
+ }));
+ });
+}
+
+class MockBuildSystem extends Mock implements BuildSystem {}
diff --git a/packages/flutter_tools/test/general.shard/commands/attach_test.dart b/packages/flutter_tools/test/general.shard/commands/attach_test.dart
new file mode 100644
index 0000000..c708f1e
--- /dev/null
+++ b/packages/flutter_tools/test/general.shard/commands/attach_test.dart
@@ -0,0 +1,644 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'dart:async';
+
+import 'package:file/memory.dart';
+import 'package:flutter_tools/src/base/common.dart';
+import 'package:flutter_tools/src/base/file_system.dart';
+import 'package:flutter_tools/src/base/logger.dart';
+import 'package:flutter_tools/src/base/platform.dart';
+import 'package:flutter_tools/src/base/terminal.dart';
+import 'package:flutter_tools/src/cache.dart';
+import 'package:flutter_tools/src/commands/attach.dart';
+import 'package:flutter_tools/src/device.dart';
+import 'package:flutter_tools/src/resident_runner.dart';
+import 'package:flutter_tools/src/run_hot.dart';
+import 'package:meta/meta.dart';
+import 'package:mockito/mockito.dart';
+import 'package:multicast_dns/multicast_dns.dart';
+
+import '../../src/common.dart';
+import '../../src/context.dart';
+import '../../src/mocks.dart';
+
+void main() {
+ group('attach', () {
+ StreamLogger logger;
+ FileSystem testFileSystem;
+
+ setUp(() {
+ Cache.disableLocking();
+ logger = StreamLogger();
+ testFileSystem = MemoryFileSystem(
+ style: platform.isWindows
+ ? FileSystemStyle.windows
+ : FileSystemStyle.posix,
+ );
+ testFileSystem.directory('lib').createSync();
+ testFileSystem.file(testFileSystem.path.join('lib', 'main.dart')).createSync();
+ });
+
+ group('with one device and no specified target file', () {
+ const int devicePort = 499;
+ const int hostPort = 42;
+
+ MockDeviceLogReader mockLogReader;
+ MockPortForwarder portForwarder;
+ MockAndroidDevice device;
+
+ setUp(() {
+ mockLogReader = MockDeviceLogReader();
+ portForwarder = MockPortForwarder();
+ device = MockAndroidDevice();
+ when(device.getLogReader()).thenAnswer((_) {
+ // Now that the reader is used, start writing messages to it.
+ Timer.run(() {
+ mockLogReader.addLine('Foo');
+ mockLogReader.addLine('Observatory listening on http://127.0.0.1:$devicePort');
+ });
+
+ return mockLogReader;
+ });
+ when(device.portForwarder)
+ .thenReturn(portForwarder);
+ when(portForwarder.forward(devicePort, hostPort: anyNamed('hostPort')))
+ .thenAnswer((_) async => hostPort);
+ when(portForwarder.forwardedPorts)
+ .thenReturn(<ForwardedPort>[ForwardedPort(hostPort, devicePort)]);
+ when(portForwarder.unforward(any))
+ .thenAnswer((_) async => null);
+
+ // We cannot add the device to a device manager because that is
+ // only enabled by the context of each testUsingContext call.
+ //
+ // Instead each test will add the device to the device manager
+ // on its own.
+ });
+
+ tearDown(() {
+ mockLogReader.dispose();
+ });
+
+ testUsingContext('finds observatory port and forwards', () async {
+ testDeviceManager.addDevice(device);
+ final Completer<void> completer = Completer<void>();
+ final StreamSubscription<String> loggerSubscription = logger.stream.listen((String message) {
+ if (message == '[stdout] Done.') {
+ // The "Done." message is output by the AttachCommand when it's done.
+ completer.complete();
+ }
+ });
+ final Future<void> task = createTestCommandRunner(AttachCommand()).run(<String>['attach']);
+ await completer.future;
+ verify(
+ portForwarder.forward(devicePort, hostPort: anyNamed('hostPort')),
+ ).called(1);
+ await expectLoggerInterruptEndsTask(task, logger);
+ await loggerSubscription.cancel();
+ }, overrides: <Type, Generator>{
+ FileSystem: () => testFileSystem,
+ Logger: () => logger,
+ });
+
+ testUsingContext('accepts filesystem parameters', () async {
+ testDeviceManager.addDevice(device);
+
+ const String filesystemScheme = 'foo';
+ const String filesystemRoot = '/build-output/';
+ const String projectRoot = '/build-output/project-root';
+ const String outputDill = '/tmp/output.dill';
+
+ final MockHotRunner mockHotRunner = MockHotRunner();
+ when(mockHotRunner.attach(appStartedCompleter: anyNamed('appStartedCompleter')))
+ .thenAnswer((_) async => 0);
+
+ final MockHotRunnerFactory mockHotRunnerFactory = MockHotRunnerFactory();
+ when(
+ mockHotRunnerFactory.build(
+ any,
+ target: anyNamed('target'),
+ projectRootPath: anyNamed('projectRootPath'),
+ dillOutputPath: anyNamed('dillOutputPath'),
+ debuggingOptions: anyNamed('debuggingOptions'),
+ packagesFilePath: anyNamed('packagesFilePath'),
+ usesTerminalUi: anyNamed('usesTerminalUi'),
+ flutterProject: anyNamed('flutterProject'),
+ ipv6: false,
+ ),
+ ).thenReturn(mockHotRunner);
+
+ final AttachCommand command = AttachCommand(
+ hotRunnerFactory: mockHotRunnerFactory,
+ );
+ await createTestCommandRunner(command).run(<String>[
+ 'attach',
+ '--filesystem-scheme',
+ filesystemScheme,
+ '--filesystem-root',
+ filesystemRoot,
+ '--project-root',
+ projectRoot,
+ '--output-dill',
+ outputDill,
+ '-v', // enables verbose logging
+ ]);
+
+ // Validate the attach call built a mock runner with the right
+ // project root and output dill.
+ final VerificationResult verificationResult = verify(
+ mockHotRunnerFactory.build(
+ captureAny,
+ target: anyNamed('target'),
+ projectRootPath: projectRoot,
+ dillOutputPath: outputDill,
+ debuggingOptions: anyNamed('debuggingOptions'),
+ packagesFilePath: anyNamed('packagesFilePath'),
+ usesTerminalUi: anyNamed('usesTerminalUi'),
+ flutterProject: anyNamed('flutterProject'),
+ ipv6: false,
+ ),
+ )..called(1);
+
+ final List<FlutterDevice> flutterDevices = verificationResult.captured.first;
+ expect(flutterDevices, hasLength(1));
+
+ // Validate that the attach call built a flutter device with the right
+ // output dill, filesystem scheme, and filesystem root.
+ final FlutterDevice flutterDevice = flutterDevices.first;
+
+ expect(flutterDevice.dillOutputPath, outputDill);
+ expect(flutterDevice.fileSystemScheme, filesystemScheme);
+ expect(flutterDevice.fileSystemRoots, const <String>[filesystemRoot]);
+ }, overrides: <Type, Generator>{
+ FileSystem: () => testFileSystem,
+ });
+
+ testUsingContext('exits when ipv6 is specified and debug-port is not', () async {
+ testDeviceManager.addDevice(device);
+
+ final AttachCommand command = AttachCommand();
+ await expectLater(
+ createTestCommandRunner(command).run(<String>['attach', '--ipv6']),
+ throwsToolExit(
+ message: 'When the --debug-port or --debug-uri is unknown, this command determines '
+ 'the value of --ipv6 on its own.',
+ ),
+ );
+ }, overrides: <Type, Generator>{
+ FileSystem: () => testFileSystem,
+ },);
+
+ testUsingContext('exits when observatory-port is specified and debug-port is not', () async {
+ testDeviceManager.addDevice(device);
+
+ final AttachCommand command = AttachCommand();
+ await expectLater(
+ createTestCommandRunner(command).run(<String>['attach', '--observatory-port', '100']),
+ throwsToolExit(
+ message: 'When the --debug-port or --debug-uri is unknown, this command does not use '
+ 'the value of --observatory-port.',
+ ),
+ );
+ }, overrides: <Type, Generator>{
+ FileSystem: () => testFileSystem,
+ },);
+ });
+
+
+ testUsingContext('selects specified target', () async {
+ const int devicePort = 499;
+ const int hostPort = 42;
+ final MockDeviceLogReader mockLogReader = MockDeviceLogReader();
+ final MockPortForwarder portForwarder = MockPortForwarder();
+ final MockAndroidDevice device = MockAndroidDevice();
+ final MockHotRunner mockHotRunner = MockHotRunner();
+ final MockHotRunnerFactory mockHotRunnerFactory = MockHotRunnerFactory();
+ when(device.portForwarder)
+ .thenReturn(portForwarder);
+ when(portForwarder.forward(devicePort, hostPort: anyNamed('hostPort')))
+ .thenAnswer((_) async => hostPort);
+ when(portForwarder.forwardedPorts)
+ .thenReturn(<ForwardedPort>[ForwardedPort(hostPort, devicePort)]);
+ when(portForwarder.unforward(any))
+ .thenAnswer((_) async => null);
+ when(mockHotRunner.attach(appStartedCompleter: anyNamed('appStartedCompleter')))
+ .thenAnswer((_) async => 0);
+ when(mockHotRunnerFactory.build(
+ any,
+ target: anyNamed('target'),
+ debuggingOptions: anyNamed('debuggingOptions'),
+ packagesFilePath: anyNamed('packagesFilePath'),
+ usesTerminalUi: anyNamed('usesTerminalUi'),
+ flutterProject: anyNamed('flutterProject'),
+ ipv6: false,
+ )).thenReturn(mockHotRunner);
+
+ testDeviceManager.addDevice(device);
+ when(device.getLogReader())
+ .thenAnswer((_) {
+ // Now that the reader is used, start writing messages to it.
+ Timer.run(() {
+ mockLogReader.addLine('Foo');
+ mockLogReader.addLine(
+ 'Observatory listening on http://127.0.0.1:$devicePort');
+ });
+ return mockLogReader;
+ });
+ final File foo = fs.file('lib/foo.dart')
+ ..createSync();
+
+ // Delete the main.dart file to be sure that attach works without it.
+ fs.file(fs.path.join('lib', 'main.dart')).deleteSync();
+
+ final AttachCommand command = AttachCommand(hotRunnerFactory: mockHotRunnerFactory);
+ await createTestCommandRunner(command).run(<String>['attach', '-t', foo.path, '-v']);
+
+ verify(mockHotRunnerFactory.build(
+ any,
+ target: foo.path,
+ debuggingOptions: anyNamed('debuggingOptions'),
+ packagesFilePath: anyNamed('packagesFilePath'),
+ usesTerminalUi: anyNamed('usesTerminalUi'),
+ flutterProject: anyNamed('flutterProject'),
+ ipv6: false,
+ )).called(1);
+ }, overrides: <Type, Generator>{
+ FileSystem: () => testFileSystem,
+ });
+
+ group('forwarding to given port', () {
+ const int devicePort = 499;
+ const int hostPort = 42;
+ MockPortForwarder portForwarder;
+ MockAndroidDevice device;
+
+ setUp(() {
+ portForwarder = MockPortForwarder();
+ device = MockAndroidDevice();
+
+ when(device.portForwarder)
+ .thenReturn(portForwarder);
+ when(portForwarder.forward(devicePort))
+ .thenAnswer((_) async => hostPort);
+ when(portForwarder.forwardedPorts)
+ .thenReturn(<ForwardedPort>[ForwardedPort(hostPort, devicePort)]);
+ when(portForwarder.unforward(any))
+ .thenAnswer((_) async => null);
+ });
+
+ testUsingContext('succeeds in ipv4 mode', () async {
+ testDeviceManager.addDevice(device);
+
+ final Completer<void> completer = Completer<void>();
+ final StreamSubscription<String> loggerSubscription = logger.stream.listen((String message) {
+ if (message == '[verbose] Connecting to service protocol: http://127.0.0.1:42/') {
+ // Wait until resident_runner.dart tries to connect.
+ // There's nothing to connect _to_, so that's as far as we care to go.
+ completer.complete();
+ }
+ });
+ final Future<void> task = createTestCommandRunner(AttachCommand())
+ .run(<String>['attach', '--debug-port', '$devicePort']);
+ await completer.future;
+ verify(portForwarder.forward(devicePort)).called(1);
+
+ await expectLoggerInterruptEndsTask(task, logger);
+ await loggerSubscription.cancel();
+ }, overrides: <Type, Generator>{
+ FileSystem: () => testFileSystem,
+ Logger: () => logger,
+ });
+
+ testUsingContext('succeeds in ipv6 mode', () async {
+ testDeviceManager.addDevice(device);
+
+ final Completer<void> completer = Completer<void>();
+ final StreamSubscription<String> loggerSubscription = logger.stream.listen((String message) {
+ if (message == '[verbose] Connecting to service protocol: http://[::1]:42/') {
+ // Wait until resident_runner.dart tries to connect.
+ // There's nothing to connect _to_, so that's as far as we care to go.
+ completer.complete();
+ }
+ });
+ final Future<void> task = createTestCommandRunner(AttachCommand())
+ .run(<String>['attach', '--debug-port', '$devicePort', '--ipv6']);
+ await completer.future;
+ verify(portForwarder.forward(devicePort)).called(1);
+
+ await expectLoggerInterruptEndsTask(task, logger);
+ await loggerSubscription.cancel();
+ }, overrides: <Type, Generator>{
+ FileSystem: () => testFileSystem,
+ Logger: () => logger,
+ });
+
+ testUsingContext('skips in ipv4 mode with a provided observatory port', () async {
+ testDeviceManager.addDevice(device);
+
+ final Completer<void> completer = Completer<void>();
+ final StreamSubscription<String> loggerSubscription = logger.stream.listen((String message) {
+ if (message == '[verbose] Connecting to service protocol: http://127.0.0.1:42/') {
+ // Wait until resident_runner.dart tries to connect.
+ // There's nothing to connect _to_, so that's as far as we care to go.
+ completer.complete();
+ }
+ });
+ final Future<void> task = createTestCommandRunner(AttachCommand()).run(
+ <String>[
+ 'attach',
+ '--debug-port',
+ '$devicePort',
+ '--observatory-port',
+ '$hostPort',
+ ],
+ );
+ await completer.future;
+ verifyNever(portForwarder.forward(devicePort));
+
+ await expectLoggerInterruptEndsTask(task, logger);
+ await loggerSubscription.cancel();
+ }, overrides: <Type, Generator>{
+ FileSystem: () => testFileSystem,
+ Logger: () => logger,
+ });
+
+ testUsingContext('skips in ipv6 mode with a provided observatory port', () async {
+ testDeviceManager.addDevice(device);
+
+ final Completer<void> completer = Completer<void>();
+ final StreamSubscription<String> loggerSubscription = logger.stream.listen((String message) {
+ if (message == '[verbose] Connecting to service protocol: http://[::1]:42/') {
+ // Wait until resident_runner.dart tries to connect.
+ // There's nothing to connect _to_, so that's as far as we care to go.
+ completer.complete();
+ }
+ });
+ final Future<void> task = createTestCommandRunner(AttachCommand()).run(
+ <String>[
+ 'attach',
+ '--debug-port',
+ '$devicePort',
+ '--observatory-port',
+ '$hostPort',
+ '--ipv6',
+ ],
+ );
+ await completer.future;
+ verifyNever(portForwarder.forward(devicePort));
+
+ await expectLoggerInterruptEndsTask(task, logger);
+ await loggerSubscription.cancel();
+ }, overrides: <Type, Generator>{
+ FileSystem: () => testFileSystem,
+ Logger: () => logger,
+ });
+ });
+
+ testUsingContext('exits when no device connected', () async {
+ final AttachCommand command = AttachCommand();
+ await expectLater(
+ createTestCommandRunner(command).run(<String>['attach']),
+ throwsA(isInstanceOf<ToolExit>()),
+ );
+ expect(testLogger.statusText, contains('No supported devices connected'));
+ }, overrides: <Type, Generator>{
+ FileSystem: () => testFileSystem,
+ });
+
+ testUsingContext('exits when multiple devices connected', () async {
+ Device aDeviceWithId(String id) {
+ final MockAndroidDevice device = MockAndroidDevice();
+ when(device.name).thenReturn('d$id');
+ when(device.id).thenReturn(id);
+ when(device.isLocalEmulator).thenAnswer((_) async => false);
+ when(device.sdkNameAndVersion).thenAnswer((_) async => 'Android 46');
+ return device;
+ }
+
+ final AttachCommand command = AttachCommand();
+ testDeviceManager.addDevice(aDeviceWithId('xx1'));
+ testDeviceManager.addDevice(aDeviceWithId('yy2'));
+ await expectLater(
+ createTestCommandRunner(command).run(<String>['attach']),
+ throwsA(isInstanceOf<ToolExit>()),
+ );
+ expect(testLogger.statusText, contains('More than one device'));
+ expect(testLogger.statusText, contains('xx1'));
+ expect(testLogger.statusText, contains('yy2'));
+ }, overrides: <Type, Generator>{
+ FileSystem: () => testFileSystem,
+ });
+ });
+
+ group('mDNS Discovery', () {
+ final int year3000 = DateTime(3000).millisecondsSinceEpoch;
+
+ MDnsClient getMockClient(
+ List<PtrResourceRecord> ptrRecords,
+ Map<String, List<SrvResourceRecord>> srvResponse,
+ ) {
+ final MDnsClient client = MockMDnsClient();
+
+ when(client.lookup<PtrResourceRecord>(
+ ResourceRecordQuery.serverPointer(MDnsObservatoryDiscovery.dartObservatoryName),
+ )).thenAnswer((_) => Stream<PtrResourceRecord>.fromIterable(ptrRecords));
+
+ for (final MapEntry<String, List<SrvResourceRecord>> entry in srvResponse.entries) {
+ when(client.lookup<SrvResourceRecord>(
+ ResourceRecordQuery.service(entry.key),
+ )).thenAnswer((_) => Stream<SrvResourceRecord>.fromIterable(entry.value));
+ }
+ return client;
+ }
+
+ testUsingContext('No ports available', () async {
+ final MDnsClient client = getMockClient(<PtrResourceRecord>[], <String, List<SrvResourceRecord>>{});
+
+ final MDnsObservatoryDiscovery portDiscovery = MDnsObservatoryDiscovery(mdnsClient: client);
+ final int port = (await portDiscovery.query())?.port;
+ expect(port, isNull);
+ });
+
+ testUsingContext('One port available, no appId', () async {
+ final MDnsClient client = getMockClient(
+ <PtrResourceRecord>[
+ PtrResourceRecord('foo', year3000, domainName: 'bar'),
+ ],
+ <String, List<SrvResourceRecord>>{
+ 'bar': <SrvResourceRecord>[
+ SrvResourceRecord('bar', year3000, port: 123, weight: 1, priority: 1, target: 'appId'),
+ ],
+ },
+ );
+
+ final MDnsObservatoryDiscovery portDiscovery = MDnsObservatoryDiscovery(mdnsClient: client);
+ final int port = (await portDiscovery.query())?.port;
+ expect(port, 123);
+ });
+
+ testUsingContext('Multiple ports available, without appId', () async {
+ final MDnsClient client = getMockClient(
+ <PtrResourceRecord>[
+ PtrResourceRecord('foo', year3000, domainName: 'bar'),
+ PtrResourceRecord('baz', year3000, domainName: 'fiz'),
+ ],
+ <String, List<SrvResourceRecord>>{
+ 'bar': <SrvResourceRecord>[
+ SrvResourceRecord('bar', year3000, port: 123, weight: 1, priority: 1, target: 'appId'),
+ ],
+ 'fiz': <SrvResourceRecord>[
+ SrvResourceRecord('fiz', year3000, port: 321, weight: 1, priority: 1, target: 'local'),
+ ],
+ },
+ );
+
+ final MDnsObservatoryDiscovery portDiscovery = MDnsObservatoryDiscovery(mdnsClient: client);
+ expect(() => portDiscovery.query(), throwsToolExit());
+ });
+
+ testUsingContext('Multiple ports available, with appId', () async {
+ final MDnsClient client = getMockClient(
+ <PtrResourceRecord>[
+ PtrResourceRecord('foo', year3000, domainName: 'bar'),
+ PtrResourceRecord('baz', year3000, domainName: 'fiz'),
+ ],
+ <String, List<SrvResourceRecord>>{
+ 'bar': <SrvResourceRecord>[
+ SrvResourceRecord('bar', year3000, port: 123, weight: 1, priority: 1, target: 'appId'),
+ ],
+ 'fiz': <SrvResourceRecord>[
+ SrvResourceRecord('fiz', year3000, port: 321, weight: 1, priority: 1, target: 'local'),
+ ],
+ },
+ );
+
+ final MDnsObservatoryDiscovery portDiscovery = MDnsObservatoryDiscovery(mdnsClient: client);
+ final int port = (await portDiscovery.query(applicationId: 'fiz'))?.port;
+ expect(port, 321);
+ });
+
+ testUsingContext('Multiple ports available per process, with appId', () async {
+ final MDnsClient client = getMockClient(
+ <PtrResourceRecord>[
+ PtrResourceRecord('foo', year3000, domainName: 'bar'),
+ PtrResourceRecord('baz', year3000, domainName: 'fiz'),
+ ],
+ <String, List<SrvResourceRecord>>{
+ 'bar': <SrvResourceRecord>[
+ SrvResourceRecord('bar', year3000, port: 1234, weight: 1, priority: 1, target: 'appId'),
+ SrvResourceRecord('bar', year3000, port: 123, weight: 1, priority: 1, target: 'appId'),
+ ],
+ 'fiz': <SrvResourceRecord>[
+ SrvResourceRecord('fiz', year3000, port: 4321, weight: 1, priority: 1, target: 'local'),
+ SrvResourceRecord('fiz', year3000, port: 321, weight: 1, priority: 1, target: 'local'),
+ ],
+ },
+ );
+
+ final MDnsObservatoryDiscovery portDiscovery = MDnsObservatoryDiscovery(mdnsClient: client);
+ final int port = (await portDiscovery.query(applicationId: 'bar'))?.port;
+ expect(port, 1234);
+ });
+
+ testUsingContext('Query returns null', () async {
+ final MDnsClient client = getMockClient(
+ <PtrResourceRecord>[],
+ <String, List<SrvResourceRecord>>{},
+ );
+
+ final MDnsObservatoryDiscovery portDiscovery = MDnsObservatoryDiscovery(mdnsClient: client);
+ final int port = (await portDiscovery.query(applicationId: 'bar'))?.port;
+ expect(port, isNull);
+ });
+ });
+}
+
+class MockMDnsClient extends Mock implements MDnsClient {}
+
+class MockPortForwarder extends Mock implements DevicePortForwarder {}
+
+class MockHotRunner extends Mock implements HotRunner {}
+
+class MockHotRunnerFactory extends Mock implements HotRunnerFactory {}
+
+class StreamLogger extends Logger {
+ @override
+ bool get isVerbose => true;
+
+ @override
+ void printError(
+ String message, {
+ StackTrace stackTrace,
+ bool emphasis,
+ TerminalColor color,
+ int indent,
+ int hangingIndent,
+ bool wrap,
+ }) {
+ _log('[stderr] $message');
+ }
+
+ @override
+ void printStatus(
+ String message, {
+ bool emphasis,
+ TerminalColor color,
+ bool newline,
+ int indent,
+ int hangingIndent,
+ bool wrap,
+ }) {
+ _log('[stdout] $message');
+ }
+
+ @override
+ void printTrace(String message) {
+ _log('[verbose] $message');
+ }
+
+ @override
+ Status startProgress(
+ String message, {
+ @required Duration timeout,
+ String progressId,
+ bool multilineOutput = false,
+ int progressIndicatorPadding = kDefaultStatusPadding,
+ }) {
+ _log('[progress] $message');
+ return SilentStatus(timeout: timeout)..start();
+ }
+
+ bool _interrupt = false;
+
+ void interrupt() {
+ _interrupt = true;
+ }
+
+ final StreamController<String> _controller = StreamController<String>.broadcast();
+
+ void _log(String message) {
+ _controller.add(message);
+ if (_interrupt) {
+ _interrupt = false;
+ throw const LoggerInterrupted();
+ }
+ }
+
+ Stream<String> get stream => _controller.stream;
+}
+
+class LoggerInterrupted implements Exception {
+ const LoggerInterrupted();
+}
+
+Future<void> expectLoggerInterruptEndsTask(Future<void> task, StreamLogger logger) async {
+ logger.interrupt(); // an exception during the task should cause it to fail...
+ try {
+ await task;
+ expect(false, isTrue); // (shouldn't reach here)
+ } on ToolExit catch (error) {
+ expect(error.exitCode, 2); // ...with exit code 2.
+ }
+}
diff --git a/packages/flutter_tools/test/general.shard/commands/build_bundle_test.dart b/packages/flutter_tools/test/general.shard/commands/build_bundle_test.dart
new file mode 100644
index 0000000..6c6c8ad
--- /dev/null
+++ b/packages/flutter_tools/test/general.shard/commands/build_bundle_test.dart
@@ -0,0 +1,96 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'package:args/command_runner.dart';
+import 'package:flutter_tools/src/base/file_system.dart';
+import 'package:flutter_tools/src/cache.dart';
+import 'package:flutter_tools/src/commands/build_bundle.dart';
+import 'package:flutter_tools/src/bundle.dart';
+import 'package:flutter_tools/src/usage.dart';
+import 'package:mockito/mockito.dart';
+
+import '../../src/common.dart';
+import '../../src/context.dart';
+
+void main() {
+ Cache.disableLocking();
+
+ group('getUsage', () {
+ Directory tempDir;
+ MockBundleBuilder mockBundleBuilder;
+
+ setUp(() {
+ tempDir = fs.systemTempDirectory.createTempSync('flutter_tools_packages_test.');
+
+ mockBundleBuilder = MockBundleBuilder();
+ when(
+ mockBundleBuilder.build(
+ platform: anyNamed('platform'),
+ buildMode: anyNamed('buildMode'),
+ mainPath: anyNamed('mainPath'),
+ manifestPath: anyNamed('manifestPath'),
+ applicationKernelFilePath: anyNamed('applicationKernelFilePath'),
+ depfilePath: anyNamed('depfilePath'),
+ privateKeyPath: anyNamed('privateKeyPath'),
+ assetDirPath: anyNamed('assetDirPath'),
+ packagesPath: anyNamed('packagesPath'),
+ precompiledSnapshot: anyNamed('precompiledSnapshot'),
+ reportLicensedPackages: anyNamed('reportLicensedPackages'),
+ trackWidgetCreation: anyNamed('trackWidgetCreation'),
+ extraFrontEndOptions: anyNamed('extraFrontEndOptions'),
+ extraGenSnapshotOptions: anyNamed('extraGenSnapshotOptions'),
+ fileSystemRoots: anyNamed('fileSystemRoots'),
+ fileSystemScheme: anyNamed('fileSystemScheme'),
+ ),
+ ).thenAnswer((_) => Future<void>.value());
+ });
+
+ tearDown(() {
+ tryToDelete(tempDir);
+ });
+
+ Future<BuildBundleCommand> runCommandIn(String projectPath, { List<String> arguments }) async {
+ final BuildBundleCommand command = BuildBundleCommand(bundleBuilder: mockBundleBuilder);
+ final CommandRunner<void> runner = createTestCommandRunner(command);
+ await runner.run(<String>[
+ 'bundle',
+ ...?arguments,
+ '--target=$projectPath/lib/main.dart',
+ ]);
+ return command;
+ }
+
+ testUsingContext('indicate that project is a module', () async {
+ final String projectPath = await createProject(tempDir,
+ arguments: <String>['--no-pub', '--template=module']);
+
+ final BuildBundleCommand command = await runCommandIn(projectPath);
+
+ expect(await command.usageValues,
+ containsPair(kCommandBuildBundleIsModule, 'true'));
+ }, timeout: allowForCreateFlutterProject);
+
+ testUsingContext('indicate that project is not a module', () async {
+ final String projectPath = await createProject(tempDir,
+ arguments: <String>['--no-pub', '--template=app']);
+
+ final BuildBundleCommand command = await runCommandIn(projectPath);
+
+ expect(await command.usageValues,
+ containsPair(kCommandBuildBundleIsModule, 'false'));
+ }, timeout: allowForCreateFlutterProject);
+
+ testUsingContext('indicate the target platform', () async {
+ final String projectPath = await createProject(tempDir,
+ arguments: <String>['--no-pub', '--template=app']);
+
+ final BuildBundleCommand command = await runCommandIn(projectPath);
+
+ expect(await command.usageValues,
+ containsPair(kCommandBuildBundleTargetPlatform, 'android-arm'));
+ }, timeout: allowForCreateFlutterProject);
+ });
+}
+
+class MockBundleBuilder extends Mock implements BundleBuilder {}
diff --git a/packages/flutter_tools/test/general.shard/commands/build_fuchsia_test.dart b/packages/flutter_tools/test/general.shard/commands/build_fuchsia_test.dart
new file mode 100644
index 0000000..3734d04
--- /dev/null
+++ b/packages/flutter_tools/test/general.shard/commands/build_fuchsia_test.dart
@@ -0,0 +1,237 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'package:file/memory.dart';
+import 'package:flutter_tools/src/base/common.dart';
+import 'package:flutter_tools/src/base/file_system.dart';
+import 'package:flutter_tools/src/base/platform.dart';
+import 'package:flutter_tools/src/build_info.dart';
+import 'package:flutter_tools/src/cache.dart';
+import 'package:flutter_tools/src/commands/build.dart';
+import 'package:flutter_tools/src/fuchsia/fuchsia_kernel_compiler.dart';
+import 'package:flutter_tools/src/fuchsia/fuchsia_pm.dart';
+import 'package:flutter_tools/src/fuchsia/fuchsia_sdk.dart';
+import 'package:flutter_tools/src/project.dart';
+import 'package:meta/meta.dart';
+import 'package:mockito/mockito.dart';
+
+import '../../src/common.dart';
+import '../../src/context.dart';
+import '../../src/mocks.dart';
+
+void main() {
+ Cache.disableLocking();
+
+ MemoryFileSystem memoryFileSystem;
+ MockPlatform linuxPlatform;
+ MockPlatform windowsPlatform;
+ MockFuchsiaSdk fuchsiaSdk;
+ MockFuchsiaArtifacts fuchsiaArtifacts;
+ MockFuchsiaArtifacts fuchsiaArtifactsNoCompiler;
+
+ setUp(() {
+ memoryFileSystem = MemoryFileSystem();
+ linuxPlatform = MockPlatform();
+ windowsPlatform = MockPlatform();
+ fuchsiaSdk = MockFuchsiaSdk();
+ fuchsiaArtifacts = MockFuchsiaArtifacts();
+ fuchsiaArtifactsNoCompiler = MockFuchsiaArtifacts();
+
+ when(linuxPlatform.isLinux).thenReturn(true);
+ when(windowsPlatform.isWindows).thenReturn(true);
+ when(windowsPlatform.isLinux).thenReturn(false);
+ when(windowsPlatform.isMacOS).thenReturn(false);
+ when(fuchsiaArtifacts.kernelCompiler).thenReturn(MockFile());
+ when(fuchsiaArtifactsNoCompiler.kernelCompiler).thenReturn(null);
+ });
+
+ group('Fuchsia build fails gracefully when', () {
+ testUsingContext('there is no Fuchsia project',
+ () async {
+ final BuildCommand command = BuildCommand();
+ applyMocksToCommand(command);
+ expect(
+ createTestCommandRunner(command)
+ .run(const <String>['build', 'fuchsia']),
+ throwsA(isInstanceOf<ToolExit>()));
+ }, overrides: <Type, Generator>{
+ Platform: () => linuxPlatform,
+ FileSystem: () => memoryFileSystem,
+ FuchsiaArtifacts: () => fuchsiaArtifacts,
+ });
+
+ testUsingContext('there is no cmx file', () async {
+ final BuildCommand command = BuildCommand();
+ applyMocksToCommand(command);
+ fs.directory('fuchsia').createSync(recursive: true);
+ fs.file('.packages').createSync();
+ fs.file('pubspec.yaml').createSync();
+
+ expect(
+ createTestCommandRunner(command)
+ .run(const <String>['build', 'fuchsia']),
+ throwsA(isInstanceOf<ToolExit>()));
+ }, overrides: <Type, Generator>{
+ Platform: () => linuxPlatform,
+ FileSystem: () => memoryFileSystem,
+ FuchsiaArtifacts: () => fuchsiaArtifacts,
+ });
+
+ testUsingContext('on Windows platform', () async {
+ final BuildCommand command = BuildCommand();
+ applyMocksToCommand(command);
+ const String appName = 'app_name';
+ fs
+ .file(fs.path.join('fuchsia', 'meta', '$appName.cmx'))
+ ..createSync(recursive: true)
+ ..writeAsStringSync('{}');
+ fs.file('.packages').createSync();
+ final File pubspecFile = fs.file('pubspec.yaml')..createSync();
+ pubspecFile.writeAsStringSync('name: $appName');
+
+ expect(
+ createTestCommandRunner(command)
+ .run(const <String>['build', 'fuchsia']),
+ throwsA(isInstanceOf<ToolExit>()));
+ }, overrides: <Type, Generator>{
+ Platform: () => windowsPlatform,
+ FileSystem: () => memoryFileSystem,
+ FuchsiaArtifacts: () => fuchsiaArtifacts,
+ });
+
+ testUsingContext('there is no Fuchsia kernel compiler', () async {
+ final BuildCommand command = BuildCommand();
+ applyMocksToCommand(command);
+ const String appName = 'app_name';
+ fs
+ .file(fs.path.join('fuchsia', 'meta', '$appName.cmx'))
+ ..createSync(recursive: true)
+ ..writeAsStringSync('{}');
+ fs.file('.packages').createSync();
+ fs.file(fs.path.join('lib', 'main.dart')).createSync(recursive: true);
+ final File pubspecFile = fs.file('pubspec.yaml')..createSync();
+ pubspecFile.writeAsStringSync('name: $appName');
+ expect(
+ createTestCommandRunner(command)
+ .run(const <String>['build', 'fuchsia']),
+ throwsA(isInstanceOf<ToolExit>()));
+ }, overrides: <Type, Generator>{
+ Platform: () => linuxPlatform,
+ FileSystem: () => memoryFileSystem,
+ FuchsiaArtifacts: () => fuchsiaArtifactsNoCompiler,
+ });
+ });
+
+ testUsingContext('Fuchsia build parts fit together right', () async {
+ final BuildCommand command = BuildCommand();
+ applyMocksToCommand(command);
+ const String appName = 'app_name';
+ fs
+ .file(fs.path.join('fuchsia', 'meta', '$appName.cmx'))
+ ..createSync(recursive: true)
+ ..writeAsStringSync('{}');
+ fs.file('.packages').createSync();
+ fs.file(fs.path.join('lib', 'main.dart')).createSync(recursive: true);
+ final File pubspecFile = fs.file('pubspec.yaml')..createSync();
+ pubspecFile.writeAsStringSync('name: $appName');
+
+ await createTestCommandRunner(command)
+ .run(const <String>['build', 'fuchsia']);
+ final String farPath =
+ fs.path.join(getFuchsiaBuildDirectory(), 'pkg', 'app_name-0.far');
+ expect(fs.file(farPath).existsSync(), isTrue);
+ }, overrides: <Type, Generator>{
+ Platform: () => linuxPlatform,
+ FileSystem: () => memoryFileSystem,
+ FuchsiaSdk: () => fuchsiaSdk,
+ });
+}
+
+class MockPlatform extends Mock implements Platform {
+ @override
+ Map<String, String> environment = <String, String>{
+ 'FLUTTER_ROOT': '/',
+ };
+}
+
+class MockFuchsiaPM extends Mock implements FuchsiaPM {
+ String _appName;
+
+ @override
+ Future<bool> init(String buildPath, String appName) async {
+ if (!fs.directory(buildPath).existsSync()) {
+ return false;
+ }
+ fs
+ .file(fs.path.join(buildPath, 'meta', 'package'))
+ .createSync(recursive: true);
+ _appName = appName;
+ return true;
+ }
+
+ @override
+ Future<bool> genkey(String buildPath, String outKeyPath) async {
+ if (!fs.file(fs.path.join(buildPath, 'meta', 'package')).existsSync()) {
+ return false;
+ }
+ fs.file(outKeyPath).createSync(recursive: true);
+ return true;
+ }
+
+ @override
+ Future<bool> build(
+ String buildPath, String keyPath, String manifestPath) async {
+ if (!fs.file(fs.path.join(buildPath, 'meta', 'package')).existsSync() ||
+ !fs.file(keyPath).existsSync() ||
+ !fs.file(manifestPath).existsSync()) {
+ return false;
+ }
+ fs.file(fs.path.join(buildPath, 'meta.far')).createSync(recursive: true);
+ return true;
+ }
+
+ @override
+ Future<bool> archive(
+ String buildPath, String keyPath, String manifestPath) async {
+ if (!fs.file(fs.path.join(buildPath, 'meta', 'package')).existsSync() ||
+ !fs.file(keyPath).existsSync() ||
+ !fs.file(manifestPath).existsSync()) {
+ return false;
+ }
+ if (_appName == null) {
+ return false;
+ }
+ fs
+ .file(fs.path.join(buildPath, '$_appName-0.far'))
+ .createSync(recursive: true);
+ return true;
+ }
+}
+
+class MockFuchsiaKernelCompiler extends Mock implements FuchsiaKernelCompiler {
+ @override
+ Future<void> build({
+ @required FuchsiaProject fuchsiaProject,
+ @required String target, // E.g., lib/main.dart
+ BuildInfo buildInfo = BuildInfo.debug,
+ }) async {
+ final String outDir = getFuchsiaBuildDirectory();
+ final String appName = fuchsiaProject.project.manifest.appName;
+ final String manifestPath = fs.path.join(outDir, '$appName.dilpmanifest');
+ fs.file(manifestPath).createSync(recursive: true);
+ }
+}
+
+class MockFuchsiaSdk extends Mock implements FuchsiaSdk {
+ @override
+ final FuchsiaPM fuchsiaPM = MockFuchsiaPM();
+
+ @override
+ final FuchsiaKernelCompiler fuchsiaKernelCompiler =
+ MockFuchsiaKernelCompiler();
+}
+
+class MockFile extends Mock implements File {}
+
+class MockFuchsiaArtifacts extends Mock implements FuchsiaArtifacts {}
diff --git a/packages/flutter_tools/test/general.shard/commands/build_linux_test.dart b/packages/flutter_tools/test/general.shard/commands/build_linux_test.dart
new file mode 100644
index 0000000..638a20b
--- /dev/null
+++ b/packages/flutter_tools/test/general.shard/commands/build_linux_test.dart
@@ -0,0 +1,125 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'package:file/memory.dart';
+import 'package:flutter_tools/src/base/common.dart';
+import 'package:flutter_tools/src/base/file_system.dart';
+import 'package:flutter_tools/src/base/io.dart';
+import 'package:flutter_tools/src/base/platform.dart';
+import 'package:flutter_tools/src/cache.dart';
+import 'package:flutter_tools/src/commands/build.dart';
+import 'package:flutter_tools/src/linux/makefile.dart';
+import 'package:flutter_tools/src/project.dart';
+import 'package:mockito/mockito.dart';
+import 'package:process/process.dart';
+
+import '../../src/common.dart';
+import '../../src/context.dart';
+import '../../src/mocks.dart';
+
+void main() {
+ MockProcessManager mockProcessManager;
+ MockProcess mockProcess;
+ MockPlatform linuxPlatform;
+ MockPlatform notLinuxPlatform;
+
+ setUpAll(() {
+ Cache.disableLocking();
+ });
+
+ setUp(() {
+ mockProcessManager = MockProcessManager();
+ mockProcess = MockProcess();
+ linuxPlatform = MockPlatform();
+ notLinuxPlatform = MockPlatform();
+ when(mockProcess.exitCode).thenAnswer((Invocation invocation) async {
+ return 0;
+ });
+ when(mockProcess.stderr).thenAnswer((Invocation invocation) {
+ return const Stream<List<int>>.empty();
+ });
+ when(mockProcess.stdout).thenAnswer((Invocation invocation) {
+ return const Stream<List<int>>.empty();
+ });
+ when(linuxPlatform.isLinux).thenReturn(true);
+ when(notLinuxPlatform.isLinux).thenReturn(false);
+ });
+
+ testUsingContext('Linux build fails when there is no linux project', () async {
+ final BuildCommand command = BuildCommand();
+ applyMocksToCommand(command);
+ expect(createTestCommandRunner(command).run(
+ const <String>['build', 'linux']
+ ), throwsA(isInstanceOf<ToolExit>()));
+ }, overrides: <Type, Generator>{
+ Platform: () => linuxPlatform,
+ FileSystem: () => MemoryFileSystem(),
+ });
+
+ testUsingContext('Linux build fails on non-linux platform', () async {
+ final BuildCommand command = BuildCommand();
+ applyMocksToCommand(command);
+ fs.file('linux/build.sh').createSync(recursive: true);
+ fs.file('pubspec.yaml').createSync();
+ fs.file('.packages').createSync();
+ fs.file(fs.path.join('lib', 'main.dart')).createSync(recursive: true);
+
+ expect(createTestCommandRunner(command).run(
+ const <String>['build', 'linux']
+ ), throwsA(isInstanceOf<ToolExit>()));
+ }, overrides: <Type, Generator>{
+ Platform: () => notLinuxPlatform,
+ FileSystem: () => MemoryFileSystem(),
+ });
+
+ testUsingContext('Linux build invokes make and writes temporary files', () async {
+ final BuildCommand command = BuildCommand();
+ applyMocksToCommand(command);
+ fs.file('linux/build.sh').createSync(recursive: true);
+ fs.file('pubspec.yaml').createSync();
+ fs.file('.packages').createSync();
+ fs.file(fs.path.join('lib', 'main.dart')).createSync(recursive: true);
+
+ when(mockProcessManager.start(<String>[
+ 'make',
+ '-C',
+ '/linux',
+ ], runInShell: true)).thenAnswer((Invocation invocation) async {
+ return mockProcess;
+ });
+
+ await createTestCommandRunner(command).run(
+ const <String>['build', 'linux']
+ );
+ expect(fs.file('linux/flutter/generated_config').existsSync(), true);
+ }, overrides: <Type, Generator>{
+ FileSystem: () => MemoryFileSystem(),
+ ProcessManager: () => mockProcessManager,
+ Platform: () => linuxPlatform,
+ });
+
+ testUsingContext('linux can extract binary name from Makefile', () async {
+ fs.file('linux/Makefile')
+ ..createSync(recursive: true)
+ ..writeAsStringSync(r'''
+# Comment
+SOMETHING_ELSE=FOO
+BINARY_NAME=fizz_bar
+''');
+ fs.file('pubspec.yaml').createSync();
+ fs.file('.packages').createSync();
+ final FlutterProject flutterProject = FlutterProject.current();
+
+ expect(makefileExecutableName(flutterProject.linux), 'fizz_bar');
+ }, overrides: <Type, Generator>{FileSystem: () => MemoryFileSystem()});
+}
+
+class MockProcessManager extends Mock implements ProcessManager {}
+class MockProcess extends Mock implements Process {}
+class MockPlatform extends Mock implements Platform {
+ @override
+ Map<String, String> environment = <String, String>{
+ 'FLUTTER_ROOT': '/',
+ };
+}
diff --git a/packages/flutter_tools/test/general.shard/commands/build_macos_test.dart b/packages/flutter_tools/test/general.shard/commands/build_macos_test.dart
new file mode 100644
index 0000000..ceb07b8
--- /dev/null
+++ b/packages/flutter_tools/test/general.shard/commands/build_macos_test.dart
@@ -0,0 +1,117 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'package:file/memory.dart';
+import 'package:flutter_tools/src/base/common.dart';
+import 'package:flutter_tools/src/base/file_system.dart';
+import 'package:flutter_tools/src/base/io.dart';
+import 'package:flutter_tools/src/base/platform.dart';
+import 'package:flutter_tools/src/build_info.dart';
+import 'package:flutter_tools/src/cache.dart';
+import 'package:flutter_tools/src/commands/build.dart';
+import 'package:flutter_tools/src/project.dart';
+import 'package:mockito/mockito.dart';
+import 'package:process/process.dart';
+
+import '../../src/common.dart';
+import '../../src/context.dart';
+import '../../src/mocks.dart';
+
+void main() {
+ MockProcessManager mockProcessManager;
+ MemoryFileSystem memoryFilesystem;
+ MockProcess mockProcess;
+ MockPlatform macosPlatform;
+ MockPlatform notMacosPlatform;
+
+ setUpAll(() {
+ Cache.disableLocking();
+ });
+
+ setUp(() {
+ mockProcessManager = MockProcessManager();
+ memoryFilesystem = MemoryFileSystem();
+ mockProcess = MockProcess();
+ macosPlatform = MockPlatform();
+ notMacosPlatform = MockPlatform();
+ when(mockProcess.exitCode).thenAnswer((Invocation invocation) async {
+ return 0;
+ });
+ when(mockProcess.stderr).thenAnswer((Invocation invocation) {
+ return const Stream<List<int>>.empty();
+ });
+ when(mockProcess.stdout).thenAnswer((Invocation invocation) {
+ return const Stream<List<int>>.empty();
+ });
+ when(macosPlatform.isMacOS).thenReturn(true);
+ when(notMacosPlatform.isMacOS).thenReturn(false);
+ });
+
+ testUsingContext('macOS build fails when there is no macos project', () async {
+ final BuildCommand command = BuildCommand();
+ applyMocksToCommand(command);
+ expect(createTestCommandRunner(command).run(
+ const <String>['build', 'macos']
+ ), throwsA(isInstanceOf<ToolExit>()));
+ }, overrides: <Type, Generator>{
+ Platform: () => macosPlatform,
+ });
+
+ testUsingContext('macOS build fails on non-macOS platform', () async {
+ final BuildCommand command = BuildCommand();
+ applyMocksToCommand(command);
+ fs.file('pubspec.yaml').createSync();
+ fs.file('.packages').createSync();
+ fs.file(fs.path.join('lib', 'main.dart')).createSync(recursive: true);
+
+ expect(createTestCommandRunner(command).run(
+ const <String>['build', 'macos']
+ ), throwsA(isInstanceOf<ToolExit>()));
+ }, overrides: <Type, Generator>{
+ Platform: () => notMacosPlatform,
+ FileSystem: () => memoryFilesystem,
+ });
+
+ testUsingContext('macOS build invokes build script', () async {
+ final BuildCommand command = BuildCommand();
+ applyMocksToCommand(command);
+ fs.directory('macos').createSync();
+ fs.file('pubspec.yaml').createSync();
+ fs.file('.packages').createSync();
+ fs.file(fs.path.join('lib', 'main.dart')).createSync(recursive: true);
+ final FlutterProject flutterProject = FlutterProject.fromDirectory(fs.currentDirectory);
+ final Directory flutterBuildDir = fs.directory(getMacOSBuildDirectory());
+
+ when(mockProcessManager.start(<String>[
+ '/usr/bin/env',
+ 'xcrun',
+ 'xcodebuild',
+ '-workspace', flutterProject.macos.xcodeWorkspace.path,
+ '-configuration', 'Debug',
+ '-scheme', 'Runner',
+ '-derivedDataPath', flutterBuildDir.absolute.path,
+ 'OBJROOT=${fs.path.join(flutterBuildDir.absolute.path, 'Build', 'Intermediates.noindex')}',
+ 'SYMROOT=${fs.path.join(flutterBuildDir.absolute.path, 'Build', 'Products')}',
+ ], runInShell: true)).thenAnswer((Invocation invocation) async {
+ return mockProcess;
+ });
+
+ await createTestCommandRunner(command).run(
+ const <String>['build', 'macos']
+ );
+ }, overrides: <Type, Generator>{
+ FileSystem: () => memoryFilesystem,
+ ProcessManager: () => mockProcessManager,
+ Platform: () => macosPlatform,
+ });
+}
+
+class MockProcessManager extends Mock implements ProcessManager {}
+class MockProcess extends Mock implements Process {}
+class MockPlatform extends Mock implements Platform {
+ @override
+ Map<String, String> environment = <String, String>{
+ 'FLUTTER_ROOT': '/',
+ };
+}
diff --git a/packages/flutter_tools/test/general.shard/commands/build_web_test.dart b/packages/flutter_tools/test/general.shard/commands/build_web_test.dart
new file mode 100644
index 0000000..2adb818
--- /dev/null
+++ b/packages/flutter_tools/test/general.shard/commands/build_web_test.dart
@@ -0,0 +1,97 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'package:flutter_tools/src/base/common.dart';
+import 'package:flutter_tools/src/base/file_system.dart';
+import 'package:flutter_tools/src/base/platform.dart';
+import 'package:flutter_tools/src/build_info.dart';
+import 'package:flutter_tools/src/cache.dart';
+import 'package:flutter_tools/src/device.dart';
+import 'package:flutter_tools/src/project.dart';
+import 'package:flutter_tools/src/resident_runner.dart';
+import 'package:flutter_tools/src/resident_web_runner.dart';
+import 'package:flutter_tools/src/version.dart';
+import 'package:flutter_tools/src/web/compile.dart';
+import 'package:mockito/mockito.dart';
+
+import '../../src/common.dart';
+import '../../src/testbed.dart';
+
+void main() {
+ MockWebCompilationProxy mockWebCompilationProxy;
+ Testbed testbed;
+ MockPlatform mockPlatform;
+
+ setUpAll(() {
+ Cache.disableLocking();
+ });
+
+ setUp(() {
+ mockWebCompilationProxy = MockWebCompilationProxy();
+ testbed = Testbed(setup: () {
+ fs.file('pubspec.yaml')
+ ..createSync()
+ ..writeAsStringSync('name: foo\n');
+ fs.file('.packages').createSync();
+ fs.file(fs.path.join('web', 'index.html')).createSync(recursive: true);
+ fs.file(fs.path.join('lib', 'main.dart')).createSync(recursive: true);
+ when(mockWebCompilationProxy.initialize(
+ projectDirectory: anyNamed('projectDirectory'),
+ release: anyNamed('release')
+ )).thenAnswer((Invocation invocation) {
+ final String path = fs.path.join('.dart_tool', 'build', 'flutter_web', 'foo', 'lib', 'main_web_entrypoint.dart.js');
+ fs.file(path).createSync(recursive: true);
+ fs.file('$path.map').createSync();
+ return Future<bool>.value(true);
+ });
+ }, overrides: <Type, Generator>{
+ WebCompilationProxy: () => mockWebCompilationProxy,
+ Platform: () => mockPlatform,
+ FlutterVersion: () => MockFlutterVersion(),
+ });
+ });
+
+ test('Refuses to build for web when missing index.html', () => testbed.run(() async {
+ fs.file(fs.path.join('web', 'index.html')).deleteSync();
+
+ expect(buildWeb(
+ FlutterProject.current(),
+ fs.path.join('lib', 'main.dart'),
+ BuildInfo.debug,
+ ), throwsA(isInstanceOf<ToolExit>()));
+ }));
+
+ test('Refuses to build using runner when missing index.html', () => testbed.run(() async {
+ fs.file(fs.path.join('web', 'index.html')).deleteSync();
+
+ final ResidentWebRunner runner = ResidentWebRunner(
+ <FlutterDevice>[],
+ flutterProject: FlutterProject.current(),
+ ipv6: false,
+ debuggingOptions: DebuggingOptions.enabled(BuildInfo.debug),
+ );
+ expect(await runner.run(), 1);
+ }));
+
+ test('Can build for web', () => testbed.run(() async {
+
+ await buildWeb(
+ FlutterProject.current(),
+ fs.path.join('lib', 'main.dart'),
+ BuildInfo.debug,
+ );
+ }));
+}
+
+class MockWebCompilationProxy extends Mock implements WebCompilationProxy {}
+class MockPlatform extends Mock implements Platform {
+ @override
+ Map<String, String> environment = <String, String>{
+ 'FLUTTER_ROOT': '/',
+ };
+}
+class MockFlutterVersion extends Mock implements FlutterVersion {
+ @override
+ bool get isMaster => true;
+}
diff --git a/packages/flutter_tools/test/general.shard/commands/build_windows_test.dart b/packages/flutter_tools/test/general.shard/commands/build_windows_test.dart
new file mode 100644
index 0000000..301fa7d
--- /dev/null
+++ b/packages/flutter_tools/test/general.shard/commands/build_windows_test.dart
@@ -0,0 +1,146 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'package:file/memory.dart';
+import 'package:flutter_tools/src/base/common.dart';
+import 'package:flutter_tools/src/base/file_system.dart';
+import 'package:flutter_tools/src/base/io.dart';
+import 'package:flutter_tools/src/base/platform.dart';
+import 'package:flutter_tools/src/cache.dart';
+import 'package:flutter_tools/src/commands/build.dart';
+import 'package:flutter_tools/src/windows/visual_studio.dart';
+import 'package:mockito/mockito.dart';
+import 'package:process/process.dart';
+import 'package:xml/xml.dart' as xml;
+
+import '../../src/common.dart';
+import '../../src/context.dart';
+import '../../src/mocks.dart';
+
+void main() {
+ MockProcessManager mockProcessManager;
+ MemoryFileSystem memoryFilesystem;
+ MockProcess mockProcess;
+ MockPlatform windowsPlatform;
+ MockPlatform notWindowsPlatform;
+ MockVisualStudio mockVisualStudio;
+ const String solutionPath = r'C:\windows\Runner.sln';
+ const String visualStudioPath = r'C:\Program Files (x86)\Microsoft Visual Studio\2017\Community';
+ const String vcvarsPath = visualStudioPath + r'\VC\Auxiliary\Build\vcvars64.bat';
+
+ setUpAll(() {
+ Cache.disableLocking();
+ });
+
+ setUp(() {
+ mockProcessManager = MockProcessManager();
+ memoryFilesystem = MemoryFileSystem(style: FileSystemStyle.windows);
+ mockProcess = MockProcess();
+ windowsPlatform = MockPlatform()
+ ..environment['PROGRAMFILES(X86)'] = r'C:\Program Files (x86)\';
+ notWindowsPlatform = MockPlatform();
+ mockVisualStudio = MockVisualStudio();
+ when(mockProcess.exitCode).thenAnswer((Invocation invocation) async {
+ return 0;
+ });
+ when(mockProcess.stderr).thenAnswer((Invocation invocation) {
+ return const Stream<List<int>>.empty();
+ });
+ when(mockProcess.stdout).thenAnswer((Invocation invocation) {
+ return const Stream<List<int>>.empty();
+ });
+ when(windowsPlatform.isWindows).thenReturn(true);
+ when(notWindowsPlatform.isWindows).thenReturn(false);
+ });
+
+ testUsingContext('Windows build fails when there is no vcvars64.bat', () async {
+ final BuildCommand command = BuildCommand();
+ applyMocksToCommand(command);
+ fs.file(solutionPath).createSync(recursive: true);
+ expect(createTestCommandRunner(command).run(
+ const <String>['build', 'windows']
+ ), throwsA(isInstanceOf<ToolExit>()));
+ }, overrides: <Type, Generator>{
+ Platform: () => windowsPlatform,
+ FileSystem: () => memoryFilesystem,
+ VisualStudio: () => mockVisualStudio,
+ });
+
+ testUsingContext('Windows build fails when there is no windows project', () async {
+ final BuildCommand command = BuildCommand();
+ applyMocksToCommand(command);
+ when(mockVisualStudio.vcvarsPath).thenReturn(vcvarsPath);
+ expect(createTestCommandRunner(command).run(
+ const <String>['build', 'windows']
+ ), throwsA(isInstanceOf<ToolExit>()));
+ }, overrides: <Type, Generator>{
+ Platform: () => windowsPlatform,
+ FileSystem: () => memoryFilesystem,
+ VisualStudio: () => mockVisualStudio,
+ });
+
+ testUsingContext('Windows build fails on non windows platform', () async {
+ final BuildCommand command = BuildCommand();
+ applyMocksToCommand(command);
+ fs.file(solutionPath).createSync(recursive: true);
+ when(mockVisualStudio.vcvarsPath).thenReturn(vcvarsPath);
+ fs.file('pubspec.yaml').createSync();
+ fs.file('.packages').createSync();
+ fs.file(fs.path.join('lib', 'main.dart')).createSync(recursive: true);
+
+ expect(createTestCommandRunner(command).run(
+ const <String>['build', 'windows']
+ ), throwsA(isInstanceOf<ToolExit>()));
+ }, overrides: <Type, Generator>{
+ Platform: () => notWindowsPlatform,
+ FileSystem: () => memoryFilesystem,
+ VisualStudio: () => mockVisualStudio,
+ });
+
+ testUsingContext('Windows build invokes msbuild and writes generated files', () async {
+ final BuildCommand command = BuildCommand();
+ applyMocksToCommand(command);
+ fs.file(solutionPath).createSync(recursive: true);
+ when(mockVisualStudio.vcvarsPath).thenReturn(vcvarsPath);
+ fs.file('pubspec.yaml').createSync();
+ fs.file('.packages').createSync();
+ fs.file(fs.path.join('lib', 'main.dart')).createSync(recursive: true);
+
+ when(mockProcessManager.start(<String>[
+ r'C:\packages\flutter_tools\bin\vs_build.bat',
+ vcvarsPath,
+ fs.path.basename(solutionPath),
+ 'Release',
+ ], workingDirectory: fs.path.dirname(solutionPath))).thenAnswer((Invocation invocation) async {
+ return mockProcess;
+ });
+
+ await createTestCommandRunner(command).run(
+ const <String>['build', 'windows']
+ );
+
+ // Spot-check important elements from the properties file.
+ final File propsFile = fs.file(r'C:\windows\flutter\Generated.props');
+ expect(propsFile.existsSync(), true);
+ final xml.XmlDocument props = xml.parse(propsFile.readAsStringSync());
+ expect(props.findAllElements('PropertyGroup').first.getAttribute('Label'), 'UserMacros');
+ expect(props.findAllElements('ItemGroup').length, 1);
+ expect(props.findAllElements('FLUTTER_ROOT').first.text, r'C:\');
+ }, overrides: <Type, Generator>{
+ FileSystem: () => memoryFilesystem,
+ ProcessManager: () => mockProcessManager,
+ Platform: () => windowsPlatform,
+ VisualStudio: () => mockVisualStudio,
+ });
+}
+
+class MockProcessManager extends Mock implements ProcessManager {}
+class MockProcess extends Mock implements Process {}
+class MockPlatform extends Mock implements Platform {
+ @override
+ Map<String, String> environment = <String, String>{
+ 'FLUTTER_ROOT': r'C:\',
+ };
+}
+class MockVisualStudio extends Mock implements VisualStudio {}
diff --git a/packages/flutter_tools/test/general.shard/commands/clean_test.dart b/packages/flutter_tools/test/general.shard/commands/clean_test.dart
new file mode 100644
index 0000000..85926c7
--- /dev/null
+++ b/packages/flutter_tools/test/general.shard/commands/clean_test.dart
@@ -0,0 +1,51 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'package:flutter_tools/src/base/config.dart';
+import 'package:flutter_tools/src/base/context.dart';
+import 'package:flutter_tools/src/base/file_system.dart';
+import 'package:flutter_tools/src/commands/clean.dart';
+import 'package:mockito/mockito.dart';
+
+import '../../src/common.dart';
+import '../../src/context.dart';
+
+
+void main() {
+ final MockFileSystem mockFileSystem = MockFileSystem();
+ final MockDirectory currentDirectory = MockDirectory();
+ final MockDirectory exampleDirectory = MockDirectory();
+ final MockDirectory buildDirectory = MockDirectory();
+ final MockDirectory dartToolDirectory = MockDirectory();
+ final MockFile pubspec = MockFile();
+ final MockFile examplePubspec = MockFile();
+
+ when(mockFileSystem.currentDirectory).thenReturn(currentDirectory);
+ when(currentDirectory.childDirectory('example')).thenReturn(exampleDirectory);
+ when(currentDirectory.childFile('pubspec.yaml')).thenReturn(pubspec);
+ when(pubspec.path).thenReturn('/test/pubspec.yaml');
+ when(exampleDirectory.childFile('pubspec.yaml')).thenReturn(examplePubspec);
+ when(currentDirectory.childDirectory('.dart_tool')).thenReturn(dartToolDirectory);
+ when(examplePubspec.path).thenReturn('/test/example/pubspec.yaml');
+ when(mockFileSystem.isFileSync('/test/pubspec.yaml')).thenReturn(false);
+ when(mockFileSystem.isFileSync('/test/example/pubspec.yaml')).thenReturn(false);
+ when(mockFileSystem.directory('build')).thenReturn(buildDirectory);
+ when(mockFileSystem.path).thenReturn(fs.path);
+ when(buildDirectory.existsSync()).thenReturn(true);
+ when(dartToolDirectory.existsSync()).thenReturn(true);
+ group(CleanCommand, () {
+ testUsingContext('removes build and .dart_tool directories', () async {
+ await CleanCommand().runCommand();
+ verify(buildDirectory.deleteSync(recursive: true)).called(1);
+ verify(dartToolDirectory.deleteSync(recursive: true)).called(1);
+ }, overrides: <Type, Generator>{
+ FileSystem: () => mockFileSystem,
+ Config: () => null,
+ });
+ });
+}
+
+class MockFileSystem extends Mock implements FileSystem {}
+class MockFile extends Mock implements File {}
+class MockDirectory extends Mock implements Directory {}
diff --git a/packages/flutter_tools/test/general.shard/commands/config_test.dart b/packages/flutter_tools/test/general.shard/commands/config_test.dart
new file mode 100644
index 0000000..b95b4ed
--- /dev/null
+++ b/packages/flutter_tools/test/general.shard/commands/config_test.dart
@@ -0,0 +1,56 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'dart:convert';
+
+import 'package:flutter_tools/src/android/android_sdk.dart';
+import 'package:flutter_tools/src/android/android_studio.dart';
+import 'package:flutter_tools/src/base/context.dart';
+import 'package:flutter_tools/src/base/logger.dart';
+import 'package:flutter_tools/src/commands/config.dart';
+import 'package:mockito/mockito.dart';
+
+import '../../src/common.dart';
+import '../../src/context.dart';
+
+void main() {
+ MockAndroidStudio mockAndroidStudio;
+ MockAndroidSdk mockAndroidSdk;
+
+ setUp(() {
+ mockAndroidStudio = MockAndroidStudio();
+ mockAndroidSdk = MockAndroidSdk();
+ });
+
+ group('config', () {
+ testUsingContext('machine flag', () async {
+ final BufferLogger logger = context.get<Logger>();
+ final ConfigCommand command = ConfigCommand();
+ await command.handleMachine();
+
+ expect(logger.statusText, isNotEmpty);
+ final dynamic jsonObject = json.decode(logger.statusText);
+ expect(jsonObject, isMap);
+
+ expect(jsonObject.containsKey('android-studio-dir'), true);
+ expect(jsonObject['android-studio-dir'], isNotNull);
+
+ expect(jsonObject.containsKey('android-sdk'), true);
+ expect(jsonObject['android-sdk'], isNotNull);
+ }, overrides: <Type, Generator>{
+ AndroidStudio: () => mockAndroidStudio,
+ AndroidSdk: () => mockAndroidSdk,
+ });
+ });
+}
+
+class MockAndroidStudio extends Mock implements AndroidStudio, Comparable<AndroidStudio> {
+ @override
+ String get directory => 'path/to/android/stdio';
+}
+
+class MockAndroidSdk extends Mock implements AndroidSdk {
+ @override
+ String get directory => 'path/to/android/sdk';
+}
diff --git a/packages/flutter_tools/test/general.shard/commands/create_test.dart b/packages/flutter_tools/test/general.shard/commands/create_test.dart
new file mode 100644
index 0000000..7a8c087
--- /dev/null
+++ b/packages/flutter_tools/test/general.shard/commands/create_test.dart
@@ -0,0 +1,1266 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// This test performs too poorly to run with coverage enabled.
+@Tags(<String>['create', 'no_coverage'])
+import 'dart:async';
+import 'dart:convert';
+import 'dart:typed_data';
+
+import 'package:args/command_runner.dart';
+import 'package:flutter_tools/src/base/file_system.dart';
+import 'package:flutter_tools/src/base/io.dart';
+import 'package:flutter_tools/src/base/net.dart';
+import 'package:flutter_tools/src/base/platform.dart';
+import 'package:flutter_tools/src/cache.dart';
+import 'package:flutter_tools/src/commands/create.dart';
+import 'package:flutter_tools/src/dart/sdk.dart';
+import 'package:flutter_tools/src/project.dart';
+import 'package:flutter_tools/src/version.dart';
+
+import 'package:mockito/mockito.dart';
+import 'package:process/process.dart';
+
+import '../../src/common.dart';
+import '../../src/context.dart';
+
+
+const String frameworkRevision = '12345678';
+const String frameworkChannel = 'omega';
+final Generator _kNoColorTerminalPlatform = () => FakePlatform.fromPlatform(const LocalPlatform())..stdoutSupportsAnsi = false;
+final Map<Type, Generator> noColorTerminalOverride = <Type, Generator>{
+ Platform: _kNoColorTerminalPlatform,
+};
+const String samplesIndexJson = '''[
+ { "id": "sample1" },
+ { "id": "sample2" }
+]''';
+
+void main() {
+ Directory tempDir;
+ Directory projectDir;
+ FlutterVersion mockFlutterVersion;
+ LoggingProcessManager loggingProcessManager;
+
+ setUpAll(() {
+ Cache.disableLocking();
+ });
+
+ setUp(() {
+ loggingProcessManager = LoggingProcessManager();
+ tempDir = fs.systemTempDirectory.createTempSync('flutter_tools_create_test.');
+ projectDir = tempDir.childDirectory('flutter_project');
+ mockFlutterVersion = MockFlutterVersion();
+ });
+
+ tearDown(() {
+ tryToDelete(tempDir);
+ });
+
+ // Verify that we create a default project ('app') that is
+ // well-formed.
+ testUsingContext('can create a default project', () async {
+ await _createAndAnalyzeProject(
+ projectDir,
+ <String>[],
+ <String>[
+ 'android/app/src/main/java/com/example/flutter_project/MainActivity.java',
+ 'android/app/src/main/java/io/flutter/plugins/GeneratedPluginRegistrant.java',
+ 'flutter_project.iml',
+ 'ios/Flutter/AppFrameworkInfo.plist',
+ 'ios/Runner/AppDelegate.m',
+ 'ios/Runner/GeneratedPluginRegistrant.h',
+ 'lib/main.dart',
+ ],
+ );
+ return _runFlutterTest(projectDir);
+ }, timeout: allowForRemotePubInvocation);
+
+ testUsingContext('can create a default project if empty directory exists', () async {
+ await projectDir.create(recursive: true);
+ await _createAndAnalyzeProject(
+ projectDir,
+ <String>[],
+ <String>[
+ 'android/app/src/main/java/com/example/flutter_project/MainActivity.java',
+ 'android/app/src/main/java/io/flutter/plugins/GeneratedPluginRegistrant.java',
+ 'flutter_project.iml',
+ 'ios/Flutter/AppFrameworkInfo.plist',
+ 'ios/Runner/AppDelegate.m',
+ 'ios/Runner/GeneratedPluginRegistrant.h',
+ ],
+ );
+ }, timeout: allowForRemotePubInvocation);
+
+ testUsingContext('creates a module project correctly', () async {
+ await _createAndAnalyzeProject(projectDir, <String>[
+ '--template=module',
+ ], <String>[
+ '.android/app/',
+ '.gitignore',
+ '.ios/Flutter',
+ '.metadata',
+ 'lib/main.dart',
+ 'pubspec.yaml',
+ 'README.md',
+ 'test/widget_test.dart',
+ ], unexpectedPaths: <String>[
+ 'android/',
+ 'ios/',
+ ]);
+ return _runFlutterTest(projectDir);
+ }, timeout: allowForRemotePubInvocation);
+
+ testUsingContext('cannot create a project if non-empty non-project directory exists with .metadata', () async {
+ await projectDir.absolute.childDirectory('blag').create(recursive: true);
+ await projectDir.absolute.childFile('.metadata').writeAsString('project_type: blag\n');
+ expect(
+ () async => await _createAndAnalyzeProject(projectDir, <String>[], <String>[], unexpectedPaths: <String>[
+ 'android/',
+ 'ios/',
+ '.android/',
+ '.ios/',
+ ]),
+ throwsToolExit(message: 'Sorry, unable to detect the type of project to recreate'));
+ }, timeout: allowForRemotePubInvocation, overrides: noColorTerminalOverride);
+
+ testUsingContext('Will create an app project if non-empty non-project directory exists without .metadata', () async {
+ await projectDir.absolute.childDirectory('blag').create(recursive: true);
+ await projectDir.absolute.childDirectory('.idea').create(recursive: true);
+ await _createAndAnalyzeProject(projectDir, <String>[], <String>[
+ 'android/app/src/main/java/com/example/flutter_project/MainActivity.java',
+ 'android/app/src/main/java/io/flutter/plugins/GeneratedPluginRegistrant.java',
+ 'flutter_project.iml',
+ 'ios/Flutter/AppFrameworkInfo.plist',
+ 'ios/Runner/AppDelegate.m',
+ 'ios/Runner/GeneratedPluginRegistrant.h',
+ ], unexpectedPaths: <String>[
+ '.android/',
+ '.ios/',
+ ]);
+ }, timeout: allowForRemotePubInvocation);
+
+ testUsingContext('detects and recreates an app project correctly', () async {
+ await projectDir.absolute.childDirectory('lib').create(recursive: true);
+ await projectDir.absolute.childDirectory('ios').create(recursive: true);
+ await _createAndAnalyzeProject(projectDir, <String>[], <String>[
+ 'android/app/src/main/java/com/example/flutter_project/MainActivity.java',
+ 'android/app/src/main/java/io/flutter/plugins/GeneratedPluginRegistrant.java',
+ 'flutter_project.iml',
+ 'ios/Flutter/AppFrameworkInfo.plist',
+ 'ios/Runner/AppDelegate.m',
+ 'ios/Runner/GeneratedPluginRegistrant.h',
+ ], unexpectedPaths: <String>[
+ '.android/',
+ '.ios/',
+ ]);
+ }, timeout: allowForRemotePubInvocation);
+
+ testUsingContext('detects and recreates a plugin project correctly', () async {
+ await projectDir.create(recursive: true);
+ await projectDir.absolute.childFile('.metadata').writeAsString('project_type: plugin\n');
+ return _createAndAnalyzeProject(
+ projectDir,
+ <String>[],
+ <String>[
+ 'android/src/main/java/com/example/flutter_project/FlutterProjectPlugin.java',
+ 'example/android/app/src/main/java/com/example/flutter_project_example/MainActivity.java',
+ 'example/ios/Runner/AppDelegate.h',
+ 'example/ios/Runner/AppDelegate.m',
+ 'example/ios/Runner/main.m',
+ 'example/lib/main.dart',
+ 'flutter_project.iml',
+ 'ios/Classes/FlutterProjectPlugin.h',
+ 'ios/Classes/FlutterProjectPlugin.m',
+ 'lib/flutter_project.dart',
+ ],
+ );
+ }, timeout: allowForRemotePubInvocation);
+
+ testUsingContext('detects and recreates a package project correctly', () async {
+ await projectDir.create(recursive: true);
+ await projectDir.absolute.childFile('.metadata').writeAsString('project_type: package\n');
+ return _createAndAnalyzeProject(
+ projectDir,
+ <String>[],
+ <String>[
+ 'lib/flutter_project.dart',
+ 'test/flutter_project_test.dart',
+ ],
+ unexpectedPaths: <String>[
+ 'android/app/src/main/java/com/example/flutter_project/MainActivity.java',
+ 'android/src/main/java/com/example/flutter_project/FlutterProjectPlugin.java',
+ 'example/android/app/src/main/java/com/example/flutter_project_example/MainActivity.java',
+ 'example/ios/Runner/AppDelegate.h',
+ 'example/ios/Runner/AppDelegate.m',
+ 'example/ios/Runner/main.m',
+ 'example/lib/main.dart',
+ 'ios/Classes/FlutterProjectPlugin.h',
+ 'ios/Classes/FlutterProjectPlugin.m',
+ 'ios/Runner/AppDelegate.h',
+ 'ios/Runner/AppDelegate.m',
+ 'ios/Runner/main.m',
+ 'lib/main.dart',
+ 'test/widget_test.dart',
+ ],
+ );
+ }, timeout: allowForRemotePubInvocation);
+
+ testUsingContext('kotlin/swift legacy app project', () async {
+ return _createProject(
+ projectDir,
+ <String>['--no-pub', '--template=app', '--android-language=kotlin', '--ios-language=swift'],
+ <String>[
+ 'android/app/src/main/kotlin/com/example/flutter_project/MainActivity.kt',
+ 'ios/Runner/AppDelegate.swift',
+ 'ios/Runner/Runner-Bridging-Header.h',
+ 'lib/main.dart',
+ '.idea/libraries/KotlinJavaRuntime.xml',
+ ],
+ unexpectedPaths: <String>[
+ 'android/app/src/main/java/com/example/flutter_project/MainActivity.java',
+ 'ios/Runner/AppDelegate.h',
+ 'ios/Runner/AppDelegate.m',
+ 'ios/Runner/main.m',
+ ],
+ );
+ }, timeout: allowForCreateFlutterProject);
+
+ testUsingContext('can create a package project', () async {
+ await _createAndAnalyzeProject(
+ projectDir,
+ <String>['--template=package'],
+ <String>[
+ 'lib/flutter_project.dart',
+ 'test/flutter_project_test.dart',
+ ],
+ unexpectedPaths: <String>[
+ 'android/app/src/main/java/com/example/flutter_project/MainActivity.java',
+ 'android/src/main/java/com/example/flutter_project/FlutterProjectPlugin.java',
+ 'example/android/app/src/main/java/com/example/flutter_project_example/MainActivity.java',
+ 'example/ios/Runner/AppDelegate.h',
+ 'example/ios/Runner/AppDelegate.m',
+ 'example/ios/Runner/main.m',
+ 'example/lib/main.dart',
+ 'ios/Classes/FlutterProjectPlugin.h',
+ 'ios/Classes/FlutterProjectPlugin.m',
+ 'ios/Runner/AppDelegate.h',
+ 'ios/Runner/AppDelegate.m',
+ 'ios/Runner/main.m',
+ 'lib/main.dart',
+ 'test/widget_test.dart',
+ ],
+ );
+ return _runFlutterTest(projectDir);
+ }, timeout: allowForRemotePubInvocation);
+
+ testUsingContext('can create a plugin project', () async {
+ await _createAndAnalyzeProject(
+ projectDir,
+ <String>['--template=plugin'],
+ <String>[
+ 'android/src/main/java/com/example/flutter_project/FlutterProjectPlugin.java',
+ 'example/android/app/src/main/java/com/example/flutter_project_example/MainActivity.java',
+ 'example/ios/Runner/AppDelegate.h',
+ 'example/ios/Runner/AppDelegate.m',
+ 'example/ios/Runner/main.m',
+ 'example/lib/main.dart',
+ 'flutter_project.iml',
+ 'ios/Classes/FlutterProjectPlugin.h',
+ 'ios/Classes/FlutterProjectPlugin.m',
+ 'lib/flutter_project.dart',
+ ],
+ );
+ return _runFlutterTest(projectDir.childDirectory('example'));
+ }, timeout: allowForRemotePubInvocation);
+
+ testUsingContext('kotlin/swift plugin project', () async {
+ return _createProject(
+ projectDir,
+ <String>['--no-pub', '--template=plugin', '-a', 'kotlin', '--ios-language', 'swift'],
+ <String>[
+ 'android/src/main/kotlin/com/example/flutter_project/FlutterProjectPlugin.kt',
+ 'example/android/app/src/main/kotlin/com/example/flutter_project_example/MainActivity.kt',
+ 'example/ios/Runner/AppDelegate.swift',
+ 'example/ios/Runner/Runner-Bridging-Header.h',
+ 'example/lib/main.dart',
+ 'ios/Classes/FlutterProjectPlugin.h',
+ 'ios/Classes/FlutterProjectPlugin.m',
+ 'ios/Classes/SwiftFlutterProjectPlugin.swift',
+ 'lib/flutter_project.dart',
+ ],
+ unexpectedPaths: <String>[
+ 'android/src/main/java/com/example/flutter_project/FlutterProjectPlugin.java',
+ 'example/android/app/src/main/java/com/example/flutter_project_example/MainActivity.java',
+ 'example/ios/Runner/AppDelegate.h',
+ 'example/ios/Runner/AppDelegate.m',
+ 'example/ios/Runner/main.m',
+ ],
+ );
+ }, timeout: allowForCreateFlutterProject);
+
+ testUsingContext('plugin project with custom org', () async {
+ return _createProject(
+ projectDir,
+ <String>['--no-pub', '--template=plugin', '--org', 'com.bar.foo'],
+ <String>[
+ 'android/src/main/java/com/bar/foo/flutter_project/FlutterProjectPlugin.java',
+ 'example/android/app/src/main/java/com/bar/foo/flutter_project_example/MainActivity.java',
+ ],
+ unexpectedPaths: <String>[
+ 'android/src/main/java/com/example/flutter_project/FlutterProjectPlugin.java',
+ 'example/android/app/src/main/java/com/example/flutter_project_example/MainActivity.java',
+ ],
+ );
+ }, timeout: allowForCreateFlutterProject);
+
+ testUsingContext('plugin project with valid custom project name', () async {
+ return _createProject(
+ projectDir,
+ <String>['--no-pub', '--template=plugin', '--project-name', 'xyz'],
+ <String>[
+ 'android/src/main/java/com/example/xyz/XyzPlugin.java',
+ 'example/android/app/src/main/java/com/example/xyz_example/MainActivity.java',
+ ],
+ unexpectedPaths: <String>[
+ 'android/src/main/java/com/example/flutter_project/FlutterProjectPlugin.java',
+ 'example/android/app/src/main/java/com/example/flutter_project_example/MainActivity.java',
+ ],
+ );
+ }, timeout: allowForCreateFlutterProject);
+
+ testUsingContext('plugin project with invalid custom project name', () async {
+ expect(
+ () => _createProject(projectDir,
+ <String>['--no-pub', '--template=plugin', '--project-name', 'xyz.xyz'],
+ <String>[],
+ ),
+ throwsToolExit(message: '"xyz.xyz" is not a valid Dart package name.'),
+ );
+ }, timeout: allowForCreateFlutterProject);
+
+ testUsingContext('legacy app project with-driver-test', () async {
+ return _createAndAnalyzeProject(
+ projectDir,
+ <String>['--with-driver-test', '--template=app'],
+ <String>['lib/main.dart'],
+ );
+ }, timeout: allowForRemotePubInvocation);
+
+ testUsingContext('module project with pub', () async {
+ return _createProject(projectDir, <String>[
+ '--template=module',
+ ], <String>[
+ '.android/build.gradle',
+ '.android/Flutter/build.gradle',
+ '.android/Flutter/src/main/AndroidManifest.xml',
+ '.android/Flutter/src/main/java/io/flutter/facade/Flutter.java',
+ '.android/Flutter/src/main/java/io/flutter/facade/FlutterFragment.java',
+ '.android/Flutter/src/main/java/io/flutter/plugins/GeneratedPluginRegistrant.java',
+ '.android/gradle.properties',
+ '.android/gradle/wrapper/gradle-wrapper.jar',
+ '.android/gradle/wrapper/gradle-wrapper.properties',
+ '.android/gradlew',
+ '.android/gradlew.bat',
+ '.android/include_flutter.groovy',
+ '.android/local.properties',
+ '.android/settings.gradle',
+ '.gitignore',
+ '.metadata',
+ '.packages',
+ 'lib/main.dart',
+ 'pubspec.lock',
+ 'pubspec.yaml',
+ 'README.md',
+ 'test/widget_test.dart',
+ ], unexpectedPaths: <String>[
+ 'android/',
+ 'ios/',
+ ]);
+ }, timeout: allowForRemotePubInvocation);
+
+
+ testUsingContext('androidx app project', () async {
+ Cache.flutterRoot = '../..';
+ when(mockFlutterVersion.frameworkRevision).thenReturn(frameworkRevision);
+ when(mockFlutterVersion.channel).thenReturn(frameworkChannel);
+
+ final CreateCommand command = CreateCommand();
+ final CommandRunner<void> runner = createTestCommandRunner(command);
+
+ await runner.run(<String>['create', '--no-pub', '--androidx', projectDir.path]);
+
+ void expectExists(String relPath) {
+ expect(fs.isFileSync('${projectDir.path}/$relPath'), true);
+ }
+
+ expectExists('android/gradle.properties');
+
+ final String actualContents = await fs.file(projectDir.path + '/android/gradle.properties').readAsString();
+
+ expect(actualContents.contains('useAndroidX'), true);
+ }, timeout: allowForCreateFlutterProject);
+
+ testUsingContext('non androidx app project', () async {
+ Cache.flutterRoot = '../..';
+ when(mockFlutterVersion.frameworkRevision).thenReturn(frameworkRevision);
+ when(mockFlutterVersion.channel).thenReturn(frameworkChannel);
+
+ final CreateCommand command = CreateCommand();
+ final CommandRunner<void> runner = createTestCommandRunner(command);
+
+ await runner.run(<String>['create', '--no-pub', '--no-androidx', projectDir.path]);
+
+ void expectExists(String relPath) {
+ expect(fs.isFileSync('${projectDir.path}/$relPath'), true);
+ }
+
+ expectExists('android/gradle.properties');
+
+ final String actualContents = await fs.file(projectDir.path + '/android/gradle.properties').readAsString();
+
+ expect(actualContents.contains('useAndroidX'), false);
+ }, timeout: allowForCreateFlutterProject);
+
+ testUsingContext('androidx app module', () async {
+ Cache.flutterRoot = '../..';
+ when(mockFlutterVersion.frameworkRevision).thenReturn(frameworkRevision);
+ when(mockFlutterVersion.channel).thenReturn(frameworkChannel);
+
+ final CreateCommand command = CreateCommand();
+ final CommandRunner<void> runner = createTestCommandRunner(command);
+
+ await runner.run(<String>['create', '--template=module', '--no-pub', '--androidx', projectDir.path]);
+
+ final FlutterProject project = FlutterProject.fromDirectory(projectDir);
+ expect(
+ project.usesAndroidX,
+ true,
+ );
+ }, timeout: allowForCreateFlutterProject);
+
+ testUsingContext('non androidx app module', () async {
+ Cache.flutterRoot = '../..';
+ when(mockFlutterVersion.frameworkRevision).thenReturn(frameworkRevision);
+ when(mockFlutterVersion.channel).thenReturn(frameworkChannel);
+
+ final CreateCommand command = CreateCommand();
+ final CommandRunner<void> runner = createTestCommandRunner(command);
+
+ await runner.run(<String>['create', '--template=module', '--no-pub', '--no-androidx', projectDir.path]);
+
+ final FlutterProject project = FlutterProject.fromDirectory(projectDir);
+ expect(
+ project.usesAndroidX,
+ false,
+ );
+ }, timeout: allowForCreateFlutterProject);
+
+ testUsingContext('androidx plugin project', () async {
+ Cache.flutterRoot = '../..';
+ when(mockFlutterVersion.frameworkRevision).thenReturn(frameworkRevision);
+ when(mockFlutterVersion.channel).thenReturn(frameworkChannel);
+
+ final CreateCommand command = CreateCommand();
+ final CommandRunner<void> runner = createTestCommandRunner(command);
+
+ await runner.run(<String>['create', '--no-pub', '--template=plugin', '--androidx', projectDir.path]);
+
+ void expectExists(String relPath) {
+ expect(fs.isFileSync('${projectDir.path}/$relPath'), true);
+ }
+
+ expectExists('android/gradle.properties');
+
+ final String actualContents = await fs.file(projectDir.path + '/android/gradle.properties').readAsString();
+
+ expect(actualContents.contains('useAndroidX'), true);
+ }, timeout: allowForCreateFlutterProject);
+
+ testUsingContext('non androidx plugin project', () async {
+ Cache.flutterRoot = '../..';
+ when(mockFlutterVersion.frameworkRevision).thenReturn(frameworkRevision);
+ when(mockFlutterVersion.channel).thenReturn(frameworkChannel);
+
+ final CreateCommand command = CreateCommand();
+ final CommandRunner<void> runner = createTestCommandRunner(command);
+
+ await runner.run(<String>['create', '--no-pub', '--template=plugin', '--no-androidx', projectDir.path]);
+
+ void expectExists(String relPath) {
+ expect(fs.isFileSync('${projectDir.path}/$relPath'), true);
+ }
+
+ expectExists('android/gradle.properties');
+
+ final String actualContents = await fs.file(projectDir.path + '/android/gradle.properties').readAsString();
+
+ expect(actualContents.contains('useAndroidX'), false);
+ }, timeout: allowForCreateFlutterProject);
+
+ testUsingContext('has correct content and formatting with module template', () async {
+ Cache.flutterRoot = '../..';
+ when(mockFlutterVersion.frameworkRevision).thenReturn(frameworkRevision);
+ when(mockFlutterVersion.channel).thenReturn(frameworkChannel);
+
+ final CreateCommand command = CreateCommand();
+ final CommandRunner<void> runner = createTestCommandRunner(command);
+
+ await runner.run(<String>['create', '--template=module', '--no-pub', '--org', 'com.foo.bar', projectDir.path]);
+
+ void expectExists(String relPath, [bool expectation = true]) {
+ expect(fs.isFileSync('${projectDir.path}/$relPath'), expectation);
+ }
+
+ expectExists('lib/main.dart');
+ expectExists('test/widget_test.dart');
+
+ final String actualContents = await fs.file(projectDir.path + '/test/widget_test.dart').readAsString();
+
+ expect(actualContents.contains('flutter_test.dart'), true);
+
+ for (FileSystemEntity file in projectDir.listSync(recursive: true)) {
+ if (file is File && file.path.endsWith('.dart')) {
+ final String original = file.readAsStringSync();
+
+ final Process process = await Process.start(
+ sdkBinaryName('dartfmt'),
+ <String>[file.path],
+ workingDirectory: projectDir.path,
+ );
+ final String formatted = await process.stdout.transform(utf8.decoder).join();
+
+ expect(original, formatted, reason: file.path);
+ }
+ }
+
+ await _runFlutterTest(projectDir, target: fs.path.join(projectDir.path, 'test', 'widget_test.dart'));
+
+ // Generated Xcode settings
+ final String xcodeConfigPath = fs.path.join('.ios', 'Flutter', 'Generated.xcconfig');
+ expectExists(xcodeConfigPath);
+ final File xcodeConfigFile = fs.file(fs.path.join(projectDir.path, xcodeConfigPath));
+ final String xcodeConfig = xcodeConfigFile.readAsStringSync();
+ expect(xcodeConfig, contains('FLUTTER_ROOT='));
+ expect(xcodeConfig, contains('FLUTTER_APPLICATION_PATH='));
+ expect(xcodeConfig, contains('FLUTTER_TARGET='));
+ // App identification
+ final String xcodeProjectPath = fs.path.join('.ios', 'Runner.xcodeproj', 'project.pbxproj');
+ expectExists(xcodeProjectPath);
+ final File xcodeProjectFile = fs.file(fs.path.join(projectDir.path, xcodeProjectPath));
+ final String xcodeProject = xcodeProjectFile.readAsStringSync();
+ expect(xcodeProject, contains('PRODUCT_BUNDLE_IDENTIFIER = com.foo.bar.flutterProject'));
+ // Xcode build system
+ final String xcodeWorkspaceSettingsPath = fs.path.join('.ios', 'Runner.xcworkspace', 'xcshareddata', 'WorkspaceSettings.xcsettings');
+ expectExists(xcodeWorkspaceSettingsPath, false);
+
+ final String versionPath = fs.path.join('.metadata');
+ expectExists(versionPath);
+ final String version = fs.file(fs.path.join(projectDir.path, versionPath)).readAsStringSync();
+ expect(version, contains('version:'));
+ expect(version, contains('revision: 12345678'));
+ expect(version, contains('channel: omega'));
+
+ // IntelliJ metadata
+ final String intelliJSdkMetadataPath = fs.path.join('.idea', 'libraries', 'Dart_SDK.xml');
+ expectExists(intelliJSdkMetadataPath);
+ final String sdkMetaContents = fs
+ .file(fs.path.join(
+ projectDir.path,
+ intelliJSdkMetadataPath,
+ ))
+ .readAsStringSync();
+ expect(sdkMetaContents, contains('<root url="file:/'));
+ expect(sdkMetaContents, contains('/bin/cache/dart-sdk/lib/core"'));
+ }, overrides: <Type, Generator>{
+ FlutterVersion: () => mockFlutterVersion,
+ Platform: _kNoColorTerminalPlatform,
+ }, timeout: allowForCreateFlutterProject);
+
+ testUsingContext('has correct content and formatting with app template', () async {
+ Cache.flutterRoot = '../..';
+ when(mockFlutterVersion.frameworkRevision).thenReturn(frameworkRevision);
+ when(mockFlutterVersion.channel).thenReturn(frameworkChannel);
+
+ final CreateCommand command = CreateCommand();
+ final CommandRunner<void> runner = createTestCommandRunner(command);
+
+ await runner.run(<String>['create', '--template=app', '--no-pub', '--org', 'com.foo.bar', projectDir.path]);
+
+ void expectExists(String relPath) {
+ expect(fs.isFileSync('${projectDir.path}/$relPath'), true);
+ }
+
+ expectExists('lib/main.dart');
+ expectExists('test/widget_test.dart');
+
+ for (FileSystemEntity file in projectDir.listSync(recursive: true)) {
+ if (file is File && file.path.endsWith('.dart')) {
+ final String original = file.readAsStringSync();
+
+ final Process process = await Process.start(
+ sdkBinaryName('dartfmt'),
+ <String>[file.path],
+ workingDirectory: projectDir.path,
+ );
+ final String formatted = await process.stdout.transform(utf8.decoder).join();
+
+ expect(original, formatted, reason: file.path);
+ }
+ }
+
+ await _runFlutterTest(projectDir, target: fs.path.join(projectDir.path, 'test', 'widget_test.dart'));
+
+ // Generated Xcode settings
+ final String xcodeConfigPath = fs.path.join('ios', 'Flutter', 'Generated.xcconfig');
+ expectExists(xcodeConfigPath);
+ final File xcodeConfigFile = fs.file(fs.path.join(projectDir.path, xcodeConfigPath));
+ final String xcodeConfig = xcodeConfigFile.readAsStringSync();
+ expect(xcodeConfig, contains('FLUTTER_ROOT='));
+ expect(xcodeConfig, contains('FLUTTER_APPLICATION_PATH='));
+ // App identification
+ final String xcodeProjectPath = fs.path.join('ios', 'Runner.xcodeproj', 'project.pbxproj');
+ expectExists(xcodeProjectPath);
+ final File xcodeProjectFile = fs.file(fs.path.join(projectDir.path, xcodeProjectPath));
+ final String xcodeProject = xcodeProjectFile.readAsStringSync();
+ expect(xcodeProject, contains('PRODUCT_BUNDLE_IDENTIFIER = com.foo.bar.flutterProject'));
+
+ final String versionPath = fs.path.join('.metadata');
+ expectExists(versionPath);
+ final String version = fs.file(fs.path.join(projectDir.path, versionPath)).readAsStringSync();
+ expect(version, contains('version:'));
+ expect(version, contains('revision: 12345678'));
+ expect(version, contains('channel: omega'));
+
+ // IntelliJ metadata
+ final String intelliJSdkMetadataPath = fs.path.join('.idea', 'libraries', 'Dart_SDK.xml');
+ expectExists(intelliJSdkMetadataPath);
+ final String sdkMetaContents = fs
+ .file(fs.path.join(
+ projectDir.path,
+ intelliJSdkMetadataPath,
+ ))
+ .readAsStringSync();
+ expect(sdkMetaContents, contains('<root url="file:/'));
+ expect(sdkMetaContents, contains('/bin/cache/dart-sdk/lib/core"'));
+ }, overrides: <Type, Generator>{
+ FlutterVersion: () => mockFlutterVersion,
+ Platform: _kNoColorTerminalPlatform,
+ }, timeout: allowForCreateFlutterProject);
+
+ testUsingContext('has correct application id for android and bundle id for ios', () async {
+ Cache.flutterRoot = '../..';
+ when(mockFlutterVersion.frameworkRevision).thenReturn(frameworkRevision);
+ when(mockFlutterVersion.channel).thenReturn(frameworkChannel);
+
+ final CreateCommand command = CreateCommand();
+ final CommandRunner<void> runner = createTestCommandRunner(command);
+
+ String tmpProjectDir = fs.path.join(tempDir.path, 'hello_flutter');
+ await runner.run(<String>['create', '--template=app', '--no-pub', '--org', 'com.example', tmpProjectDir]);
+ FlutterProject project = FlutterProject.fromDirectory(fs.directory(tmpProjectDir));
+ expect(
+ project.ios.productBundleIdentifier,
+ 'com.example.helloFlutter',
+ );
+ expect(
+ project.android.applicationId,
+ 'com.example.hello_flutter',
+ );
+
+ tmpProjectDir = fs.path.join(tempDir.path, 'test_abc');
+ await runner.run(<String>['create', '--template=app', '--no-pub', '--org', 'abc^*.1#@', tmpProjectDir]);
+ project = FlutterProject.fromDirectory(fs.directory(tmpProjectDir));
+ expect(
+ project.ios.productBundleIdentifier,
+ 'abc.1.testAbc',
+ );
+ expect(
+ project.android.applicationId,
+ 'abc.u1.test_abc',
+ );
+
+ tmpProjectDir = fs.path.join(tempDir.path, 'flutter_project');
+ await runner.run(<String>['create', '--template=app', '--no-pub', '--org', '#+^%', tmpProjectDir]);
+ project = FlutterProject.fromDirectory(fs.directory(tmpProjectDir));
+ expect(
+ project.ios.productBundleIdentifier,
+ 'flutterProject.untitled',
+ );
+ expect(
+ project.android.applicationId,
+ 'flutter_project.untitled',
+ );
+ }, overrides: <Type, Generator>{
+ FlutterVersion: () => mockFlutterVersion,
+ Platform: _kNoColorTerminalPlatform,
+ }, timeout: allowForCreateFlutterProject);
+
+ testUsingContext('can re-gen default template over existing project', () async {
+ Cache.flutterRoot = '../..';
+
+ final CreateCommand command = CreateCommand();
+ final CommandRunner<void> runner = createTestCommandRunner(command);
+
+ await runner.run(<String>['create', '--no-pub', projectDir.path]);
+
+ await runner.run(<String>['create', '--no-pub', projectDir.path]);
+
+ final String metadata = fs.file(fs.path.join(projectDir.path, '.metadata')).readAsStringSync();
+ expect(metadata, contains('project_type: app\n'));
+ }, timeout: allowForCreateFlutterProject);
+
+ testUsingContext('can re-gen default template over existing app project with no metadta and detect the type', () async {
+ Cache.flutterRoot = '../..';
+
+ final CreateCommand command = CreateCommand();
+ final CommandRunner<void> runner = createTestCommandRunner(command);
+
+ await runner.run(<String>['create', '--no-pub', '--template=app', projectDir.path]);
+
+ // Remove the .metadata to simulate an older instantiation that didn't generate those.
+ fs.file(fs.path.join(projectDir.path, '.metadata')).deleteSync();
+
+ await runner.run(<String>['create', '--no-pub', projectDir.path]);
+
+ final String metadata = fs.file(fs.path.join(projectDir.path, '.metadata')).readAsStringSync();
+ expect(metadata, contains('project_type: app\n'));
+ }, timeout: allowForCreateFlutterProject);
+
+ testUsingContext('can re-gen app template over existing app project and detect the type', () async {
+ Cache.flutterRoot = '../..';
+
+ final CreateCommand command = CreateCommand();
+ final CommandRunner<void> runner = createTestCommandRunner(command);
+
+ await runner.run(<String>['create', '--no-pub', '--template=app', projectDir.path]);
+
+ await runner.run(<String>['create', '--no-pub', projectDir.path]);
+
+ final String metadata = fs.file(fs.path.join(projectDir.path, '.metadata')).readAsStringSync();
+ expect(metadata, contains('project_type: app\n'));
+ }, timeout: allowForCreateFlutterProject);
+
+ testUsingContext('can re-gen template over existing module project and detect the type', () async {
+ Cache.flutterRoot = '../..';
+
+ final CreateCommand command = CreateCommand();
+ final CommandRunner<void> runner = createTestCommandRunner(command);
+
+ await runner.run(<String>['create', '--no-pub', '--template=module', projectDir.path]);
+
+ await runner.run(<String>['create', '--no-pub', projectDir.path]);
+
+ final String metadata = fs.file(fs.path.join(projectDir.path, '.metadata')).readAsStringSync();
+ expect(metadata, contains('project_type: module\n'));
+ }, timeout: allowForCreateFlutterProject);
+
+ testUsingContext('can re-gen default template over existing plugin project and detect the type', () async {
+ Cache.flutterRoot = '../..';
+
+ final CreateCommand command = CreateCommand();
+ final CommandRunner<void> runner = createTestCommandRunner(command);
+
+ await runner.run(<String>['create', '--no-pub', '--template=plugin', projectDir.path]);
+
+ await runner.run(<String>['create', '--no-pub', projectDir.path]);
+
+ final String metadata = fs.file(fs.path.join(projectDir.path, '.metadata')).readAsStringSync();
+ expect(metadata, contains('project_type: plugin'));
+ }, timeout: allowForCreateFlutterProject);
+
+ testUsingContext('can re-gen default template over existing package project and detect the type', () async {
+ Cache.flutterRoot = '../..';
+
+ final CreateCommand command = CreateCommand();
+ final CommandRunner<void> runner = createTestCommandRunner(command);
+
+ await runner.run(<String>['create', '--no-pub', '--template=package', projectDir.path]);
+
+ await runner.run(<String>['create', '--no-pub', projectDir.path]);
+
+ final String metadata = fs.file(fs.path.join(projectDir.path, '.metadata')).readAsStringSync();
+ expect(metadata, contains('project_type: package'));
+ }, timeout: allowForCreateFlutterProject);
+
+ testUsingContext('can re-gen module .android/ folder, reusing custom org', () async {
+ await _createProject(
+ projectDir,
+ <String>['--template=module', '--org', 'com.bar.foo'],
+ <String>[],
+ );
+ projectDir.childDirectory('.android').deleteSync(recursive: true);
+ return _createProject(
+ projectDir,
+ <String>[],
+ <String>[
+ '.android/app/src/main/java/com/bar/foo/flutter_project/host/MainActivity.java',
+ ],
+ );
+ }, timeout: allowForRemotePubInvocation);
+
+ testUsingContext('can re-gen module .ios/ folder, reusing custom org', () async {
+ await _createProject(
+ projectDir,
+ <String>['--template=module', '--org', 'com.bar.foo'],
+ <String>[],
+ );
+ projectDir.childDirectory('.ios').deleteSync(recursive: true);
+ await _createProject(projectDir, <String>[], <String>[]);
+ final FlutterProject project = FlutterProject.fromDirectory(projectDir);
+ expect(
+ project.ios.productBundleIdentifier,
+ 'com.bar.foo.flutterProject',
+ );
+ }, timeout: allowForRemotePubInvocation);
+
+ testUsingContext('can re-gen app android/ folder, reusing custom org', () async {
+ await _createProject(
+ projectDir,
+ <String>['--no-pub', '--template=app', '--org', 'com.bar.foo'],
+ <String>[],
+ );
+ projectDir.childDirectory('android').deleteSync(recursive: true);
+ return _createProject(
+ projectDir,
+ <String>['--no-pub'],
+ <String>[
+ 'android/app/src/main/java/com/bar/foo/flutter_project/MainActivity.java',
+ ],
+ unexpectedPaths: <String>[
+ 'android/app/src/main/java/com/example/flutter_project/MainActivity.java',
+ ],
+ );
+ }, timeout: allowForCreateFlutterProject);
+
+ testUsingContext('can re-gen app ios/ folder, reusing custom org', () async {
+ await _createProject(
+ projectDir,
+ <String>['--no-pub', '--template=app', '--org', 'com.bar.foo'],
+ <String>[],
+ );
+ projectDir.childDirectory('ios').deleteSync(recursive: true);
+ await _createProject(projectDir, <String>['--no-pub'], <String>[]);
+ final FlutterProject project = FlutterProject.fromDirectory(projectDir);
+ expect(
+ project.ios.productBundleIdentifier,
+ 'com.bar.foo.flutterProject',
+ );
+ }, timeout: allowForCreateFlutterProject);
+
+ testUsingContext('can re-gen plugin ios/ and example/ folders, reusing custom org', () async {
+ await _createProject(
+ projectDir,
+ <String>['--no-pub', '--template=plugin', '--org', 'com.bar.foo'],
+ <String>[],
+ );
+ projectDir.childDirectory('example').deleteSync(recursive: true);
+ projectDir.childDirectory('ios').deleteSync(recursive: true);
+ await _createProject(
+ projectDir,
+ <String>['--no-pub', '--template=plugin'],
+ <String>[
+ 'example/android/app/src/main/java/com/bar/foo/flutter_project_example/MainActivity.java',
+ 'ios/Classes/FlutterProjectPlugin.h',
+ ],
+ unexpectedPaths: <String>[
+ 'example/android/app/src/main/java/com/example/flutter_project_example/MainActivity.java',
+ 'android/src/main/java/com/example/flutter_project/FlutterProjectPlugin.java',
+ ],
+ );
+ final FlutterProject project = FlutterProject.fromDirectory(projectDir);
+ expect(
+ project.example.ios.productBundleIdentifier,
+ 'com.bar.foo.flutterProjectExample',
+ );
+ }, timeout: allowForCreateFlutterProject);
+
+ testUsingContext('fails to re-gen without specified org when org is ambiguous', () async {
+ await _createProject(
+ projectDir,
+ <String>['--no-pub', '--template=app', '--org', 'com.bar.foo'],
+ <String>[],
+ );
+ fs.directory(fs.path.join(projectDir.path, 'ios')).deleteSync(recursive: true);
+ await _createProject(
+ projectDir,
+ <String>['--no-pub', '--template=app', '--org', 'com.bar.baz'],
+ <String>[],
+ );
+ expect(
+ () => _createProject(projectDir, <String>[], <String>[]),
+ throwsToolExit(message: 'Ambiguous organization'),
+ );
+ }, timeout: allowForCreateFlutterProject);
+
+ // Verify that we help the user correct an option ordering issue
+ testUsingContext('produces sensible error message', () async {
+ Cache.flutterRoot = '../..';
+
+ final CreateCommand command = CreateCommand();
+ final CommandRunner<void> runner = createTestCommandRunner(command);
+
+ expect(
+ runner.run(<String>['create', projectDir.path, '--pub']),
+ throwsToolExit(exitCode: 2, message: 'Try moving --pub'),
+ );
+ });
+
+ testUsingContext('fails when file exists where output directory should be', () async {
+ Cache.flutterRoot = '../..';
+ final CreateCommand command = CreateCommand();
+ final CommandRunner<void> runner = createTestCommandRunner(command);
+ final File existingFile = fs.file(fs.path.join(projectDir.path, 'bad'));
+ if (!existingFile.existsSync()) {
+ existingFile.createSync(recursive: true);
+ }
+ expect(
+ runner.run(<String>['create', existingFile.path]),
+ throwsToolExit(message: 'existing file'),
+ );
+ });
+
+ testUsingContext('fails overwrite when file exists where output directory should be', () async {
+ Cache.flutterRoot = '../..';
+ final CreateCommand command = CreateCommand();
+ final CommandRunner<void> runner = createTestCommandRunner(command);
+ final File existingFile = fs.file(fs.path.join(projectDir.path, 'bad'));
+ if (!existingFile.existsSync()) {
+ existingFile.createSync(recursive: true);
+ }
+ expect(
+ runner.run(<String>['create', '--overwrite', existingFile.path]),
+ throwsToolExit(message: 'existing file'),
+ );
+ });
+
+ testUsingContext('overwrites existing directory when requested', () async {
+ Cache.flutterRoot = '../..';
+ final Directory existingDirectory = fs.directory(fs.path.join(projectDir.path, 'bad'));
+ if (!existingDirectory.existsSync()) {
+ existingDirectory.createSync(recursive: true);
+ }
+ final File existingFile = fs.file(fs.path.join(existingDirectory.path, 'lib', 'main.dart'));
+ existingFile.createSync(recursive: true);
+ await _createProject(
+ fs.directory(existingDirectory.path),
+ <String>['--overwrite'],
+ <String>[
+ 'android/app/src/main/java/io/flutter/plugins/GeneratedPluginRegistrant.java',
+ 'lib/main.dart',
+ 'ios/Flutter/AppFrameworkInfo.plist',
+ 'ios/Runner/AppDelegate.m',
+ 'ios/Runner/GeneratedPluginRegistrant.h',
+ ],
+ );
+ });
+
+ testUsingContext('fails when invalid package name', () async {
+ Cache.flutterRoot = '../..';
+ final CreateCommand command = CreateCommand();
+ final CommandRunner<void> runner = createTestCommandRunner(command);
+ expect(
+ runner.run(<String>['create', fs.path.join(projectDir.path, 'invalidName')]),
+ throwsToolExit(message: '"invalidName" is not a valid Dart package name.'),
+ );
+ });
+
+ testUsingContext(
+ 'invokes pub offline when requested',
+ () async {
+ Cache.flutterRoot = '../..';
+
+ final CreateCommand command = CreateCommand();
+ final CommandRunner<void> runner = createTestCommandRunner(command);
+
+ await runner.run(<String>['create', '--pub', '--offline', projectDir.path]);
+ expect(loggingProcessManager.commands.first, contains(matches(r'dart-sdk[\\/]bin[\\/]pub')));
+ expect(loggingProcessManager.commands.first, contains('--offline'));
+ },
+ timeout: allowForCreateFlutterProject,
+ overrides: <Type, Generator>{
+ ProcessManager: () => loggingProcessManager,
+ },
+ );
+
+ testUsingContext(
+ 'invokes pub online when offline not requested',
+ () async {
+ Cache.flutterRoot = '../..';
+
+ final CreateCommand command = CreateCommand();
+ final CommandRunner<void> runner = createTestCommandRunner(command);
+
+ await runner.run(<String>['create', '--pub', projectDir.path]);
+ expect(loggingProcessManager.commands.first, contains(matches(r'dart-sdk[\\/]bin[\\/]pub')));
+ expect(loggingProcessManager.commands.first, isNot(contains('--offline')));
+ },
+ timeout: allowForCreateFlutterProject,
+ overrides: <Type, Generator>{
+ ProcessManager: () => loggingProcessManager,
+ },
+ );
+
+ testUsingContext('can create a sample-based project', () async {
+ await _createAndAnalyzeProject(
+ projectDir,
+ <String>['--no-pub', '--sample=foo.bar.Baz'],
+ <String>[
+ 'lib/main.dart',
+ 'flutter_project.iml',
+ 'android/app/src/main/AndroidManifest.xml',
+ 'ios/Flutter/AppFrameworkInfo.plist',
+ ],
+ unexpectedPaths: <String>['test'],
+ );
+ expect(projectDir.childDirectory('lib').childFile('main.dart').readAsStringSync(),
+ contains('void main() {}'));
+ }, timeout: allowForRemotePubInvocation, overrides: <Type, Generator>{
+ HttpClientFactory: () => () => MockHttpClient(200, result: 'void main() {}'),
+ });
+
+ testUsingContext('can write samples index to disk', () async {
+ final String outputFile = fs.path.join(tempDir.path, 'flutter_samples.json');
+ final CreateCommand command = CreateCommand();
+ final CommandRunner<void> runner = createTestCommandRunner(command);
+ final List<String> args = <String>[
+ 'create',
+ '--list-samples',
+ outputFile,
+ ];
+
+ await runner.run(args);
+ final File expectedFile = fs.file(outputFile);
+ expect(expectedFile.existsSync(), isTrue);
+ expect(expectedFile.readAsStringSync(), equals(samplesIndexJson));
+ }, overrides: <Type, Generator>{
+ HttpClientFactory: () =>
+ () => MockHttpClient(200, result: samplesIndexJson),
+ });
+ testUsingContext('provides an error to the user if samples json download fails', () async {
+ final String outputFile = fs.path.join(tempDir.path, 'flutter_samples.json');
+ final CreateCommand command = CreateCommand();
+ final CommandRunner<void> runner = createTestCommandRunner(command);
+ final List<String> args = <String>[
+ 'create',
+ '--list-samples',
+ outputFile,
+ ];
+
+ await expectLater(runner.run(args), throwsToolExit(exitCode: 2, message: 'Failed to write samples'));
+ expect(fs.file(outputFile).existsSync(), isFalse);
+ }, overrides: <Type, Generator>{
+ HttpClientFactory: () =>
+ () => MockHttpClient(404, result: 'not found'),
+ });
+}
+
+
+Future<void> _createProject(
+ Directory dir,
+ List<String> createArgs,
+ List<String> expectedPaths, {
+ List<String> unexpectedPaths = const <String>[],
+}) async {
+ Cache.flutterRoot = '../../..';
+ final CreateCommand command = CreateCommand();
+ final CommandRunner<void> runner = createTestCommandRunner(command);
+ await runner.run(<String>[
+ 'create',
+ ...createArgs,
+ dir.path,
+ ]);
+
+ bool pathExists(String path) {
+ final String fullPath = fs.path.join(dir.path, path);
+ return fs.typeSync(fullPath) != FileSystemEntityType.notFound;
+ }
+
+ final List<String> failures = <String>[];
+ for (String path in expectedPaths) {
+ if (!pathExists(path)) {
+ failures.add('Path "$path" does not exist.');
+ }
+ }
+ for (String path in unexpectedPaths) {
+ if (pathExists(path)) {
+ failures.add('Path "$path" exists when it shouldn\'t.');
+ }
+ }
+ expect(failures, isEmpty, reason: failures.join('\n'));
+}
+
+Future<void> _createAndAnalyzeProject(
+ Directory dir,
+ List<String> createArgs,
+ List<String> expectedPaths, {
+ List<String> unexpectedPaths = const <String>[],
+}) async {
+ await _createProject(dir, createArgs, expectedPaths, unexpectedPaths: unexpectedPaths);
+ await _analyzeProject(dir.path);
+}
+
+Future<void> _analyzeProject(String workingDir) async {
+ final String flutterToolsPath = fs.path.absolute(fs.path.join(
+ 'bin',
+ 'flutter_tools.dart',
+ ));
+
+ final List<String> args = <String>[
+ ...dartVmFlags,
+ flutterToolsPath,
+ 'analyze',
+ ];
+
+ final ProcessResult exec = await Process.run(
+ '$dartSdkPath/bin/dart',
+ args,
+ workingDirectory: workingDir,
+ );
+ if (exec.exitCode != 0) {
+ print(exec.stdout);
+ print(exec.stderr);
+ }
+ expect(exec.exitCode, 0);
+}
+
+Future<void> _runFlutterTest(Directory workingDir, { String target }) async {
+ final String flutterToolsPath = fs.path.absolute(fs.path.join(
+ 'bin',
+ 'flutter_tools.dart',
+ ));
+
+ // While flutter test does get packages, it doesn't write version
+ // files anymore.
+ await Process.run(
+ '$dartSdkPath/bin/dart',
+ <String>[
+ ...dartVmFlags,
+ flutterToolsPath,
+ 'packages',
+ 'get',
+ ],
+ workingDirectory: workingDir.path,
+ );
+
+ final List<String> args = <String>[
+ ...dartVmFlags,
+ flutterToolsPath,
+ 'test',
+ '--no-color',
+ if (target != null) target,
+ ];
+
+ final ProcessResult exec = await Process.run(
+ '$dartSdkPath/bin/dart',
+ args,
+ workingDirectory: workingDir.path,
+ );
+ if (exec.exitCode != 0) {
+ print(exec.stdout);
+ print(exec.stderr);
+ }
+ expect(exec.exitCode, 0);
+}
+
+class MockFlutterVersion extends Mock implements FlutterVersion {}
+
+/// A ProcessManager that invokes a real process manager, but keeps
+/// track of all commands sent to it.
+class LoggingProcessManager extends LocalProcessManager {
+ List<List<String>> commands = <List<String>>[];
+
+ @override
+ Future<Process> start(
+ List<dynamic> command, {
+ String workingDirectory,
+ Map<String, String> environment,
+ bool includeParentEnvironment = true,
+ bool runInShell = false,
+ ProcessStartMode mode = ProcessStartMode.normal,
+ }) {
+ commands.add(command);
+ return super.start(
+ command,
+ workingDirectory: workingDirectory,
+ environment: environment,
+ includeParentEnvironment: includeParentEnvironment,
+ runInShell: runInShell,
+ mode: mode,
+ );
+ }
+}
+
+class MockHttpClient implements HttpClient {
+ MockHttpClient(this.statusCode, {this.result});
+
+ final int statusCode;
+ final String result;
+
+ @override
+ Future<HttpClientRequest> getUrl(Uri url) async {
+ return MockHttpClientRequest(statusCode, result: result);
+ }
+
+ @override
+ dynamic noSuchMethod(Invocation invocation) {
+ throw 'io.HttpClient - $invocation';
+ }
+}
+
+class MockHttpClientRequest implements HttpClientRequest {
+ MockHttpClientRequest(this.statusCode, {this.result});
+
+ final int statusCode;
+ final String result;
+
+ @override
+ Future<HttpClientResponse> close() async {
+ return MockHttpClientResponse(statusCode, result: result);
+ }
+
+ @override
+ dynamic noSuchMethod(Invocation invocation) {
+ throw 'io.HttpClientRequest - $invocation';
+ }
+}
+
+class MockHttpClientResponse implements HttpClientResponse {
+ MockHttpClientResponse(this.statusCode, {this.result});
+
+ @override
+ final int statusCode;
+
+ final String result;
+
+ @override
+ String get reasonPhrase => '<reason phrase>';
+
+ @override
+ HttpClientResponseCompressionState get compressionState {
+ return HttpClientResponseCompressionState.decompressed;
+ }
+
+ @override
+ StreamSubscription<Uint8List> listen(
+ void onData(Uint8List event), {
+ Function onError,
+ void onDone(),
+ bool cancelOnError,
+ }) {
+ return Stream<Uint8List>.fromIterable(<Uint8List>[Uint8List.fromList(result.codeUnits)])
+ .listen(onData, onError: onError, onDone: onDone, cancelOnError: cancelOnError);
+ }
+
+ @override
+ Future<dynamic> forEach(void Function(Uint8List element) action) {
+ action(Uint8List.fromList(result.codeUnits));
+ return Future<void>.value();
+ }
+
+ @override
+ dynamic noSuchMethod(Invocation invocation) {
+ throw 'io.HttpClientResponse - $invocation';
+ }
+}
diff --git a/packages/flutter_tools/test/general.shard/commands/create_usage_test.dart b/packages/flutter_tools/test/general.shard/commands/create_usage_test.dart
new file mode 100644
index 0000000..735cee5
--- /dev/null
+++ b/packages/flutter_tools/test/general.shard/commands/create_usage_test.dart
@@ -0,0 +1,104 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'package:args/command_runner.dart';
+import 'package:flutter_tools/src/base/file_system.dart';
+import 'package:flutter_tools/src/cache.dart';
+import 'package:flutter_tools/src/commands/create.dart';
+import 'package:flutter_tools/src/doctor.dart';
+import 'package:flutter_tools/src/usage.dart';
+
+import '../../src/common.dart';
+import '../../src/testbed.dart';
+
+
+void main() {
+ group('usageValues', () {
+ Testbed testbed;
+
+ setUpAll(() {
+ Cache.disableLocking();
+ });
+
+ setUp(() {
+ testbed = Testbed(setup: () {
+ final List<String> paths = <String>[
+ fs.path.join('flutter', 'packages', 'flutter', 'pubspec.yaml'),
+ fs.path.join('flutter', 'packages', 'flutter_driver', 'pubspec.yaml'),
+ fs.path.join('flutter', 'packages', 'flutter_test', 'pubspec.yaml'),
+ fs.path.join('flutter', 'bin', 'cache', 'artifacts', 'gradle_wrapper', 'wrapper'),
+ fs.path.join('usr', 'local', 'bin', 'adb'),
+ fs.path.join('Android', 'platform-tools', 'foo'),
+ ];
+ for (String path in paths) {
+ fs.file(path).createSync(recursive: true);
+ }
+ }, overrides: <Type, Generator>{
+ DoctorValidatorsProvider: () => FakeDoctorValidatorsProvider(),
+ });
+ });
+
+ test('set template type as usage value', () => testbed.run(() async {
+ final CreateCommand command = CreateCommand();
+ final CommandRunner<void> runner = createTestCommandRunner(command);
+
+ await runner.run(<String>['create', '--flutter-root=flutter', '--no-pub', '--template=module', 'testy']);
+ expect(await command.usageValues, containsPair(kCommandCreateProjectType, 'module'));
+
+ await runner.run(<String>['create', '--flutter-root=flutter', '--no-pub', '--template=app', 'testy']);
+ expect(await command.usageValues, containsPair(kCommandCreateProjectType, 'app'));
+
+ await runner.run(<String>['create', '--flutter-root=flutter', '--no-pub', '--template=package', 'testy']);
+ expect(await command.usageValues, containsPair(kCommandCreateProjectType, 'package'));
+
+ await runner.run(<String>['create', '--flutter-root=flutter', '--no-pub', '--template=plugin', 'testy']);
+ expect(await command.usageValues, containsPair(kCommandCreateProjectType, 'plugin'));
+ }));
+
+ test('set iOS host language type as usage value', () => testbed.run(() async {
+ final CreateCommand command = CreateCommand();
+ final CommandRunner<void> runner = createTestCommandRunner(command);
+
+ await runner.run(<String>['create', '--flutter-root=flutter', '--no-pub', '--template=app', 'testy']);
+ expect(await command.usageValues, containsPair(kCommandCreateIosLanguage, 'objc'));
+
+ await runner.run(<String>[
+ 'create',
+ '--flutter-root=flutter',
+ '--no-pub',
+ '--template=app',
+ '--ios-language=swift',
+ 'testy',
+ ]);
+ expect(await command.usageValues, containsPair(kCommandCreateIosLanguage, 'swift'));
+
+ }));
+
+ test('set Android host language type as usage value', () => testbed.run(() async {
+ final CreateCommand command = CreateCommand();
+ final CommandRunner<void> runner = createTestCommandRunner(command);
+
+ await runner.run(<String>['create', '--flutter-root=flutter', '--no-pub', '--template=app', 'testy']);
+ expect(await command.usageValues, containsPair(kCommandCreateAndroidLanguage, 'java'));
+
+ await runner.run(<String>[
+ 'create',
+ '--flutter-root=flutter',
+ '--no-pub',
+ '--template=app',
+ '--android-language=kotlin',
+ 'testy',
+ ]);
+ expect(await command.usageValues, containsPair(kCommandCreateAndroidLanguage, 'kotlin'));
+ }));
+ });
+}
+
+class FakeDoctorValidatorsProvider implements DoctorValidatorsProvider {
+ @override
+ List<DoctorValidator> get validators => <DoctorValidator>[];
+
+ @override
+ List<Workflow> get workflows => <Workflow>[];
+}
diff --git a/packages/flutter_tools/test/general.shard/commands/daemon_test.dart b/packages/flutter_tools/test/general.shard/commands/daemon_test.dart
new file mode 100644
index 0000000..54aebdb
--- /dev/null
+++ b/packages/flutter_tools/test/general.shard/commands/daemon_test.dart
@@ -0,0 +1,323 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'dart:async';
+
+import 'package:flutter_tools/src/android/android_workflow.dart';
+import 'package:flutter_tools/src/base/logger.dart';
+import 'package:flutter_tools/src/commands/daemon.dart';
+import 'package:flutter_tools/src/fuchsia/fuchsia_workflow.dart';
+import 'package:flutter_tools/src/globals.dart';
+import 'package:flutter_tools/src/ios/ios_workflow.dart';
+import 'package:flutter_tools/src/resident_runner.dart';
+
+import '../../src/common.dart';
+import '../../src/context.dart';
+import '../../src/mocks.dart';
+
+void main() {
+ Daemon daemon;
+ NotifyingLogger notifyingLogger;
+
+ group('daemon', () {
+ setUp(() {
+ notifyingLogger = NotifyingLogger();
+ });
+
+ tearDown(() {
+ if (daemon != null)
+ return daemon.shutdown();
+ notifyingLogger.dispose();
+ });
+
+ testUsingContext('daemon.version command should succeed', () async {
+ final StreamController<Map<String, dynamic>> commands = StreamController<Map<String, dynamic>>();
+ final StreamController<Map<String, dynamic>> responses = StreamController<Map<String, dynamic>>();
+ daemon = Daemon(
+ commands.stream,
+ responses.add,
+ notifyingLogger: notifyingLogger,
+ );
+ commands.add(<String, dynamic>{'id': 0, 'method': 'daemon.version'});
+ final Map<String, dynamic> response = await responses.stream.firstWhere(_notEvent);
+ expect(response['id'], 0);
+ expect(response['result'], isNotEmpty);
+ expect(response['result'] is String, true);
+ await responses.close();
+ await commands.close();
+ });
+
+ testUsingContext('printError should send daemon.logMessage event', () async {
+ final StreamController<Map<String, dynamic>> commands = StreamController<Map<String, dynamic>>();
+ final StreamController<Map<String, dynamic>> responses = StreamController<Map<String, dynamic>>();
+ daemon = Daemon(
+ commands.stream,
+ responses.add,
+ notifyingLogger: notifyingLogger,
+ );
+ printError('daemon.logMessage test');
+ final Map<String, dynamic> response = await responses.stream.firstWhere((Map<String, dynamic> map) {
+ return map['event'] == 'daemon.logMessage' && map['params']['level'] == 'error';
+ });
+ expect(response['id'], isNull);
+ expect(response['event'], 'daemon.logMessage');
+ final Map<String, String> logMessage = response['params'].cast<String, String>();
+ expect(logMessage['level'], 'error');
+ expect(logMessage['message'], 'daemon.logMessage test');
+ await responses.close();
+ await commands.close();
+ }, overrides: <Type, Generator>{
+ Logger: () => notifyingLogger,
+ });
+
+ testUsingContext('printStatus should log to stdout when logToStdout is enabled', () async {
+ final StringBuffer buffer = StringBuffer();
+
+ await runZoned<Future<void>>(() async {
+ final StreamController<Map<String, dynamic>> commands = StreamController<Map<String, dynamic>>();
+ final StreamController<Map<String, dynamic>> responses = StreamController<Map<String, dynamic>>();
+ daemon = Daemon(
+ commands.stream,
+ responses.add,
+ notifyingLogger: notifyingLogger,
+ logToStdout: true,
+ );
+ printStatus('daemon.logMessage test');
+ // Service the event loop.
+ await Future<void>.value();
+ }, zoneSpecification: ZoneSpecification(print: (Zone self, ZoneDelegate parent, Zone zone, String line) {
+ buffer.writeln(line);
+ }));
+
+ expect(buffer.toString().trim(), 'daemon.logMessage test');
+ }, overrides: <Type, Generator>{
+ Logger: () => notifyingLogger,
+ });
+
+ testUsingContext('daemon.shutdown command should stop daemon', () async {
+ final StreamController<Map<String, dynamic>> commands = StreamController<Map<String, dynamic>>();
+ final StreamController<Map<String, dynamic>> responses = StreamController<Map<String, dynamic>>();
+ daemon = Daemon(
+ commands.stream,
+ responses.add,
+ notifyingLogger: notifyingLogger,
+ );
+ commands.add(<String, dynamic>{'id': 0, 'method': 'daemon.shutdown'});
+ return daemon.onExit.then<void>((int code) async {
+ await commands.close();
+ expect(code, 0);
+ });
+ });
+
+ testUsingContext('app.restart without an appId should report an error', () async {
+ final DaemonCommand command = DaemonCommand();
+ applyMocksToCommand(command);
+
+ final StreamController<Map<String, dynamic>> commands = StreamController<Map<String, dynamic>>();
+ final StreamController<Map<String, dynamic>> responses = StreamController<Map<String, dynamic>>();
+ daemon = Daemon(
+ commands.stream,
+ responses.add,
+ daemonCommand: command,
+ notifyingLogger: notifyingLogger,
+ );
+
+ commands.add(<String, dynamic>{'id': 0, 'method': 'app.restart'});
+ final Map<String, dynamic> response = await responses.stream.firstWhere(_notEvent);
+ expect(response['id'], 0);
+ expect(response['error'], contains('appId is required'));
+ await responses.close();
+ await commands.close();
+ });
+
+ testUsingContext('ext.flutter.debugPaint via service extension without an appId should report an error', () async {
+ final DaemonCommand command = DaemonCommand();
+ applyMocksToCommand(command);
+
+ final StreamController<Map<String, dynamic>> commands = StreamController<Map<String, dynamic>>();
+ final StreamController<Map<String, dynamic>> responses = StreamController<Map<String, dynamic>>();
+ daemon = Daemon(
+ commands.stream,
+ responses.add,
+ daemonCommand: command,
+ notifyingLogger: notifyingLogger,
+ );
+
+ commands.add(<String, dynamic>{
+ 'id': 0,
+ 'method': 'app.callServiceExtension',
+ 'params': <String, String>{
+ 'methodName': 'ext.flutter.debugPaint',
+ },
+ });
+ final Map<String, dynamic> response = await responses.stream.firstWhere(_notEvent);
+ expect(response['id'], 0);
+ expect(response['error'], contains('appId is required'));
+ await responses.close();
+ await commands.close();
+ });
+
+ testUsingContext('app.stop without appId should report an error', () async {
+ final DaemonCommand command = DaemonCommand();
+ applyMocksToCommand(command);
+
+ final StreamController<Map<String, dynamic>> commands = StreamController<Map<String, dynamic>>();
+ final StreamController<Map<String, dynamic>> responses = StreamController<Map<String, dynamic>>();
+ daemon = Daemon(
+ commands.stream,
+ responses.add,
+ daemonCommand: command,
+ notifyingLogger: notifyingLogger,
+ );
+
+ commands.add(<String, dynamic>{'id': 0, 'method': 'app.stop'});
+ final Map<String, dynamic> response = await responses.stream.firstWhere(_notEvent);
+ expect(response['id'], 0);
+ expect(response['error'], contains('appId is required'));
+ await responses.close();
+ await commands.close();
+ });
+
+ testUsingContext('device.getDevices should respond with list', () async {
+ final StreamController<Map<String, dynamic>> commands = StreamController<Map<String, dynamic>>();
+ final StreamController<Map<String, dynamic>> responses = StreamController<Map<String, dynamic>>();
+ daemon = Daemon(
+ commands.stream,
+ responses.add,
+ notifyingLogger: notifyingLogger,
+ );
+ commands.add(<String, dynamic>{'id': 0, 'method': 'device.getDevices'});
+ final Map<String, dynamic> response = await responses.stream.firstWhere(_notEvent);
+ expect(response['id'], 0);
+ expect(response['result'], isList);
+ await responses.close();
+ await commands.close();
+ });
+
+ testUsingContext('device.getDevices reports available devices', () async {
+ final StreamController<Map<String, dynamic>> commands = StreamController<Map<String, dynamic>>();
+ final StreamController<Map<String, dynamic>> responses = StreamController<Map<String, dynamic>>();
+ daemon = Daemon(
+ commands.stream,
+ responses.add,
+ notifyingLogger: notifyingLogger,
+ );
+ final MockPollingDeviceDiscovery discoverer = MockPollingDeviceDiscovery();
+ daemon.deviceDomain.addDeviceDiscoverer(discoverer);
+ discoverer.addDevice(MockAndroidDevice());
+ commands.add(<String, dynamic>{'id': 0, 'method': 'device.getDevices'});
+ final Map<String, dynamic> response = await responses.stream.firstWhere(_notEvent);
+ expect(response['id'], 0);
+ final dynamic result = response['result'];
+ expect(result, isList);
+ expect(result, isNotEmpty);
+ await responses.close();
+ await commands.close();
+ });
+
+ testUsingContext('should send device.added event when device is discovered', () async {
+ final StreamController<Map<String, dynamic>> commands = StreamController<Map<String, dynamic>>();
+ final StreamController<Map<String, dynamic>> responses = StreamController<Map<String, dynamic>>();
+ daemon = Daemon(
+ commands.stream,
+ responses.add,
+ notifyingLogger: notifyingLogger,
+ );
+
+ final MockPollingDeviceDiscovery discoverer = MockPollingDeviceDiscovery();
+ daemon.deviceDomain.addDeviceDiscoverer(discoverer);
+ discoverer.addDevice(MockAndroidDevice());
+
+ return await responses.stream.skipWhile(_isConnectedEvent).first.then<void>((Map<String, dynamic> response) async {
+ expect(response['event'], 'device.added');
+ expect(response['params'], isMap);
+
+ final Map<String, dynamic> params = response['params'];
+ expect(params['platform'], isNotEmpty); // the mock device has a platform of 'android-arm'
+
+ await responses.close();
+ await commands.close();
+ });
+ }, overrides: <Type, Generator>{
+ AndroidWorkflow: () => MockAndroidWorkflow(),
+ IOSWorkflow: () => MockIOSWorkflow(),
+ FuchsiaWorkflow: () => MockFuchsiaWorkflow(),
+ });
+
+ testUsingContext('emulator.launch without an emulatorId should report an error', () async {
+ final DaemonCommand command = DaemonCommand();
+ applyMocksToCommand(command);
+
+ final StreamController<Map<String, dynamic>> commands = StreamController<Map<String, dynamic>>();
+ final StreamController<Map<String, dynamic>> responses = StreamController<Map<String, dynamic>>();
+ daemon = Daemon(
+ commands.stream,
+ responses.add,
+ daemonCommand: command,
+ notifyingLogger: notifyingLogger,
+ );
+
+ commands.add(<String, dynamic>{'id': 0, 'method': 'emulator.launch'});
+ final Map<String, dynamic> response = await responses.stream.firstWhere(_notEvent);
+ expect(response['id'], 0);
+ expect(response['error'], contains('emulatorId is required'));
+ await responses.close();
+ await commands.close();
+ });
+
+ testUsingContext('emulator.getEmulators should respond with list', () async {
+ final StreamController<Map<String, dynamic>> commands = StreamController<Map<String, dynamic>>();
+ final StreamController<Map<String, dynamic>> responses = StreamController<Map<String, dynamic>>();
+ daemon = Daemon(
+ commands.stream,
+ responses.add,
+ notifyingLogger: notifyingLogger,
+ );
+ commands.add(<String, dynamic>{'id': 0, 'method': 'emulator.getEmulators'});
+ final Map<String, dynamic> response = await responses.stream.firstWhere(_notEvent);
+ expect(response['id'], 0);
+ expect(response['result'], isList);
+ await responses.close();
+ await commands.close();
+ });
+ });
+
+ group('daemon serialization', () {
+ test('OperationResult', () {
+ expect(
+ jsonEncodeObject(OperationResult.ok),
+ '{"code":0,"message":""}',
+ );
+ expect(
+ jsonEncodeObject(OperationResult(1, 'foo')),
+ '{"code":1,"message":"foo"}',
+ );
+ });
+ });
+}
+
+bool _notEvent(Map<String, dynamic> map) => map['event'] == null;
+
+bool _isConnectedEvent(Map<String, dynamic> map) => map['event'] == 'daemon.connected';
+
+class MockFuchsiaWorkflow extends FuchsiaWorkflow {
+ MockFuchsiaWorkflow({ this.canListDevices = true });
+
+ @override
+ final bool canListDevices;
+}
+
+class MockAndroidWorkflow extends AndroidWorkflow {
+ MockAndroidWorkflow({ this.canListDevices = true });
+
+ @override
+ final bool canListDevices;
+}
+
+class MockIOSWorkflow extends IOSWorkflow {
+ MockIOSWorkflow({ this.canListDevices =true });
+
+ @override
+ final bool canListDevices;
+}
diff --git a/packages/flutter_tools/test/general.shard/commands/devices_test.dart b/packages/flutter_tools/test/general.shard/commands/devices_test.dart
new file mode 100644
index 0000000..01bbb9a
--- /dev/null
+++ b/packages/flutter_tools/test/general.shard/commands/devices_test.dart
@@ -0,0 +1,71 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// 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:convert';
+import 'dart:io';
+
+import 'package:flutter_tools/src/android/android_sdk.dart';
+import 'package:flutter_tools/src/cache.dart';
+import 'package:flutter_tools/src/commands/devices.dart';
+import 'package:flutter_tools/src/device.dart';
+import 'package:mockito/mockito.dart';
+import 'package:process/process.dart';
+
+import '../../src/common.dart';
+import '../../src/context.dart';
+
+void main() {
+ group('devices', () {
+ setUpAll(() {
+ Cache.disableLocking();
+ // TODO(jonahwilliams): adjust the individual tests so they do not
+ // depend on the host environment.
+ debugDisableWebAndDesktop = true;
+ });
+
+ testUsingContext('returns 0 when called', () async {
+ final DevicesCommand command = DevicesCommand();
+ await createTestCommandRunner(command).run(<String>['devices']);
+ });
+
+ testUsingContext('no error when no connected devices', () async {
+ final DevicesCommand command = DevicesCommand();
+ await createTestCommandRunner(command).run(<String>['devices']);
+ expect(testLogger.statusText, contains('No devices detected'));
+ }, overrides: <Type, Generator>{
+ AndroidSdk: () => null,
+ DeviceManager: () => DeviceManager(),
+ ProcessManager: () => MockProcessManager(),
+ });
+ });
+}
+
+class MockProcessManager extends Mock implements ProcessManager {
+ @override
+ Future<ProcessResult> run(
+ List<dynamic> command, {
+ String workingDirectory,
+ Map<String, String> environment,
+ bool includeParentEnvironment = true,
+ bool runInShell = false,
+ Encoding stdoutEncoding = systemEncoding,
+ Encoding stderrEncoding = systemEncoding,
+ }) async {
+ return ProcessResult(0, 0, '', '');
+ }
+
+ @override
+ ProcessResult runSync(
+ List<dynamic> command, {
+ String workingDirectory,
+ Map<String, String> environment,
+ bool includeParentEnvironment = true,
+ bool runInShell = false,
+ Encoding stdoutEncoding = systemEncoding,
+ Encoding stderrEncoding = systemEncoding,
+ }) {
+ return ProcessResult(0, 0, '', '');
+ }
+}
diff --git a/packages/flutter_tools/test/general.shard/commands/doctor_test.dart b/packages/flutter_tools/test/general.shard/commands/doctor_test.dart
new file mode 100644
index 0000000..5aa2a89
--- /dev/null
+++ b/packages/flutter_tools/test/general.shard/commands/doctor_test.dart
@@ -0,0 +1,831 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'dart:async';
+
+import 'package:mockito/mockito.dart';
+import 'package:process/process.dart';
+
+import 'package:flutter_tools/src/artifacts.dart';
+import 'package:flutter_tools/src/base/file_system.dart';
+import 'package:flutter_tools/src/base/io.dart';
+import 'package:flutter_tools/src/base/platform.dart';
+import 'package:flutter_tools/src/base/terminal.dart';
+import 'package:flutter_tools/src/base/user_messages.dart';
+import 'package:flutter_tools/src/doctor.dart';
+import 'package:flutter_tools/src/globals.dart';
+import 'package:flutter_tools/src/proxy_validator.dart';
+import 'package:flutter_tools/src/vscode/vscode.dart';
+import 'package:flutter_tools/src/vscode/vscode_validator.dart';
+import 'package:flutter_tools/src/usage.dart';
+
+import '../../src/common.dart';
+import '../../src/context.dart';
+
+final Generator _kNoColorOutputPlatform = () => FakePlatform.fromPlatform(const LocalPlatform())..stdoutSupportsAnsi = false;
+final Map<Type, Generator> noColorTerminalOverride = <Type, Generator>{
+ Platform: _kNoColorOutputPlatform,
+};
+
+void main() {
+ MockProcessManager mockProcessManager;
+
+ setUp(() {
+ mockProcessManager = MockProcessManager();
+ });
+
+ group('doctor', () {
+ testUsingContext('intellij validator', () async {
+ const String installPath = '/path/to/intelliJ';
+ final ValidationResult result = await IntelliJValidatorTestTarget('Test', installPath).validate();
+ expect(result.type, ValidationType.partial);
+ expect(result.statusInfo, 'version test.test.test');
+ expect(result.messages, hasLength(4));
+
+ ValidationMessage message = result.messages
+ .firstWhere((ValidationMessage m) => m.message.startsWith('IntelliJ '));
+ expect(message.message, 'IntelliJ at $installPath');
+
+ message = result.messages
+ .firstWhere((ValidationMessage m) => m.message.startsWith('Dart '));
+ expect(message.message, 'Dart plugin version 162.2485');
+
+ message = result.messages
+ .firstWhere((ValidationMessage m) => m.message.startsWith('Flutter '));
+ expect(message.message, contains('Flutter plugin version 0.1.3'));
+ expect(message.message, contains('recommended minimum version'));
+ }, overrides: noColorTerminalOverride);
+
+ testUsingContext('vs code validator when both installed', () async {
+ final ValidationResult result = await VsCodeValidatorTestTargets.installedWithExtension.validate();
+ expect(result.type, ValidationType.installed);
+ expect(result.statusInfo, 'version 1.2.3');
+ expect(result.messages, hasLength(2));
+
+ ValidationMessage message = result.messages
+ .firstWhere((ValidationMessage m) => m.message.startsWith('VS Code '));
+ expect(message.message, 'VS Code at ${VsCodeValidatorTestTargets.validInstall}');
+
+ message = result.messages
+ .firstWhere((ValidationMessage m) => m.message.startsWith('Flutter '));
+ expect(message.message, 'Flutter extension version 4.5.6');
+ expect(message.isError, isFalse);
+ }, overrides: noColorTerminalOverride);
+
+ testUsingContext('vs code validator when 64bit installed', () async {
+ expect(VsCodeValidatorTestTargets.installedWithExtension64bit.title, 'VS Code, 64-bit edition');
+ final ValidationResult result = await VsCodeValidatorTestTargets.installedWithExtension64bit.validate();
+ expect(result.type, ValidationType.installed);
+ expect(result.statusInfo, 'version 1.2.3');
+ expect(result.messages, hasLength(2));
+
+ ValidationMessage message = result.messages
+ .firstWhere((ValidationMessage m) => m.message.startsWith('VS Code '));
+ expect(message.message, 'VS Code at ${VsCodeValidatorTestTargets.validInstall}');
+
+ message = result.messages
+ .firstWhere((ValidationMessage m) => m.message.startsWith('Flutter '));
+ expect(message.message, 'Flutter extension version 4.5.6');
+ }, overrides: noColorTerminalOverride);
+
+ testUsingContext('vs code validator when extension missing', () async {
+ final ValidationResult result = await VsCodeValidatorTestTargets.installedWithoutExtension.validate();
+ expect(result.type, ValidationType.partial);
+ expect(result.statusInfo, 'version 1.2.3');
+ expect(result.messages, hasLength(2));
+
+ ValidationMessage message = result.messages
+ .firstWhere((ValidationMessage m) => m.message.startsWith('VS Code '));
+ expect(message.message, 'VS Code at ${VsCodeValidatorTestTargets.validInstall}');
+
+ message = result.messages
+ .firstWhere((ValidationMessage m) => m.message.startsWith('Flutter '));
+ expect(message.message, startsWith('Flutter extension not installed'));
+ expect(message.isError, isTrue);
+ }, overrides: noColorTerminalOverride);
+ });
+
+ group('proxy validator', () {
+ testUsingContext('does not show if HTTP_PROXY is not set', () {
+ expect(ProxyValidator.shouldShow, isFalse);
+ }, overrides: <Type, Generator>{
+ Platform: () => FakePlatform()..environment = <String, String>{},
+ });
+
+ testUsingContext('does not show if HTTP_PROXY is only whitespace', () {
+ expect(ProxyValidator.shouldShow, isFalse);
+ }, overrides: <Type, Generator>{
+ Platform: () =>
+ FakePlatform()..environment = <String, String>{'HTTP_PROXY': ' '},
+ });
+
+ testUsingContext('shows when HTTP_PROXY is set', () {
+ expect(ProxyValidator.shouldShow, isTrue);
+ }, overrides: <Type, Generator>{
+ Platform: () => FakePlatform()
+ ..environment = <String, String>{'HTTP_PROXY': 'fakeproxy.local'},
+ });
+
+ testUsingContext('shows when http_proxy is set', () {
+ expect(ProxyValidator.shouldShow, isTrue);
+ }, overrides: <Type, Generator>{
+ Platform: () => FakePlatform()
+ ..environment = <String, String>{'http_proxy': 'fakeproxy.local'},
+ });
+
+ testUsingContext('reports success when NO_PROXY is configured correctly', () async {
+ final ValidationResult results = await ProxyValidator().validate();
+ final List<ValidationMessage> issues = results.messages
+ .where((ValidationMessage msg) => msg.isError || msg.isHint)
+ .toList();
+ expect(issues, hasLength(0));
+ }, overrides: <Type, Generator>{
+ Platform: () => FakePlatform()
+ ..environment = <String, String>{
+ 'HTTP_PROXY': 'fakeproxy.local',
+ 'NO_PROXY': 'localhost,127.0.0.1',
+ },
+ });
+
+ testUsingContext('reports success when no_proxy is configured correctly', () async {
+ final ValidationResult results = await ProxyValidator().validate();
+ final List<ValidationMessage> issues = results.messages
+ .where((ValidationMessage msg) => msg.isError || msg.isHint)
+ .toList();
+ expect(issues, hasLength(0));
+ }, overrides: <Type, Generator>{
+ Platform: () => FakePlatform()
+ ..environment = <String, String>{
+ 'http_proxy': 'fakeproxy.local',
+ 'no_proxy': 'localhost,127.0.0.1',
+ },
+ });
+
+ testUsingContext('reports issues when NO_PROXY is missing localhost', () async {
+ final ValidationResult results = await ProxyValidator().validate();
+ final List<ValidationMessage> issues = results.messages
+ .where((ValidationMessage msg) => msg.isError || msg.isHint)
+ .toList();
+ expect(issues, isNot(hasLength(0)));
+ }, overrides: <Type, Generator>{
+ Platform: () => FakePlatform()
+ ..environment = <String, String>{
+ 'HTTP_PROXY': 'fakeproxy.local',
+ 'NO_PROXY': '127.0.0.1',
+ },
+ });
+
+ testUsingContext('reports issues when NO_PROXY is missing 127.0.0.1', () async {
+ final ValidationResult results = await ProxyValidator().validate();
+ final List<ValidationMessage> issues = results.messages
+ .where((ValidationMessage msg) => msg.isError || msg.isHint)
+ .toList();
+ expect(issues, isNot(hasLength(0)));
+ }, overrides: <Type, Generator>{
+ Platform: () => FakePlatform()
+ ..environment = <String, String>{
+ 'HTTP_PROXY': 'fakeproxy.local',
+ 'NO_PROXY': 'localhost',
+ },
+ });
+ });
+
+ group('doctor with overridden validators', () {
+ testUsingContext('validate non-verbose output format for run without issues', () async {
+ expect(await doctor.diagnose(verbose: false), isTrue);
+ expect(testLogger.statusText, equals(
+ 'Doctor summary (to see all details, run flutter doctor -v):\n'
+ '[✓] Passing Validator (with statusInfo)\n'
+ '[✓] Another Passing Validator (with statusInfo)\n'
+ '[✓] Providing validators is fun (with statusInfo)\n'
+ '\n'
+ '• No issues found!\n'
+ ));
+ }, overrides: <Type, Generator>{
+ DoctorValidatorsProvider: () => FakeDoctorValidatorsProvider(),
+ Platform: _kNoColorOutputPlatform,
+ });
+ });
+
+ group('doctor usage params', () {
+ Usage mockUsage;
+
+ setUp(() {
+ mockUsage = MockUsage();
+ when(mockUsage.isFirstRun).thenReturn(true);
+ });
+
+ testUsingContext('contains installed', () async {
+ await doctor.diagnose(verbose: false);
+
+ expect(
+ verify(mockUsage.sendEvent('doctorResult.PassingValidator', captureAny)).captured,
+ <dynamic>['installed', 'installed', 'installed'],
+ );
+ }, overrides: <Type, Generator>{
+ DoctorValidatorsProvider: () => FakeDoctorValidatorsProvider(),
+ Platform: _kNoColorOutputPlatform,
+ Usage: () => mockUsage,
+ });
+
+ testUsingContext('contains installed and partial', () async {
+ await FakePassingDoctor().diagnose(verbose: false);
+
+ expect(
+ verify(mockUsage.sendEvent('doctorResult.PassingValidator', captureAny)).captured,
+ <dynamic>['installed', 'installed'],
+ );
+ expect(
+ verify(mockUsage.sendEvent('doctorResult.PartialValidatorWithHintsOnly', captureAny)).captured,
+ <dynamic>['partial'],
+ );
+ expect(
+ verify(mockUsage.sendEvent('doctorResult.PartialValidatorWithErrors', captureAny)).captured,
+ <dynamic>['partial'],
+ );
+ }, overrides: <Type, Generator>{
+ Platform: _kNoColorOutputPlatform,
+ Usage: () => mockUsage,
+ });
+
+ testUsingContext('contains installed, missing and partial', () async {
+ await FakeDoctor().diagnose(verbose: false);
+
+ expect(
+ verify(mockUsage.sendEvent('doctorResult.PassingValidator', captureAny)).captured,
+ <dynamic>['installed'],
+ );
+ expect(
+ verify(mockUsage.sendEvent('doctorResult.MissingValidator', captureAny)).captured,
+ <dynamic>['missing'],
+ );
+ expect(
+ verify(mockUsage.sendEvent('doctorResult.NotAvailableValidator', captureAny)).captured,
+ <dynamic>['notAvailable'],
+ );
+ expect(
+ verify(mockUsage.sendEvent('doctorResult.PartialValidatorWithHintsOnly', captureAny)).captured,
+ <dynamic>['partial'],
+ );
+ expect(
+ verify(mockUsage.sendEvent('doctorResult.PartialValidatorWithErrors', captureAny)).captured,
+ <dynamic>['partial'],
+ );
+ }, overrides: <Type, Generator>{
+ Platform: _kNoColorOutputPlatform,
+ Usage: () => mockUsage,
+ });
+ });
+
+ group('doctor with fake validators', () {
+ testUsingContext('validate non-verbose output format for run without issues', () async {
+ expect(await FakeQuietDoctor().diagnose(verbose: false), isTrue);
+ expect(testLogger.statusText, equals(
+ 'Doctor summary (to see all details, run flutter doctor -v):\n'
+ '[✓] Passing Validator (with statusInfo)\n'
+ '[✓] Another Passing Validator (with statusInfo)\n'
+ '[✓] Validators are fun (with statusInfo)\n'
+ '[✓] Four score and seven validators ago (with statusInfo)\n'
+ '\n'
+ '• No issues found!\n'
+ ));
+ }, overrides: noColorTerminalOverride);
+
+ testUsingContext('validate non-verbose output format when only one category fails', () async {
+ expect(await FakeSinglePassingDoctor().diagnose(verbose: false), isTrue);
+ expect(testLogger.statusText, equals(
+ 'Doctor summary (to see all details, run flutter doctor -v):\n'
+ '[!] Partial Validator with only a Hint\n'
+ ' ! There is a hint here\n'
+ '\n'
+ '! Doctor found issues in 1 category.\n'
+ ));
+ }, overrides: noColorTerminalOverride);
+
+ testUsingContext('validate non-verbose output format for a passing run', () async {
+ expect(await FakePassingDoctor().diagnose(verbose: false), isTrue);
+ expect(testLogger.statusText, equals(
+ 'Doctor summary (to see all details, run flutter doctor -v):\n'
+ '[✓] Passing Validator (with statusInfo)\n'
+ '[!] Partial Validator with only a Hint\n'
+ ' ! There is a hint here\n'
+ '[!] Partial Validator with Errors\n'
+ ' ✗ An error message indicating partial installation\n'
+ ' ! Maybe a hint will help the user\n'
+ '[✓] Another Passing Validator (with statusInfo)\n'
+ '\n'
+ '! Doctor found issues in 2 categories.\n'
+ ));
+ }, overrides: noColorTerminalOverride);
+
+ testUsingContext('validate non-verbose output format', () async {
+ expect(await FakeDoctor().diagnose(verbose: false), isFalse);
+ expect(testLogger.statusText, equals(
+ 'Doctor summary (to see all details, run flutter doctor -v):\n'
+ '[✓] Passing Validator (with statusInfo)\n'
+ '[✗] Missing Validator\n'
+ ' ✗ A useful error message\n'
+ ' ! A hint message\n'
+ '[!] Not Available Validator\n'
+ ' ✗ A useful error message\n'
+ ' ! A hint message\n'
+ '[!] Partial Validator with only a Hint\n'
+ ' ! There is a hint here\n'
+ '[!] Partial Validator with Errors\n'
+ ' ✗ An error message indicating partial installation\n'
+ ' ! Maybe a hint will help the user\n'
+ '\n'
+ '! Doctor found issues in 4 categories.\n'
+ ));
+ }, overrides: noColorTerminalOverride);
+
+ testUsingContext('validate verbose output format', () async {
+ expect(await FakeDoctor().diagnose(verbose: true), isFalse);
+ expect(testLogger.statusText, equals(
+ '[✓] Passing Validator (with statusInfo)\n'
+ ' • A helpful message\n'
+ ' • A second, somewhat longer helpful message\n'
+ '\n'
+ '[✗] Missing Validator\n'
+ ' ✗ A useful error message\n'
+ ' • A message that is not an error\n'
+ ' ! A hint message\n'
+ '\n'
+ '[!] Not Available Validator\n'
+ ' ✗ A useful error message\n'
+ ' • A message that is not an error\n'
+ ' ! A hint message\n'
+ '\n'
+ '[!] Partial Validator with only a Hint\n'
+ ' ! There is a hint here\n'
+ ' • But there is no error\n'
+ '\n'
+ '[!] Partial Validator with Errors\n'
+ ' ✗ An error message indicating partial installation\n'
+ ' ! Maybe a hint will help the user\n'
+ ' • An extra message with some verbose details\n'
+ '\n'
+ '! Doctor found issues in 4 categories.\n'
+ ));
+ }, overrides: noColorTerminalOverride);
+
+ testUsingContext('gen_snapshot does not work', () async {
+ when(mockProcessManager.runSync(
+ <String>[artifacts.getArtifactPath(Artifact.genSnapshot)],
+ workingDirectory: anyNamed('workingDirectory'),
+ environment: anyNamed('environment'),
+ )).thenReturn(ProcessResult(101, 1, '', ''));
+
+ expect(await FlutterValidatorDoctor().diagnose(verbose: false), isTrue);
+ final List<String> statusLines = testLogger.statusText.split('\n');
+ for (String msg in userMessages.flutterBinariesDoNotRun.split('\n')) {
+ expect(statusLines, contains(contains(msg)));
+ }
+ if (platform.isLinux) {
+ for (String msg in userMessages.flutterBinariesLinuxRepairCommands.split('\n')) {
+ expect(statusLines, contains(contains(msg)));
+ }
+ }
+ }, overrides: <Type, Generator>{
+ OutputPreferences: () => OutputPreferences(wrapText: false),
+ ProcessManager: () => mockProcessManager,
+ Platform: _kNoColorOutputPlatform,
+ });
+ });
+
+ testUsingContext('validate non-verbose output wrapping', () async {
+ expect(await FakeDoctor().diagnose(verbose: false), isFalse);
+ expect(testLogger.statusText, equals(
+ 'Doctor summary (to see all\n'
+ 'details, run flutter doctor\n'
+ '-v):\n'
+ '[✓] Passing Validator (with\n'
+ ' statusInfo)\n'
+ '[✗] Missing Validator\n'
+ ' ✗ A useful error message\n'
+ ' ! A hint message\n'
+ '[!] Not Available Validator\n'
+ ' ✗ A useful error message\n'
+ ' ! A hint message\n'
+ '[!] Partial Validator with\n'
+ ' only a Hint\n'
+ ' ! There is a hint here\n'
+ '[!] Partial Validator with\n'
+ ' Errors\n'
+ ' ✗ An error message\n'
+ ' indicating partial\n'
+ ' installation\n'
+ ' ! Maybe a hint will help\n'
+ ' the user\n'
+ '\n'
+ '! Doctor found issues in 4\n'
+ ' categories.\n'
+ ''
+ ));
+ }, overrides: <Type, Generator>{
+ OutputPreferences: () => OutputPreferences(wrapText: true, wrapColumn: 30),
+ Platform: _kNoColorOutputPlatform,
+ });
+
+ testUsingContext('validate verbose output wrapping', () async {
+ expect(await FakeDoctor().diagnose(verbose: true), isFalse);
+ expect(testLogger.statusText, equals(
+ '[✓] Passing Validator (with\n'
+ ' statusInfo)\n'
+ ' • A helpful message\n'
+ ' • A second, somewhat\n'
+ ' longer helpful message\n'
+ '\n'
+ '[✗] Missing Validator\n'
+ ' ✗ A useful error message\n'
+ ' • A message that is not an\n'
+ ' error\n'
+ ' ! A hint message\n'
+ '\n'
+ '[!] Not Available Validator\n'
+ ' ✗ A useful error message\n'
+ ' • A message that is not an\n'
+ ' error\n'
+ ' ! A hint message\n'
+ '\n'
+ '[!] Partial Validator with\n'
+ ' only a Hint\n'
+ ' ! There is a hint here\n'
+ ' • But there is no error\n'
+ '\n'
+ '[!] Partial Validator with\n'
+ ' Errors\n'
+ ' ✗ An error message\n'
+ ' indicating partial\n'
+ ' installation\n'
+ ' ! Maybe a hint will help\n'
+ ' the user\n'
+ ' • An extra message with\n'
+ ' some verbose details\n'
+ '\n'
+ '! Doctor found issues in 4\n'
+ ' categories.\n'
+ ''
+ ));
+ }, overrides: <Type, Generator>{
+ OutputPreferences: () => OutputPreferences(wrapText: true, wrapColumn: 30),
+ Platform: _kNoColorOutputPlatform,
+ });
+
+
+ group('doctor with grouped validators', () {
+ testUsingContext('validate diagnose combines validator output', () async {
+ expect(await FakeGroupedDoctor().diagnose(), isTrue);
+ expect(testLogger.statusText, equals(
+ '[✓] Category 1\n'
+ ' • A helpful message\n'
+ ' • A helpful message\n'
+ '\n'
+ '[!] Category 2\n'
+ ' • A helpful message\n'
+ ' ✗ A useful error message\n'
+ '\n'
+ '! Doctor found issues in 1 category.\n'
+ ));
+ }, overrides: noColorTerminalOverride);
+
+ testUsingContext('validate merging assigns statusInfo and title', () async {
+ // There are two subvalidators. Only the second contains statusInfo.
+ expect(await FakeGroupedDoctorWithStatus().diagnose(), isTrue);
+ expect(testLogger.statusText, equals(
+ '[✓] First validator title (A status message)\n'
+ ' • A helpful message\n'
+ ' • A different message\n'
+ '\n'
+ '• No issues found!\n'
+ ));
+ }, overrides: noColorTerminalOverride);
+ });
+
+
+ group('grouped validator merging results', () {
+ final PassingGroupedValidator installed = PassingGroupedValidator('Category');
+ final PartialGroupedValidator partial = PartialGroupedValidator('Category');
+ final MissingGroupedValidator missing = MissingGroupedValidator('Category');
+
+ testUsingContext('validate installed + installed = installed', () async {
+ expect(await FakeSmallGroupDoctor(installed, installed).diagnose(), isTrue);
+ expect(testLogger.statusText, startsWith('[✓]'));
+ }, overrides: noColorTerminalOverride);
+
+ testUsingContext('validate installed + partial = partial', () async {
+ expect(await FakeSmallGroupDoctor(installed, partial).diagnose(), isTrue);
+ expect(testLogger.statusText, startsWith('[!]'));
+ }, overrides: noColorTerminalOverride);
+
+ testUsingContext('validate installed + missing = partial', () async {
+ expect(await FakeSmallGroupDoctor(installed, missing).diagnose(), isTrue);
+ expect(testLogger.statusText, startsWith('[!]'));
+ }, overrides: noColorTerminalOverride);
+
+ testUsingContext('validate partial + installed = partial', () async {
+ expect(await FakeSmallGroupDoctor(partial, installed).diagnose(), isTrue);
+ expect(testLogger.statusText, startsWith('[!]'));
+ }, overrides: noColorTerminalOverride);
+
+ testUsingContext('validate partial + partial = partial', () async {
+ expect(await FakeSmallGroupDoctor(partial, partial).diagnose(), isTrue);
+ expect(testLogger.statusText, startsWith('[!]'));
+ }, overrides: noColorTerminalOverride);
+
+ testUsingContext('validate partial + missing = partial', () async {
+ expect(await FakeSmallGroupDoctor(partial, missing).diagnose(), isTrue);
+ expect(testLogger.statusText, startsWith('[!]'));
+ }, overrides: noColorTerminalOverride);
+
+ testUsingContext('validate missing + installed = partial', () async {
+ expect(await FakeSmallGroupDoctor(missing, installed).diagnose(), isTrue);
+ expect(testLogger.statusText, startsWith('[!]'));
+ }, overrides: noColorTerminalOverride);
+
+ testUsingContext('validate missing + partial = partial', () async {
+ expect(await FakeSmallGroupDoctor(missing, partial).diagnose(), isTrue);
+ expect(testLogger.statusText, startsWith('[!]'));
+ }, overrides: noColorTerminalOverride);
+
+ testUsingContext('validate missing + missing = missing', () async {
+ expect(await FakeSmallGroupDoctor(missing, missing).diagnose(), isFalse);
+ expect(testLogger.statusText, startsWith('[✗]'));
+ }, overrides: noColorTerminalOverride);
+ });
+}
+
+class MockUsage extends Mock implements Usage {}
+
+class IntelliJValidatorTestTarget extends IntelliJValidator {
+ IntelliJValidatorTestTarget(String title, String installPath) : super(title, installPath);
+
+ @override
+ String get pluginsPath => fs.path.join('test', 'data', 'intellij', 'plugins');
+
+ @override
+ String get version => 'test.test.test';
+}
+
+class PassingValidator extends DoctorValidator {
+ PassingValidator(String name) : super(name);
+
+ @override
+ Future<ValidationResult> validate() async {
+ final List<ValidationMessage> messages = <ValidationMessage>[];
+ messages.add(ValidationMessage('A helpful message'));
+ messages.add(ValidationMessage('A second, somewhat longer helpful message'));
+ return ValidationResult(ValidationType.installed, messages, statusInfo: 'with statusInfo');
+ }
+}
+
+class MissingValidator extends DoctorValidator {
+ MissingValidator() : super('Missing Validator');
+
+ @override
+ Future<ValidationResult> validate() async {
+ final List<ValidationMessage> messages = <ValidationMessage>[];
+ messages.add(ValidationMessage.error('A useful error message'));
+ messages.add(ValidationMessage('A message that is not an error'));
+ messages.add(ValidationMessage.hint('A hint message'));
+ return ValidationResult(ValidationType.missing, messages);
+ }
+}
+
+class NotAvailableValidator extends DoctorValidator {
+ NotAvailableValidator() : super('Not Available Validator');
+
+ @override
+ Future<ValidationResult> validate() async {
+ final List<ValidationMessage> messages = <ValidationMessage>[];
+ messages.add(ValidationMessage.error('A useful error message'));
+ messages.add(ValidationMessage('A message that is not an error'));
+ messages.add(ValidationMessage.hint('A hint message'));
+ return ValidationResult(ValidationType.notAvailable, messages);
+ }
+}
+
+class PartialValidatorWithErrors extends DoctorValidator {
+ PartialValidatorWithErrors() : super('Partial Validator with Errors');
+
+ @override
+ Future<ValidationResult> validate() async {
+ final List<ValidationMessage> messages = <ValidationMessage>[];
+ messages.add(ValidationMessage.error('An error message indicating partial installation'));
+ messages.add(ValidationMessage.hint('Maybe a hint will help the user'));
+ messages.add(ValidationMessage('An extra message with some verbose details'));
+ return ValidationResult(ValidationType.partial, messages);
+ }
+}
+
+class PartialValidatorWithHintsOnly extends DoctorValidator {
+ PartialValidatorWithHintsOnly() : super('Partial Validator with only a Hint');
+
+ @override
+ Future<ValidationResult> validate() async {
+ final List<ValidationMessage> messages = <ValidationMessage>[];
+ messages.add(ValidationMessage.hint('There is a hint here'));
+ messages.add(ValidationMessage('But there is no error'));
+ return ValidationResult(ValidationType.partial, messages);
+ }
+}
+
+/// A doctor that fails with a missing [ValidationResult].
+class FakeDoctor extends Doctor {
+ List<DoctorValidator> _validators;
+
+ @override
+ List<DoctorValidator> get validators {
+ if (_validators == null) {
+ _validators = <DoctorValidator>[];
+ _validators.add(PassingValidator('Passing Validator'));
+ _validators.add(MissingValidator());
+ _validators.add(NotAvailableValidator());
+ _validators.add(PartialValidatorWithHintsOnly());
+ _validators.add(PartialValidatorWithErrors());
+ }
+ return _validators;
+ }
+}
+
+/// A doctor that should pass, but still has issues in some categories.
+class FakePassingDoctor extends Doctor {
+ List<DoctorValidator> _validators;
+ @override
+ List<DoctorValidator> get validators {
+ if (_validators == null) {
+ _validators = <DoctorValidator>[];
+ _validators.add(PassingValidator('Passing Validator'));
+ _validators.add(PartialValidatorWithHintsOnly());
+ _validators.add(PartialValidatorWithErrors());
+ _validators.add(PassingValidator('Another Passing Validator'));
+ }
+ return _validators;
+ }
+}
+
+/// A doctor that should pass, but still has 1 issue to test the singular of
+/// categories.
+class FakeSinglePassingDoctor extends Doctor {
+ List<DoctorValidator> _validators;
+ @override
+ List<DoctorValidator> get validators {
+ if (_validators == null) {
+ _validators = <DoctorValidator>[];
+ _validators.add(PartialValidatorWithHintsOnly());
+ }
+ return _validators;
+ }
+}
+
+/// A doctor that passes and has no issues anywhere.
+class FakeQuietDoctor extends Doctor {
+ List<DoctorValidator> _validators;
+ @override
+ List<DoctorValidator> get validators {
+ if (_validators == null) {
+ _validators = <DoctorValidator>[];
+ _validators.add(PassingValidator('Passing Validator'));
+ _validators.add(PassingValidator('Another Passing Validator'));
+ _validators.add(PassingValidator('Validators are fun'));
+ _validators.add(PassingValidator('Four score and seven validators ago'));
+ }
+ return _validators;
+ }
+}
+
+/// A DoctorValidatorsProvider that overrides the default validators without
+/// overriding the doctor.
+class FakeDoctorValidatorsProvider implements DoctorValidatorsProvider {
+ @override
+ List<DoctorValidator> get validators {
+ return <DoctorValidator>[
+ PassingValidator('Passing Validator'),
+ PassingValidator('Another Passing Validator'),
+ PassingValidator('Providing validators is fun'),
+ ];
+ }
+
+ @override
+ List<Workflow> get workflows => <Workflow>[];
+}
+
+class PassingGroupedValidator extends DoctorValidator {
+ PassingGroupedValidator(String name) : super(name);
+
+ @override
+ Future<ValidationResult> validate() async {
+ final List<ValidationMessage> messages = <ValidationMessage>[];
+ messages.add(ValidationMessage('A helpful message'));
+ return ValidationResult(ValidationType.installed, messages);
+ }
+}
+
+class MissingGroupedValidator extends DoctorValidator {
+ MissingGroupedValidator(String name) : super(name);
+
+ @override
+ Future<ValidationResult> validate() async {
+ final List<ValidationMessage> messages = <ValidationMessage>[];
+ messages.add(ValidationMessage.error('A useful error message'));
+ return ValidationResult(ValidationType.missing, messages);
+ }
+}
+
+class PartialGroupedValidator extends DoctorValidator {
+ PartialGroupedValidator(String name) : super(name);
+
+ @override
+ Future<ValidationResult> validate() async {
+ final List<ValidationMessage> messages = <ValidationMessage>[];
+ messages.add(ValidationMessage.error('An error message for partial installation'));
+ return ValidationResult(ValidationType.partial, messages);
+ }
+}
+
+class PassingGroupedValidatorWithStatus extends DoctorValidator {
+ PassingGroupedValidatorWithStatus(String name) : super(name);
+
+ @override
+ Future<ValidationResult> validate() async {
+ final List<ValidationMessage> messages = <ValidationMessage>[];
+ messages.add(ValidationMessage('A different message'));
+ return ValidationResult(ValidationType.installed, messages, statusInfo: 'A status message');
+ }
+}
+
+/// A doctor that has two groups of two validators each.
+class FakeGroupedDoctor extends Doctor {
+ List<DoctorValidator> _validators;
+ @override
+ List<DoctorValidator> get validators {
+ if (_validators == null) {
+ _validators = <DoctorValidator>[];
+ _validators.add(GroupedValidator(<DoctorValidator>[
+ PassingGroupedValidator('Category 1'),
+ PassingGroupedValidator('Category 1'),
+ ]));
+ _validators.add(GroupedValidator(<DoctorValidator>[
+ PassingGroupedValidator('Category 2'),
+ MissingGroupedValidator('Category 2'),
+ ]));
+ }
+ return _validators;
+ }
+}
+
+class FakeGroupedDoctorWithStatus extends Doctor {
+ List<DoctorValidator> _validators;
+ @override
+ List<DoctorValidator> get validators {
+ _validators ??= <DoctorValidator>[
+ GroupedValidator(<DoctorValidator>[
+ PassingGroupedValidator('First validator title'),
+ PassingGroupedValidatorWithStatus('Second validator title'),
+ ])];
+ return _validators;
+ }
+}
+
+class FlutterValidatorDoctor extends Doctor {
+ List<DoctorValidator> _validators;
+ @override
+ List<DoctorValidator> get validators {
+ _validators ??= <DoctorValidator>[FlutterValidator()];
+ return _validators;
+ }
+}
+
+/// A doctor that takes any two validators. Used to check behavior when
+/// merging ValidationTypes (installed, missing, partial).
+class FakeSmallGroupDoctor extends Doctor {
+ FakeSmallGroupDoctor(DoctorValidator val1, DoctorValidator val2) {
+ _validators = <DoctorValidator>[GroupedValidator(<DoctorValidator>[val1, val2])];
+ }
+
+ List<DoctorValidator> _validators;
+
+ @override
+ List<DoctorValidator> get validators => _validators;
+}
+
+class VsCodeValidatorTestTargets extends VsCodeValidator {
+ VsCodeValidatorTestTargets._(String installDirectory, String extensionDirectory, {String edition})
+ : super(VsCode.fromDirectory(installDirectory, extensionDirectory, edition: edition));
+
+ static VsCodeValidatorTestTargets get installedWithExtension =>
+ VsCodeValidatorTestTargets._(validInstall, validExtensions);
+
+ static VsCodeValidatorTestTargets get installedWithExtension64bit =>
+ VsCodeValidatorTestTargets._(validInstall, validExtensions, edition: '64-bit edition');
+
+ static VsCodeValidatorTestTargets get installedWithoutExtension =>
+ VsCodeValidatorTestTargets._(validInstall, missingExtensions);
+
+ static final String validInstall = fs.path.join('test', 'data', 'vscode', 'application');
+ static final String validExtensions = fs.path.join('test', 'data', 'vscode', 'extensions');
+ static final String missingExtensions = fs.path.join('test', 'data', 'vscode', 'notExtensions');
+}
+
+class MockProcessManager extends Mock implements ProcessManager {}
diff --git a/packages/flutter_tools/test/general.shard/commands/drive_test.dart b/packages/flutter_tools/test/general.shard/commands/drive_test.dart
new file mode 100644
index 0000000..f6e39ed
--- /dev/null
+++ b/packages/flutter_tools/test/general.shard/commands/drive_test.dart
@@ -0,0 +1,429 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'dart:async';
+
+import 'package:file/memory.dart';
+import 'package:flutter_tools/src/android/android_device.dart';
+import 'package:flutter_tools/src/base/common.dart';
+import 'package:flutter_tools/src/base/file_system.dart';
+import 'package:flutter_tools/src/base/io.dart';
+import 'package:flutter_tools/src/base/platform.dart';
+import 'package:flutter_tools/src/cache.dart';
+import 'package:flutter_tools/src/commands/drive.dart';
+import 'package:flutter_tools/src/device.dart';
+import 'package:mockito/mockito.dart';
+
+import '../../src/common.dart';
+import '../../src/context.dart';
+import '../../src/mocks.dart';
+
+void main() {
+ group('drive', () {
+ DriveCommand command;
+ Device mockDevice;
+ MemoryFileSystem fs;
+ Directory tempDir;
+
+ void withMockDevice([ Device mock ]) {
+ mockDevice = mock ?? MockDevice();
+ targetDeviceFinder = () async => mockDevice;
+ testDeviceManager.addDevice(mockDevice);
+ }
+
+ setUpAll(() {
+ Cache.disableLocking();
+ });
+
+ setUp(() {
+ command = DriveCommand();
+ applyMocksToCommand(command);
+ fs = MemoryFileSystem();
+ tempDir = fs.systemTempDirectory.createTempSync('flutter_drive_test.');
+ fs.currentDirectory = tempDir;
+ fs.directory('test').createSync();
+ fs.directory('test_driver').createSync();
+ fs.file('pubspec.yaml')..createSync();
+ fs.file('.packages').createSync();
+ setExitFunctionForTests();
+ targetDeviceFinder = () {
+ throw 'Unexpected call to targetDeviceFinder';
+ };
+ appStarter = (DriveCommand command) {
+ throw 'Unexpected call to appStarter';
+ };
+ testRunner = (List<String> testArgs, String observatoryUri) {
+ throw 'Unexpected call to testRunner';
+ };
+ appStopper = (DriveCommand command) {
+ throw 'Unexpected call to appStopper';
+ };
+ });
+
+ tearDown(() {
+ command = null;
+ restoreExitFunction();
+ restoreAppStarter();
+ restoreAppStopper();
+ restoreTestRunner();
+ restoreTargetDeviceFinder();
+ tryToDelete(tempDir);
+ });
+
+ testUsingContext('returns 1 when test file is not found', () async {
+ withMockDevice();
+
+ final String testApp = fs.path.join(tempDir.path, 'test', 'e2e.dart');
+ final String testFile = fs.path.join(tempDir.path, 'test_driver', 'e2e_test.dart');
+ fs.file(testApp).createSync(recursive: true);
+
+ final List<String> args = <String>[
+ 'drive',
+ '--target=$testApp',
+ ];
+ try {
+ await createTestCommandRunner(command).run(args);
+ fail('Expect exception');
+ } on ToolExit catch (e) {
+ expect(e.exitCode ?? 1, 1);
+ expect(e.message, contains('Test file not found: $testFile'));
+ }
+ }, overrides: <Type, Generator>{
+ FileSystem: () => fs,
+ });
+
+ testUsingContext('returns 1 when app fails to run', () async {
+ withMockDevice();
+ appStarter = expectAsync1((DriveCommand command) async => null);
+
+ final String testApp = fs.path.join(tempDir.path, 'test_driver', 'e2e.dart');
+ final String testFile = fs.path.join(tempDir.path, 'test_driver', 'e2e_test.dart');
+
+ final MemoryFileSystem memFs = fs;
+ await memFs.file(testApp).writeAsString('main() { }');
+ await memFs.file(testFile).writeAsString('main() { }');
+
+ final List<String> args = <String>[
+ 'drive',
+ '--target=$testApp',
+ ];
+ try {
+ await createTestCommandRunner(command).run(args);
+ fail('Expect exception');
+ } on ToolExit catch (e) {
+ expect(e.exitCode, 1);
+ expect(e.message, contains('Application failed to start. Will not run test. Quitting.'));
+ }
+ }, overrides: <Type, Generator>{
+ FileSystem: () => fs,
+ });
+
+ testUsingContext('returns 1 when app file is outside package', () async {
+ final String appFile = fs.path.join(tempDir.dirname, 'other_app', 'app.dart');
+ fs.file(appFile).createSync(recursive: true);
+ final List<String> args = <String>[
+ '--no-wrap',
+ 'drive',
+ '--target=$appFile',
+ ];
+ try {
+ await createTestCommandRunner(command).run(args);
+ fail('Expect exception');
+ } on ToolExit catch (e) {
+ expect(e.exitCode ?? 1, 1);
+ expect(testLogger.errorText, contains(
+ 'Application file $appFile is outside the package directory ${tempDir.path}',
+ ));
+ }
+ }, overrides: <Type, Generator>{
+ FileSystem: () => fs,
+ });
+
+ testUsingContext('returns 1 when app file is in the root dir', () async {
+ final String appFile = fs.path.join(tempDir.path, 'main.dart');
+ fs.file(appFile).createSync(recursive: true);
+ final List<String> args = <String>[
+ '--no-wrap',
+ 'drive',
+ '--target=$appFile',
+ ];
+ try {
+ await createTestCommandRunner(command).run(args);
+ fail('Expect exception');
+ } on ToolExit catch (e) {
+ expect(e.exitCode ?? 1, 1);
+ expect(testLogger.errorText, contains(
+ 'Application file main.dart must reside in one of the '
+ 'sub-directories of the package structure, not in the root directory.',
+ ));
+ }
+ }, overrides: <Type, Generator>{
+ FileSystem: () => fs,
+ });
+
+ testUsingContext('returns 0 when test ends successfully', () async {
+ withMockDevice();
+
+ final String testApp = fs.path.join(tempDir.path, 'test', 'e2e.dart');
+ final String testFile = fs.path.join(tempDir.path, 'test_driver', 'e2e_test.dart');
+
+ appStarter = expectAsync1((DriveCommand command) async {
+ return LaunchResult.succeeded();
+ });
+ testRunner = expectAsync2((List<String> testArgs, String observatoryUri) async {
+ expect(testArgs, <String>[testFile]);
+ return null;
+ });
+ appStopper = expectAsync1((DriveCommand command) async {
+ return true;
+ });
+
+ final MemoryFileSystem memFs = fs;
+ await memFs.file(testApp).writeAsString('main() {}');
+ await memFs.file(testFile).writeAsString('main() {}');
+
+ final List<String> args = <String>[
+ 'drive',
+ '--target=$testApp',
+ ];
+ await createTestCommandRunner(command).run(args);
+ expect(testLogger.errorText, isEmpty);
+ }, overrides: <Type, Generator>{
+ FileSystem: () => fs,
+ });
+
+ testUsingContext('returns exitCode set by test runner', () async {
+ withMockDevice();
+
+ final String testApp = fs.path.join(tempDir.path, 'test', 'e2e.dart');
+ final String testFile = fs.path.join(tempDir.path, 'test_driver', 'e2e_test.dart');
+
+ appStarter = expectAsync1((DriveCommand command) async {
+ return LaunchResult.succeeded();
+ });
+ testRunner = (List<String> testArgs, String observatoryUri) async {
+ throwToolExit(null, exitCode: 123);
+ };
+ appStopper = expectAsync1((DriveCommand command) async {
+ return true;
+ });
+
+ final MemoryFileSystem memFs = fs;
+ await memFs.file(testApp).writeAsString('main() {}');
+ await memFs.file(testFile).writeAsString('main() {}');
+
+ final List<String> args = <String>[
+ 'drive',
+ '--target=$testApp',
+ ];
+ try {
+ await createTestCommandRunner(command).run(args);
+ fail('Expect exception');
+ } on ToolExit catch (e) {
+ expect(e.exitCode ?? 1, 123);
+ expect(e.message, isNull);
+ }
+ }, overrides: <Type, Generator>{
+ FileSystem: () => fs,
+ });
+
+ group('findTargetDevice', () {
+ testUsingContext('uses specified device', () async {
+ testDeviceManager.specifiedDeviceId = '123';
+ withMockDevice();
+ when(mockDevice.name).thenReturn('specified-device');
+ when(mockDevice.id).thenReturn('123');
+
+ final Device device = await findTargetDevice();
+ expect(device.name, 'specified-device');
+ }, overrides: <Type, Generator>{
+ FileSystem: () => fs,
+ });
+ });
+
+ void findTargetDeviceOnOperatingSystem(String operatingSystem) {
+ Platform platform() => FakePlatform(operatingSystem: operatingSystem);
+
+ testUsingContext('returns null if no devices found', () async {
+ expect(await findTargetDevice(), isNull);
+ }, overrides: <Type, Generator>{
+ FileSystem: () => fs,
+ Platform: platform,
+ });
+
+ testUsingContext('uses existing Android device', () async {
+ mockDevice = MockAndroidDevice();
+ when(mockDevice.name).thenReturn('mock-android-device');
+ withMockDevice(mockDevice);
+
+ final Device device = await findTargetDevice();
+ expect(device.name, 'mock-android-device');
+ }, overrides: <Type, Generator>{
+ FileSystem: () => fs,
+ Platform: platform,
+ });
+ }
+
+ group('findTargetDevice on Linux', () {
+ findTargetDeviceOnOperatingSystem('linux');
+ });
+
+ group('findTargetDevice on Windows', () {
+ findTargetDeviceOnOperatingSystem('windows');
+ });
+
+ group('findTargetDevice on macOS', () {
+ findTargetDeviceOnOperatingSystem('macos');
+
+ Platform macOsPlatform() => FakePlatform(operatingSystem: 'macos');
+
+ testUsingContext('uses existing simulator', () async {
+ withMockDevice();
+ when(mockDevice.name).thenReturn('mock-simulator');
+ when(mockDevice.isLocalEmulator)
+ .thenAnswer((Invocation invocation) => Future<bool>.value(true));
+
+ final Device device = await findTargetDevice();
+ expect(device.name, 'mock-simulator');
+ }, overrides: <Type, Generator>{
+ FileSystem: () => fs,
+ Platform: macOsPlatform,
+ });
+ });
+
+ group('build arguments', () {
+ String testApp, testFile;
+
+ setUp(() {
+ restoreAppStarter();
+ });
+
+ Future<void> appStarterSetup() async {
+ withMockDevice();
+
+ final MockDeviceLogReader mockDeviceLogReader = MockDeviceLogReader();
+ when(mockDevice.getLogReader()).thenReturn(mockDeviceLogReader);
+ final MockLaunchResult mockLaunchResult = MockLaunchResult();
+ when(mockLaunchResult.started).thenReturn(true);
+ when(mockDevice.startApp(
+ null,
+ mainPath: anyNamed('mainPath'),
+ route: anyNamed('route'),
+ debuggingOptions: anyNamed('debuggingOptions'),
+ platformArgs: anyNamed('platformArgs'),
+ prebuiltApplication: anyNamed('prebuiltApplication'),
+ usesTerminalUi: false,
+ )).thenAnswer((_) => Future<LaunchResult>.value(mockLaunchResult));
+ when(mockDevice.isAppInstalled(any)).thenAnswer((_) => Future<bool>.value(false));
+
+ testApp = fs.path.join(tempDir.path, 'test', 'e2e.dart');
+ testFile = fs.path.join(tempDir.path, 'test_driver', 'e2e_test.dart');
+
+ testRunner = (List<String> testArgs, String observatoryUri) async {
+ throwToolExit(null, exitCode: 123);
+ };
+ appStopper = expectAsync1(
+ (DriveCommand command) async {
+ return true;
+ },
+ count: 2,
+ );
+
+ final MemoryFileSystem memFs = fs;
+ await memFs.file(testApp).writeAsString('main() {}');
+ await memFs.file(testFile).writeAsString('main() {}');
+ }
+
+ testUsingContext('does not use pre-built app if no build arg provided', () async {
+ await appStarterSetup();
+
+ final List<String> args = <String>[
+ 'drive',
+ '--target=$testApp',
+ ];
+ try {
+ await createTestCommandRunner(command).run(args);
+ } on ToolExit catch (e) {
+ expect(e.exitCode, 123);
+ expect(e.message, null);
+ }
+ verify(mockDevice.startApp(
+ null,
+ mainPath: anyNamed('mainPath'),
+ route: anyNamed('route'),
+ debuggingOptions: anyNamed('debuggingOptions'),
+ platformArgs: anyNamed('platformArgs'),
+ prebuiltApplication: false,
+ usesTerminalUi: false,
+ ));
+ }, overrides: <Type, Generator>{
+ FileSystem: () => fs,
+ });
+
+ testUsingContext('does not use pre-built app if --build arg provided', () async {
+ await appStarterSetup();
+
+ final List<String> args = <String>[
+ 'drive',
+ '--build',
+ '--target=$testApp',
+ ];
+ try {
+ await createTestCommandRunner(command).run(args);
+ } on ToolExit catch (e) {
+ expect(e.exitCode, 123);
+ expect(e.message, null);
+ }
+ verify(mockDevice.startApp(
+ null,
+ mainPath: anyNamed('mainPath'),
+ route: anyNamed('route'),
+ debuggingOptions: anyNamed('debuggingOptions'),
+ platformArgs: anyNamed('platformArgs'),
+ prebuiltApplication: false,
+ usesTerminalUi: false,
+ ));
+ }, overrides: <Type, Generator>{
+ FileSystem: () => fs,
+ });
+
+ testUsingContext('uses prebuilt app if --no-build arg provided', () async {
+ await appStarterSetup();
+
+ final List<String> args = <String>[
+ 'drive',
+ '--no-build',
+ '--target=$testApp',
+ ];
+ try {
+ await createTestCommandRunner(command).run(args);
+ } on ToolExit catch (e) {
+ expect(e.exitCode, 123);
+ expect(e.message, null);
+ }
+ verify(mockDevice.startApp(
+ null,
+ mainPath: anyNamed('mainPath'),
+ route: anyNamed('route'),
+ debuggingOptions: anyNamed('debuggingOptions'),
+ platformArgs: anyNamed('platformArgs'),
+ prebuiltApplication: true,
+ usesTerminalUi: false,
+ ));
+ }, overrides: <Type, Generator>{
+ FileSystem: () => fs,
+ });
+ });
+ });
+}
+
+class MockDevice extends Mock implements Device {
+ MockDevice() {
+ when(isSupported()).thenReturn(true);
+ }
+}
+
+class MockAndroidDevice extends Mock implements AndroidDevice { }
+
+class MockLaunchResult extends Mock implements LaunchResult { }
diff --git a/packages/flutter_tools/test/general.shard/commands/format_test.dart b/packages/flutter_tools/test/general.shard/commands/format_test.dart
new file mode 100644
index 0000000..1817bbe
--- /dev/null
+++ b/packages/flutter_tools/test/general.shard/commands/format_test.dart
@@ -0,0 +1,78 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'package:args/command_runner.dart';
+import 'package:flutter_tools/src/base/file_system.dart';
+import 'package:flutter_tools/src/cache.dart';
+import 'package:flutter_tools/src/commands/format.dart';
+
+import '../../src/common.dart';
+import '../../src/context.dart';
+
+void main() {
+ group('format', () {
+ Directory tempDir;
+
+ setUp(() {
+ Cache.disableLocking();
+ tempDir = fs.systemTempDirectory.createTempSync('flutter_tools_format_test.');
+ });
+
+ tearDown(() {
+ tryToDelete(tempDir);
+ });
+
+ testUsingContext('a file', () async {
+ final String projectPath = await createProject(tempDir);
+
+ final File srcFile = fs.file(fs.path.join(projectPath, 'lib', 'main.dart'));
+ final String original = srcFile.readAsStringSync();
+ srcFile.writeAsStringSync(original.replaceFirst('main()', 'main( )'));
+
+ final FormatCommand command = FormatCommand();
+ final CommandRunner<void> runner = createTestCommandRunner(command);
+ await runner.run(<String>['format', srcFile.path]);
+
+ final String formatted = srcFile.readAsStringSync();
+ expect(formatted, original);
+ });
+
+ testUsingContext('dry-run', () async {
+ final String projectPath = await createProject(tempDir);
+
+ final File srcFile = fs.file(
+ fs.path.join(projectPath, 'lib', 'main.dart'));
+ final String nonFormatted = srcFile.readAsStringSync().replaceFirst(
+ 'main()', 'main( )');
+ srcFile.writeAsStringSync(nonFormatted);
+
+ final FormatCommand command = FormatCommand();
+ final CommandRunner<void> runner = createTestCommandRunner(command);
+ await runner.run(<String>['format', '--dry-run', srcFile.path]);
+
+ final String shouldNotFormatted = srcFile.readAsStringSync();
+ expect(shouldNotFormatted, nonFormatted);
+ });
+
+ testUsingContext('dry-run with set-exit-if-changed', () async {
+ final String projectPath = await createProject(tempDir);
+
+ final File srcFile = fs.file(
+ fs.path.join(projectPath, 'lib', 'main.dart'));
+ final String nonFormatted = srcFile.readAsStringSync().replaceFirst(
+ 'main()', 'main( )');
+ srcFile.writeAsStringSync(nonFormatted);
+
+ final FormatCommand command = FormatCommand();
+ final CommandRunner<void> runner = createTestCommandRunner(command);
+
+ expect(runner.run(<String>[
+ 'format', '--dry-run', '--set-exit-if-changed', srcFile.path,
+ ]), throwsException);
+
+ final String shouldNotFormatted = srcFile.readAsStringSync();
+ expect(shouldNotFormatted, nonFormatted);
+ });
+ });
+}
diff --git a/packages/flutter_tools/test/general.shard/commands/ide_config_test.dart b/packages/flutter_tools/test/general.shard/commands/ide_config_test.dart
new file mode 100644
index 0000000..dd6defa
--- /dev/null
+++ b/packages/flutter_tools/test/general.shard/commands/ide_config_test.dart
@@ -0,0 +1,324 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'dart:async';
+
+import 'package:args/command_runner.dart';
+import 'package:flutter_tools/src/base/file_system.dart';
+import 'package:flutter_tools/src/cache.dart';
+import 'package:flutter_tools/src/template.dart';
+import 'package:flutter_tools/src/commands/ide_config.dart';
+
+import '../../src/common.dart';
+import '../../src/context.dart';
+
+void main() {
+ group('ide_config', () {
+ Directory tempDir;
+ Directory templateDir;
+ Directory intellijDir;
+ Directory toolsDir;
+
+ Map<String, String> _getFilesystemContents([ Directory root ]) {
+ final String tempPath = tempDir.absolute.path;
+ final List<String> paths =
+ (root ?? tempDir).listSync(recursive: true).map((FileSystemEntity entity) {
+ final String relativePath = fs.path.relative(entity.path, from: tempPath);
+ return relativePath;
+ }).toList();
+ final Map<String, String> contents = <String, String>{};
+ for (String path in paths) {
+ final String absPath = fs.path.join(tempPath, path);
+ if (fs.isDirectorySync(absPath)) {
+ contents[path] = 'dir';
+ } else if (fs.isFileSync(absPath)) {
+ contents[path] = fs.file(absPath).readAsStringSync();
+ }
+ }
+ return contents;
+ }
+
+ Map<String, String> _getManifest(Directory base, String marker, { bool isTemplate = false }) {
+ final String basePath = fs.path.relative(base.path, from: tempDir.absolute.path);
+ final String suffix = isTemplate ? Template.copyTemplateExtension : '';
+ return <String, String>{
+ fs.path.join(basePath, '.idea'): 'dir',
+ fs.path.join(basePath, '.idea', 'modules.xml$suffix'): 'modules $marker',
+ fs.path.join(basePath, '.idea', 'vcs.xml$suffix'): 'vcs $marker',
+ fs.path.join(basePath, '.idea', '.name$suffix'):
+ 'codeStyleSettings $marker',
+ fs.path.join(basePath, '.idea', 'runConfigurations'): 'dir',
+ fs.path.join(basePath, '.idea', 'runConfigurations', 'hello_world.xml$suffix'):
+ 'hello_world $marker',
+ fs.path.join(basePath, 'flutter.iml$suffix'): 'flutter $marker',
+ fs.path.join(basePath, 'packages', 'new', 'deep.iml$suffix'): 'deep $marker',
+ };
+ }
+
+ void _populateDir(Map<String, String> manifest) {
+ for (String key in manifest.keys) {
+ if (manifest[key] == 'dir') {
+ tempDir.childDirectory(key)..createSync(recursive: true);
+ }
+ }
+ for (String key in manifest.keys) {
+ if (manifest[key] != 'dir') {
+ tempDir.childFile(key)
+ ..createSync(recursive: true)
+ ..writeAsStringSync(manifest[key]);
+ }
+ }
+ }
+
+ bool _fileOrDirectoryExists(String path) {
+ final String absPath = fs.path.join(tempDir.absolute.path, path);
+ return fs.file(absPath).existsSync() || fs.directory(absPath).existsSync();
+ }
+
+ Future<void> _updateIdeConfig({
+ Directory dir,
+ List<String> args = const <String>[],
+ Map<String, String> expectedContents = const <String, String>{},
+ List<String> unexpectedPaths = const <String>[],
+ }) async {
+ dir ??= tempDir;
+ final IdeConfigCommand command = IdeConfigCommand();
+ final CommandRunner<void> runner = createTestCommandRunner(command);
+ await runner.run(<String>[
+ '--flutter-root=${tempDir.absolute.path}',
+ 'ide-config',
+ ...args,
+ ]);
+
+ for (String path in expectedContents.keys) {
+ final String absPath = fs.path.join(tempDir.absolute.path, path);
+ expect(_fileOrDirectoryExists(fs.path.join(dir.path, path)), true,
+ reason: "$path doesn't exist");
+ if (fs.file(absPath).existsSync()) {
+ expect(fs.file(absPath).readAsStringSync(), equals(expectedContents[path]),
+ reason: "$path contents don't match");
+ }
+ }
+ for (String path in unexpectedPaths) {
+ expect(_fileOrDirectoryExists(fs.path.join(dir.path, path)), false, reason: '$path exists');
+ }
+ }
+
+ setUpAll(() {
+ Cache.disableLocking();
+ });
+
+ setUp(() {
+ tempDir = fs.systemTempDirectory.createTempSync('flutter_tools_ide_config_test.');
+ final Directory packagesDir = tempDir.childDirectory('packages')..createSync(recursive: true);
+ toolsDir = packagesDir.childDirectory('flutter_tools')..createSync();
+ templateDir = toolsDir.childDirectory('ide_templates')..createSync();
+ intellijDir = templateDir.childDirectory('intellij')..createSync();
+ });
+
+ tearDown(() {
+ tryToDelete(tempDir);
+ });
+
+ testUsingContext("doesn't touch existing files without --overwrite", () async {
+ final Map<String, String> templateManifest = _getManifest(
+ intellijDir,
+ 'template',
+ isTemplate: true,
+ );
+ final Map<String, String> flutterManifest = _getManifest(
+ tempDir,
+ 'existing',
+ );
+ _populateDir(templateManifest);
+ _populateDir(flutterManifest);
+ final Map<String, String> expectedContents = _getFilesystemContents();
+ return _updateIdeConfig(
+ expectedContents: expectedContents,
+ );
+ }, timeout: const Timeout.factor(2.0));
+
+ testUsingContext('creates non-existent files', () async {
+ final Map<String, String> templateManifest = _getManifest(
+ intellijDir,
+ 'template',
+ isTemplate: true,
+ );
+ final Map<String, String> flutterManifest = _getManifest(
+ tempDir,
+ 'template',
+ );
+ _populateDir(templateManifest);
+ final Map<String, String> expectedContents = <String, String>{
+ ...templateManifest,
+ ...flutterManifest,
+ };
+ return _updateIdeConfig(
+ expectedContents: expectedContents,
+ );
+ }, timeout: const Timeout.factor(2.0));
+
+ testUsingContext('overwrites existing files with --overwrite', () async {
+ final Map<String, String> templateManifest = _getManifest(
+ intellijDir,
+ 'template',
+ isTemplate: true,
+ );
+ final Map<String, String> flutterManifest = _getManifest(
+ tempDir,
+ 'existing',
+ );
+ _populateDir(templateManifest);
+ _populateDir(flutterManifest);
+ final Map<String, String> overwrittenManifest = _getManifest(
+ tempDir,
+ 'template',
+ );
+ final Map<String, String> expectedContents = <String, String>{
+ ...templateManifest,
+ ...overwrittenManifest,
+ };
+ return _updateIdeConfig(
+ args: <String>['--overwrite'],
+ expectedContents: expectedContents,
+ );
+ }, timeout: const Timeout.factor(2.0));
+
+ testUsingContext('only adds new templates without --overwrite', () async {
+ final Map<String, String> templateManifest = _getManifest(
+ intellijDir,
+ 'template',
+ isTemplate: true,
+ );
+ final String flutterIml = fs.path.join(
+ 'packages',
+ 'flutter_tools',
+ 'ide_templates',
+ 'intellij',
+ 'flutter.iml${Template.copyTemplateExtension}',
+ );
+ templateManifest.remove(flutterIml);
+ _populateDir(templateManifest);
+ templateManifest[flutterIml] = 'flutter existing';
+ final Map<String, String> flutterManifest = _getManifest(
+ tempDir,
+ 'existing',
+ );
+ _populateDir(flutterManifest);
+ final Map<String, String> expectedContents = <String, String>{
+ ...flutterManifest,
+ ...templateManifest,
+ };
+ return _updateIdeConfig(
+ args: <String>['--update-templates'],
+ expectedContents: expectedContents,
+ );
+ }, timeout: const Timeout.factor(2.0));
+
+ testUsingContext('update all templates with --overwrite', () async {
+ final Map<String, String> templateManifest = _getManifest(
+ intellijDir,
+ 'template',
+ isTemplate: true,
+ );
+ _populateDir(templateManifest);
+ final Map<String, String> flutterManifest = _getManifest(
+ tempDir,
+ 'existing',
+ );
+ _populateDir(flutterManifest);
+ final Map<String, String> updatedTemplates = _getManifest(
+ intellijDir,
+ 'existing',
+ isTemplate: true,
+ );
+ final Map<String, String> expectedContents = <String, String>{
+ ...flutterManifest,
+ ...updatedTemplates,
+ };
+ return _updateIdeConfig(
+ args: <String>['--update-templates', '--overwrite'],
+ expectedContents: expectedContents,
+ );
+ }, timeout: const Timeout.factor(2.0));
+
+ testUsingContext('removes deleted imls with --overwrite', () async {
+ final Map<String, String> templateManifest = _getManifest(
+ intellijDir,
+ 'template',
+ isTemplate: true,
+ );
+ _populateDir(templateManifest);
+ final Map<String, String> flutterManifest = _getManifest(
+ tempDir,
+ 'existing',
+ );
+ flutterManifest.remove('flutter.iml');
+ _populateDir(flutterManifest);
+ final Map<String, String> updatedTemplates = _getManifest(
+ intellijDir,
+ 'existing',
+ isTemplate: true,
+ );
+ final String flutterIml = fs.path.join(
+ 'packages',
+ 'flutter_tools',
+ 'ide_templates',
+ 'intellij',
+ 'flutter.iml${Template.copyTemplateExtension}',
+ );
+ updatedTemplates.remove(flutterIml);
+ final Map<String, String> expectedContents = <String, String>{
+ ...flutterManifest,
+ ...updatedTemplates,
+ };
+ return _updateIdeConfig(
+ args: <String>['--update-templates', '--overwrite'],
+ expectedContents: expectedContents,
+ );
+ }, timeout: const Timeout.factor(2.0));
+
+ testUsingContext('removes deleted imls with --overwrite, including empty parent dirs', () async {
+ final Map<String, String> templateManifest = _getManifest(
+ intellijDir,
+ 'template',
+ isTemplate: true,
+ );
+ _populateDir(templateManifest);
+ final Map<String, String> flutterManifest = _getManifest(
+ tempDir,
+ 'existing',
+ );
+ flutterManifest.remove(fs.path.join('packages', 'new', 'deep.iml'));
+ _populateDir(flutterManifest);
+ final Map<String, String> updatedTemplates = _getManifest(
+ intellijDir,
+ 'existing',
+ isTemplate: true,
+ );
+ String deepIml = fs.path.join(
+ 'packages',
+ 'flutter_tools',
+ 'ide_templates',
+ 'intellij');
+ // Remove the all the dir entries too.
+ updatedTemplates.remove(deepIml);
+ deepIml = fs.path.join(deepIml, 'packages');
+ updatedTemplates.remove(deepIml);
+ deepIml = fs.path.join(deepIml, 'new');
+ updatedTemplates.remove(deepIml);
+ deepIml = fs.path.join(deepIml, 'deep.iml');
+ updatedTemplates.remove(deepIml);
+ final Map<String, String> expectedContents = <String, String>{
+ ...flutterManifest,
+ ...updatedTemplates,
+ };
+ return _updateIdeConfig(
+ args: <String>['--update-templates', '--overwrite'],
+ expectedContents: expectedContents,
+ );
+ }, timeout: const Timeout.factor(2.0));
+
+ });
+}
diff --git a/packages/flutter_tools/test/general.shard/commands/install_test.dart b/packages/flutter_tools/test/general.shard/commands/install_test.dart
new file mode 100644
index 0000000..2883259
--- /dev/null
+++ b/packages/flutter_tools/test/general.shard/commands/install_test.dart
@@ -0,0 +1,49 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'package:flutter_tools/src/cache.dart';
+import 'package:flutter_tools/src/commands/install.dart';
+import 'package:mockito/mockito.dart';
+
+import '../../src/common.dart';
+import '../../src/context.dart';
+import '../../src/mocks.dart';
+
+void main() {
+ group('install', () {
+ setUpAll(() {
+ Cache.disableLocking();
+ });
+
+ testUsingContext('returns 0 when Android is connected and ready for an install', () async {
+ final InstallCommand command = InstallCommand();
+ applyMocksToCommand(command);
+
+ final MockAndroidDevice device = MockAndroidDevice();
+ when(device.isAppInstalled(any)).thenAnswer((_) async => false);
+ when(device.installApp(any)).thenAnswer((_) async => true);
+ testDeviceManager.addDevice(device);
+
+ await createTestCommandRunner(command).run(<String>['install']);
+ }, overrides: <Type, Generator>{
+ Cache: () => MockCache(),
+ });
+
+ testUsingContext('returns 0 when iOS is connected and ready for an install', () async {
+ final InstallCommand command = InstallCommand();
+ applyMocksToCommand(command);
+
+ final MockIOSDevice device = MockIOSDevice();
+ when(device.isAppInstalled(any)).thenAnswer((_) async => false);
+ when(device.installApp(any)).thenAnswer((_) async => true);
+ testDeviceManager.addDevice(device);
+
+ await createTestCommandRunner(command).run(<String>['install']);
+ }, overrides: <Type, Generator>{
+ Cache: () => MockCache(),
+ });
+ });
+}
+
+class MockCache extends Mock implements Cache {}
diff --git a/packages/flutter_tools/test/general.shard/commands/packages_test.dart b/packages/flutter_tools/test/general.shard/commands/packages_test.dart
new file mode 100644
index 0000000..8e0269b
--- /dev/null
+++ b/packages/flutter_tools/test/general.shard/commands/packages_test.dart
@@ -0,0 +1,448 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'dart:async';
+
+import 'package:args/command_runner.dart';
+import 'package:flutter_tools/src/base/file_system.dart' hide IOSink;
+import 'package:flutter_tools/src/base/io.dart';
+import 'package:flutter_tools/src/base/utils.dart';
+import 'package:flutter_tools/src/cache.dart';
+import 'package:flutter_tools/src/commands/packages.dart';
+import 'package:flutter_tools/src/usage.dart';
+import 'package:process/process.dart';
+
+import '../../src/common.dart';
+import '../../src/context.dart';
+import '../../src/mocks.dart' show MockProcessManager, MockStdio, PromptingProcess;
+
+class AlwaysTrueBotDetector implements BotDetector {
+ const AlwaysTrueBotDetector();
+
+ @override
+ bool get isRunningOnBot => true;
+}
+
+
+class AlwaysFalseBotDetector implements BotDetector {
+ const AlwaysFalseBotDetector();
+
+ @override
+ bool get isRunningOnBot => false;
+}
+
+
+void main() {
+ Cache.disableLocking();
+ group('packages get/upgrade', () {
+ Directory tempDir;
+
+ setUp(() {
+ tempDir = fs.systemTempDirectory.createTempSync('flutter_tools_packages_test.');
+ });
+
+ tearDown(() {
+ tryToDelete(tempDir);
+ });
+
+ Future<String> createProjectWithPlugin(String plugin, { List<String> arguments }) async {
+ final String projectPath = await createProject(tempDir, arguments: arguments);
+ final File pubspec = fs.file(fs.path.join(projectPath, 'pubspec.yaml'));
+ String content = await pubspec.readAsString();
+ content = content.replaceFirst(
+ '\ndependencies:\n',
+ '\ndependencies:\n $plugin:\n',
+ );
+ await pubspec.writeAsString(content, flush: true);
+ return projectPath;
+ }
+
+ Future<PackagesCommand> runCommandIn(String projectPath, String verb, { List<String> args }) async {
+ final PackagesCommand command = PackagesCommand();
+ final CommandRunner<void> runner = createTestCommandRunner(command);
+ await runner.run(<String>[
+ 'packages',
+ verb,
+ ...?args,
+ projectPath,
+ ]);
+ return command;
+ }
+
+ void expectExists(String projectPath, String relPath) {
+ expect(
+ fs.isFileSync(fs.path.join(projectPath, relPath)),
+ true,
+ reason: '$projectPath/$relPath should exist, but does not',
+ );
+ }
+
+ void expectContains(String projectPath, String relPath, String substring) {
+ expectExists(projectPath, relPath);
+ expect(
+ fs.file(fs.path.join(projectPath, relPath)).readAsStringSync(),
+ contains(substring),
+ reason: '$projectPath/$relPath has unexpected content',
+ );
+ }
+
+ void expectNotExists(String projectPath, String relPath) {
+ expect(
+ fs.isFileSync(fs.path.join(projectPath, relPath)),
+ false,
+ reason: '$projectPath/$relPath should not exist, but does',
+ );
+ }
+
+ void expectNotContains(String projectPath, String relPath, String substring) {
+ expectExists(projectPath, relPath);
+ expect(
+ fs.file(fs.path.join(projectPath, relPath)).readAsStringSync(),
+ isNot(contains(substring)),
+ reason: '$projectPath/$relPath has unexpected content',
+ );
+ }
+
+ const List<String> pubOutput = <String>[
+ '.packages',
+ 'pubspec.lock',
+ ];
+
+ const List<String> pluginRegistrants = <String>[
+ 'ios/Runner/GeneratedPluginRegistrant.h',
+ 'ios/Runner/GeneratedPluginRegistrant.m',
+ 'android/app/src/main/java/io/flutter/plugins/GeneratedPluginRegistrant.java',
+ ];
+
+ const List<String> modulePluginRegistrants = <String>[
+ '.ios/Flutter/FlutterPluginRegistrant/Classes/GeneratedPluginRegistrant.h',
+ '.ios/Flutter/FlutterPluginRegistrant/Classes/GeneratedPluginRegistrant.m',
+ '.android/Flutter/src/main/java/io/flutter/plugins/GeneratedPluginRegistrant.java',
+ ];
+
+ const List<String> pluginWitnesses = <String>[
+ '.flutter-plugins',
+ 'ios/Podfile',
+ ];
+
+ const List<String> modulePluginWitnesses = <String>[
+ '.flutter-plugins',
+ '.ios/Podfile',
+ ];
+
+ const Map<String, String> pluginContentWitnesses = <String, String>{
+ 'ios/Flutter/Debug.xcconfig': '#include "Pods/Target Support Files/Pods-Runner/Pods-Runner.debug.xcconfig"',
+ 'ios/Flutter/Release.xcconfig': '#include "Pods/Target Support Files/Pods-Runner/Pods-Runner.release.xcconfig"',
+ };
+
+ const Map<String, String> modulePluginContentWitnesses = <String, String>{
+ '.ios/Config/Debug.xcconfig': '#include "Pods/Target Support Files/Pods-Runner/Pods-Runner.debug.xcconfig"',
+ '.ios/Config/Release.xcconfig': '#include "Pods/Target Support Files/Pods-Runner/Pods-Runner.release.xcconfig"',
+ };
+
+ void expectDependenciesResolved(String projectPath) {
+ for (String output in pubOutput) {
+ expectExists(projectPath, output);
+ }
+ }
+
+ void expectZeroPluginsInjected(String projectPath) {
+ for (final String registrant in modulePluginRegistrants) {
+ expectExists(projectPath, registrant);
+ }
+ for (final String witness in pluginWitnesses) {
+ expectNotExists(projectPath, witness);
+ }
+ modulePluginContentWitnesses.forEach((String witness, String content) {
+ expectNotContains(projectPath, witness, content);
+ });
+ }
+
+ void expectPluginInjected(String projectPath) {
+ for (final String registrant in pluginRegistrants) {
+ expectExists(projectPath, registrant);
+ }
+ for (final String witness in pluginWitnesses) {
+ expectExists(projectPath, witness);
+ }
+ pluginContentWitnesses.forEach((String witness, String content) {
+ expectContains(projectPath, witness, content);
+ });
+ }
+
+ void expectModulePluginInjected(String projectPath) {
+ for (final String registrant in modulePluginRegistrants) {
+ expectExists(projectPath, registrant);
+ }
+ for (final String witness in modulePluginWitnesses) {
+ expectExists(projectPath, witness);
+ }
+ modulePluginContentWitnesses.forEach((String witness, String content) {
+ expectContains(projectPath, witness, content);
+ });
+ }
+
+ void removeGeneratedFiles(String projectPath) {
+ final Iterable<String> allFiles = <List<String>>[
+ pubOutput,
+ modulePluginRegistrants,
+ pluginWitnesses,
+ ].expand<String>((List<String> list) => list);
+ for (String path in allFiles) {
+ final File file = fs.file(fs.path.join(projectPath, path));
+ if (file.existsSync())
+ file.deleteSync();
+ }
+ }
+
+ testUsingContext('get fetches packages', () async {
+ final String projectPath = await createProject(tempDir,
+ arguments: <String>['--no-pub', '--template=module']);
+ removeGeneratedFiles(projectPath);
+
+ await runCommandIn(projectPath, 'get');
+
+ expectDependenciesResolved(projectPath);
+ expectZeroPluginsInjected(projectPath);
+ }, timeout: allowForRemotePubInvocation);
+
+ testUsingContext('get --offline fetches packages', () async {
+ final String projectPath = await createProject(tempDir,
+ arguments: <String>['--no-pub', '--template=module']);
+ removeGeneratedFiles(projectPath);
+
+ await runCommandIn(projectPath, 'get', args: <String>['--offline']);
+
+ expectDependenciesResolved(projectPath);
+ expectZeroPluginsInjected(projectPath);
+ }, timeout: allowForCreateFlutterProject);
+
+ testUsingContext('set the number of plugins as usage value', () async {
+ final String projectPath = await createProject(tempDir,
+ arguments: <String>['--no-pub', '--template=module']);
+ removeGeneratedFiles(projectPath);
+
+ final PackagesCommand command = await runCommandIn(projectPath, 'get');
+ final PackagesGetCommand getCommand = command.subcommands['get'] as PackagesGetCommand;
+
+ expect(await getCommand.usageValues, containsPair(kCommandPackagesNumberPlugins, '0'));
+ }, timeout: allowForCreateFlutterProject);
+
+ testUsingContext('indicate that the project is not a module in usage value', () async {
+ final String projectPath = await createProject(tempDir,
+ arguments: <String>['--no-pub']);
+ removeGeneratedFiles(projectPath);
+
+ final PackagesCommand command = await runCommandIn(projectPath, 'get');
+ final PackagesGetCommand getCommand = command.subcommands['get'] as PackagesGetCommand;
+
+ expect(await getCommand.usageValues, containsPair(kCommandPackagesProjectModule, 'false'));
+ }, timeout: allowForCreateFlutterProject);
+
+ testUsingContext('indicate that the project is a module in usage value', () async {
+ final String projectPath = await createProject(tempDir,
+ arguments: <String>['--no-pub', '--template=module']);
+ removeGeneratedFiles(projectPath);
+
+ final PackagesCommand command = await runCommandIn(projectPath, 'get');
+ final PackagesGetCommand getCommand = command.subcommands['get'] as PackagesGetCommand;
+
+ expect(await getCommand.usageValues, containsPair(kCommandPackagesProjectModule, 'true'));
+ }, timeout: allowForCreateFlutterProject);
+
+ testUsingContext('upgrade fetches packages', () async {
+ final String projectPath = await createProject(tempDir,
+ arguments: <String>['--no-pub', '--template=module']);
+ removeGeneratedFiles(projectPath);
+
+ await runCommandIn(projectPath, 'upgrade');
+
+ expectDependenciesResolved(projectPath);
+ expectZeroPluginsInjected(projectPath);
+ }, timeout: allowForRemotePubInvocation);
+
+ testUsingContext('get fetches packages and injects plugin', () async {
+ final String projectPath = await createProjectWithPlugin('path_provider',
+ arguments: <String>['--no-pub', '--template=module']);
+ removeGeneratedFiles(projectPath);
+
+ await runCommandIn(projectPath, 'get');
+
+ expectDependenciesResolved(projectPath);
+ expectModulePluginInjected(projectPath);
+ }, timeout: allowForRemotePubInvocation);
+
+ testUsingContext('get fetches packages and injects plugin in plugin project', () async {
+ final String projectPath = await createProject(
+ tempDir,
+ arguments: <String>['--template=plugin', '--no-pub'],
+ );
+ final String exampleProjectPath = fs.path.join(projectPath, 'example');
+ removeGeneratedFiles(projectPath);
+ removeGeneratedFiles(exampleProjectPath);
+
+ await runCommandIn(projectPath, 'get');
+
+ expectDependenciesResolved(projectPath);
+
+ await runCommandIn(exampleProjectPath, 'get');
+
+ expectDependenciesResolved(exampleProjectPath);
+ expectPluginInjected(exampleProjectPath);
+ }, timeout: allowForRemotePubInvocation);
+ });
+
+ group('packages test/pub', () {
+ MockProcessManager mockProcessManager;
+ MockStdio mockStdio;
+
+ setUp(() {
+ mockProcessManager = MockProcessManager();
+ mockStdio = MockStdio();
+ });
+
+ testUsingContext('test without bot', () async {
+ await createTestCommandRunner(PackagesCommand()).run(<String>['packages', 'test']);
+ final List<String> commands = mockProcessManager.commands;
+ expect(commands, hasLength(3));
+ expect(commands[0], matches(r'dart-sdk[\\/]bin[\\/]pub'));
+ expect(commands[1], 'run');
+ expect(commands[2], 'test');
+ }, overrides: <Type, Generator>{
+ ProcessManager: () => mockProcessManager,
+ Stdio: () => mockStdio,
+ BotDetector: () => const AlwaysFalseBotDetector(),
+ });
+
+ testUsingContext('test with bot', () async {
+ await createTestCommandRunner(PackagesCommand()).run(<String>['packages', 'test']);
+ final List<String> commands = mockProcessManager.commands;
+ expect(commands, hasLength(4));
+ expect(commands[0], matches(r'dart-sdk[\\/]bin[\\/]pub'));
+ expect(commands[1], '--trace');
+ expect(commands[2], 'run');
+ expect(commands[3], 'test');
+ }, overrides: <Type, Generator>{
+ ProcessManager: () => mockProcessManager,
+ Stdio: () => mockStdio,
+ BotDetector: () => const AlwaysTrueBotDetector(),
+ });
+
+ testUsingContext('run', () async {
+ await createTestCommandRunner(PackagesCommand()).run(<String>['packages', '--verbose', 'pub', 'run', '--foo', 'bar']);
+ final List<String> commands = mockProcessManager.commands;
+ expect(commands, hasLength(4));
+ expect(commands[0], matches(r'dart-sdk[\\/]bin[\\/]pub'));
+ expect(commands[1], 'run');
+ expect(commands[2], '--foo');
+ expect(commands[3], 'bar');
+ }, overrides: <Type, Generator>{
+ ProcessManager: () => mockProcessManager,
+ Stdio: () => mockStdio,
+ });
+
+ testUsingContext('pub publish', () async {
+ final PromptingProcess process = PromptingProcess();
+ mockProcessManager.processFactory = (List<String> commands) => process;
+ final Future<void> runPackages = createTestCommandRunner(PackagesCommand()).run(<String>['packages', 'pub', 'publish']);
+ final Future<void> runPrompt = process.showPrompt('Proceed (y/n)? ', <String>['hello', 'world']);
+ final Future<void> simulateUserInput = Future<void>(() {
+ mockStdio.simulateStdin('y');
+ });
+ await Future.wait<void>(<Future<void>>[runPackages, runPrompt, simulateUserInput]);
+ final List<String> commands = mockProcessManager.commands;
+ expect(commands, hasLength(2));
+ expect(commands[0], matches(r'dart-sdk[\\/]bin[\\/]pub'));
+ expect(commands[1], 'publish');
+ final List<String> stdout = mockStdio.writtenToStdout;
+ expect(stdout, hasLength(4));
+ expect(stdout.sublist(0, 2), contains('Proceed (y/n)? '));
+ expect(stdout.sublist(0, 2), contains('y\n'));
+ expect(stdout[2], 'hello\n');
+ expect(stdout[3], 'world\n');
+ }, overrides: <Type, Generator>{
+ ProcessManager: () => mockProcessManager,
+ Stdio: () => mockStdio,
+ });
+
+ testUsingContext('publish', () async {
+ await createTestCommandRunner(PackagesCommand()).run(<String>['packages', 'publish']);
+ final List<String> commands = mockProcessManager.commands;
+ expect(commands, hasLength(3));
+ expect(commands[0], matches(r'dart-sdk[\\/]bin[\\/]pub'));
+ expect(commands[1], '--trace');
+ expect(commands[2], 'publish');
+ }, overrides: <Type, Generator>{
+ ProcessManager: () => mockProcessManager,
+ Stdio: () => mockStdio,
+ BotDetector: () => const AlwaysTrueBotDetector(),
+ });
+
+ testUsingContext('deps', () async {
+ await createTestCommandRunner(PackagesCommand()).run(<String>['packages', 'deps']);
+ final List<String> commands = mockProcessManager.commands;
+ expect(commands, hasLength(3));
+ expect(commands[0], matches(r'dart-sdk[\\/]bin[\\/]pub'));
+ expect(commands[1], '--trace');
+ expect(commands[2], 'deps');
+ }, overrides: <Type, Generator>{
+ ProcessManager: () => mockProcessManager,
+ Stdio: () => mockStdio,
+ BotDetector: () => const AlwaysTrueBotDetector(),
+ });
+
+ testUsingContext('cache', () async {
+ await createTestCommandRunner(PackagesCommand()).run(<String>['packages', 'cache']);
+ final List<String> commands = mockProcessManager.commands;
+ expect(commands, hasLength(3));
+ expect(commands[0], matches(r'dart-sdk[\\/]bin[\\/]pub'));
+ expect(commands[1], '--trace');
+ expect(commands[2], 'cache');
+ }, overrides: <Type, Generator>{
+ ProcessManager: () => mockProcessManager,
+ Stdio: () => mockStdio,
+ BotDetector: () => const AlwaysTrueBotDetector(),
+ });
+
+ testUsingContext('version', () async {
+ await createTestCommandRunner(PackagesCommand()).run(<String>['packages', 'version']);
+ final List<String> commands = mockProcessManager.commands;
+ expect(commands, hasLength(3));
+ expect(commands[0], matches(r'dart-sdk[\\/]bin[\\/]pub'));
+ expect(commands[1], '--trace');
+ expect(commands[2], 'version');
+ }, overrides: <Type, Generator>{
+ ProcessManager: () => mockProcessManager,
+ Stdio: () => mockStdio,
+ BotDetector: () => const AlwaysTrueBotDetector(),
+ });
+
+ testUsingContext('uploader', () async {
+ await createTestCommandRunner(PackagesCommand()).run(<String>['packages', 'uploader']);
+ final List<String> commands = mockProcessManager.commands;
+ expect(commands, hasLength(3));
+ expect(commands[0], matches(r'dart-sdk[\\/]bin[\\/]pub'));
+ expect(commands[1], '--trace');
+ expect(commands[2], 'uploader');
+ }, overrides: <Type, Generator>{
+ ProcessManager: () => mockProcessManager,
+ Stdio: () => mockStdio,
+ BotDetector: () => const AlwaysTrueBotDetector(),
+ });
+
+ testUsingContext('global', () async {
+ await createTestCommandRunner(PackagesCommand()).run(<String>['packages', 'global', 'list']);
+ final List<String> commands = mockProcessManager.commands;
+ expect(commands, hasLength(4));
+ expect(commands[0], matches(r'dart-sdk[\\/]bin[\\/]pub'));
+ expect(commands[1], '--trace');
+ expect(commands[2], 'global');
+ expect(commands[3], 'list');
+ }, overrides: <Type, Generator>{
+ ProcessManager: () => mockProcessManager,
+ Stdio: () => mockStdio,
+ BotDetector: () => const AlwaysTrueBotDetector(),
+ });
+ });
+}
diff --git a/packages/flutter_tools/test/general.shard/commands/precache_test.dart b/packages/flutter_tools/test/general.shard/commands/precache_test.dart
new file mode 100644
index 0000000..0308da6
--- /dev/null
+++ b/packages/flutter_tools/test/general.shard/commands/precache_test.dart
@@ -0,0 +1,87 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'package:flutter_tools/src/cache.dart';
+import 'package:flutter_tools/src/commands/precache.dart';
+import 'package:flutter_tools/src/runner/flutter_command.dart';
+import 'package:flutter_tools/src/version.dart';
+import 'package:mockito/mockito.dart';
+
+import '../../src/common.dart';
+import '../../src/context.dart';
+import '../../src/mocks.dart';
+
+void main() {
+ group('precache', () {
+ final MockCache cache = MockCache();
+ Set<DevelopmentArtifact> artifacts;
+
+ when(cache.isUpToDate()).thenReturn(false);
+ when(cache.updateAll(any)).thenAnswer((Invocation invocation) {
+ artifacts = invocation.positionalArguments.first;
+ return Future<void>.value(null);
+ });
+
+ testUsingContext('Adds artifact flags to requested artifacts', () async {
+ final PrecacheCommand command = PrecacheCommand();
+ applyMocksToCommand(command);
+ await createTestCommandRunner(command).run(
+ const <String>['precache', '--ios', '--android', '--web', '--macos', '--linux', '--windows', '--fuchsia']
+ );
+ expect(artifacts, unorderedEquals(<DevelopmentArtifact>{
+ DevelopmentArtifact.universal,
+ DevelopmentArtifact.iOS,
+ DevelopmentArtifact.android,
+ DevelopmentArtifact.web,
+ DevelopmentArtifact.macOS,
+ DevelopmentArtifact.linux,
+ DevelopmentArtifact.windows,
+ DevelopmentArtifact.fuchsia,
+ }));
+ }, overrides: <Type, Generator>{
+ Cache: () => cache,
+ });
+
+ final MockFlutterVersion flutterVersion = MockFlutterVersion();
+ when(flutterVersion.isMaster).thenReturn(false);
+
+ testUsingContext('Adds artifact flags to requested artifacts on stable', () async {
+ // Release lock between test cases.
+ Cache.releaseLockEarly();
+ final PrecacheCommand command = PrecacheCommand();
+ applyMocksToCommand(command);
+ await createTestCommandRunner(command).run(
+ const <String>['precache', '--ios', '--android', '--web', '--macos', '--linux', '--windows', '--fuchsia']
+ );
+ expect(artifacts, unorderedEquals(<DevelopmentArtifact>{
+ DevelopmentArtifact.universal,
+ DevelopmentArtifact.iOS,
+ DevelopmentArtifact.android,
+ }));
+ }, overrides: <Type, Generator>{
+ Cache: () => cache,
+ FlutterVersion: () => flutterVersion,
+ });
+
+ testUsingContext('Downloads artifacts when --force is provided', () async {
+ when(cache.isUpToDate()).thenReturn(true);
+ // Release lock between test cases.
+ Cache.releaseLockEarly();
+ final PrecacheCommand command = PrecacheCommand();
+ applyMocksToCommand(command);
+ await createTestCommandRunner(command).run(const <String>['precache', '--force']);
+ expect(artifacts, unorderedEquals(<DevelopmentArtifact>{
+ DevelopmentArtifact.universal,
+ DevelopmentArtifact.iOS,
+ DevelopmentArtifact.android,
+ }));
+ }, overrides: <Type, Generator>{
+ Cache: () => cache,
+ FlutterVersion: () => flutterVersion,
+ });
+ });
+}
+
+class MockFlutterVersion extends Mock implements FlutterVersion {}
+class MockCache extends Mock implements Cache {}
diff --git a/packages/flutter_tools/test/general.shard/commands/run_test.dart b/packages/flutter_tools/test/general.shard/commands/run_test.dart
new file mode 100644
index 0000000..b743a36
--- /dev/null
+++ b/packages/flutter_tools/test/general.shard/commands/run_test.dart
@@ -0,0 +1,262 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'package:args/command_runner.dart';
+import 'package:flutter_tools/src/application_package.dart';
+import 'package:flutter_tools/src/base/common.dart';
+import 'package:flutter_tools/src/build_info.dart';
+import 'package:flutter_tools/src/cache.dart';
+import 'package:flutter_tools/src/commands/run.dart';
+import 'package:flutter_tools/src/device.dart';
+import 'package:flutter_tools/src/runner/flutter_command.dart';
+import 'package:flutter_tools/src/version.dart';
+import 'package:mockito/mockito.dart';
+
+import '../../src/common.dart';
+import '../../src/context.dart';
+import '../../src/mocks.dart';
+
+void main() {
+ group('run', () {
+ MockApplicationPackageFactory mockApplicationPackageFactory;
+ MockDeviceManager mockDeviceManager;
+ MockFlutterVersion mockStableFlutterVersion;
+ MockFlutterVersion mockUnstableFlutterVersion;
+
+ setUpAll(() {
+ Cache.disableLocking();
+ mockApplicationPackageFactory = MockApplicationPackageFactory();
+ mockDeviceManager = MockDeviceManager();
+ mockStableFlutterVersion = MockFlutterVersion(isStable: true);
+ mockUnstableFlutterVersion = MockFlutterVersion(isStable: false);
+ });
+
+ testUsingContext('fails when target not found', () async {
+ final RunCommand command = RunCommand();
+ applyMocksToCommand(command);
+ try {
+ await createTestCommandRunner(command).run(<String>['run', '-t', 'abc123']);
+ fail('Expect exception');
+ } on ToolExit catch (e) {
+ expect(e.exitCode ?? 1, 1);
+ }
+ });
+
+
+ group('dart-flags option', () {
+ setUpAll(() {
+ when(mockDeviceManager.getDevices()).thenAnswer((Invocation invocation) {
+ return Stream<Device>.fromIterable(<Device>[
+ FakeDevice(),
+ ]);
+ });
+ });
+
+ RunCommand command;
+ List<String> args;
+ setUp(() {
+ command = TestRunCommand();
+ args = <String> [
+ 'run',
+ '--dart-flags', '"--observe"',
+ '--no-hot',
+ ];
+ });
+
+ testUsingContext('is not available on stable channel', () async {
+ // Stable branch.
+ try {
+ await createTestCommandRunner(command).run(args);
+ fail('Expect exception');
+ // ignore: unused_catch_clause
+ } on UsageException catch(e) {
+ // Not available while on stable branch.
+ }
+ }, overrides: <Type, Generator>{
+ DeviceManager: () => mockDeviceManager,
+ FlutterVersion: () => mockStableFlutterVersion,
+ });
+
+ testUsingContext('is populated in debug mode', () async {
+ // FakeDevice.startApp checks that --dart-flags doesn't get dropped and
+ // throws ToolExit with FakeDevice.kSuccess if the flag is populated.
+ try {
+ await createTestCommandRunner(command).run(args);
+ fail('Expect exception');
+ } on ToolExit catch (e) {
+ expect(e.exitCode, FakeDevice.kSuccess);
+ }
+ }, overrides: <Type, Generator>{
+ ApplicationPackageFactory: () => mockApplicationPackageFactory,
+ DeviceManager: () => mockDeviceManager,
+ FlutterVersion: () => mockUnstableFlutterVersion,
+ });
+
+ testUsingContext('is populated in profile mode', () async {
+ args.add('--profile');
+
+ // FakeDevice.startApp checks that --dart-flags doesn't get dropped and
+ // throws ToolExit with FakeDevice.kSuccess if the flag is populated.
+ try {
+ await createTestCommandRunner(command).run(args);
+ fail('Expect exception');
+ } on ToolExit catch (e) {
+ expect(e.exitCode, FakeDevice.kSuccess);
+ }
+ }, overrides: <Type, Generator>{
+ ApplicationPackageFactory: () => mockApplicationPackageFactory,
+ DeviceManager: () => mockDeviceManager,
+ FlutterVersion: () => mockUnstableFlutterVersion,
+ });
+
+ testUsingContext('is not populated in release mode', () async {
+ args.add('--release');
+
+ // FakeDevice.startApp checks that --dart-flags *does* get dropped and
+ // throws ToolExit with FakeDevice.kSuccess if the flag is set to the
+ // empty string.
+ try {
+ await createTestCommandRunner(command).run(args);
+ fail('Expect exception');
+ } on ToolExit catch (e) {
+ expect(e.exitCode, FakeDevice.kSuccess);
+ }
+ }, overrides: <Type, Generator>{
+ ApplicationPackageFactory: () => mockApplicationPackageFactory,
+ DeviceManager: () => mockDeviceManager,
+ FlutterVersion: () => mockUnstableFlutterVersion,
+ });
+ });
+
+ testUsingContext('should only request artifacts corresponding to connected devices', () async {
+ when(mockDeviceManager.getDevices()).thenAnswer((Invocation invocation) {
+ return Stream<Device>.fromIterable(<Device>[
+ MockDevice(TargetPlatform.android_arm),
+ ]);
+ });
+
+ expect(await RunCommand().requiredArtifacts, unorderedEquals(<DevelopmentArtifact>{
+ DevelopmentArtifact.universal,
+ DevelopmentArtifact.android,
+ }));
+
+ when(mockDeviceManager.getDevices()).thenAnswer((Invocation invocation) {
+ return Stream<Device>.fromIterable(<Device>[
+ MockDevice(TargetPlatform.ios),
+ ]);
+ });
+
+ expect(await RunCommand().requiredArtifacts, unorderedEquals(<DevelopmentArtifact>{
+ DevelopmentArtifact.universal,
+ DevelopmentArtifact.iOS,
+ }));
+
+ when(mockDeviceManager.getDevices()).thenAnswer((Invocation invocation) {
+ return Stream<Device>.fromIterable(<Device>[
+ MockDevice(TargetPlatform.ios),
+ MockDevice(TargetPlatform.android_arm),
+ ]);
+ });
+
+ expect(await RunCommand().requiredArtifacts, unorderedEquals(<DevelopmentArtifact>{
+ DevelopmentArtifact.universal,
+ DevelopmentArtifact.iOS,
+ DevelopmentArtifact.android,
+ }));
+
+ when(mockDeviceManager.getDevices()).thenAnswer((Invocation invocation) {
+ return Stream<Device>.fromIterable(<Device>[
+ MockDevice(TargetPlatform.web_javascript),
+ ]);
+ });
+
+ expect(await RunCommand().requiredArtifacts, unorderedEquals(<DevelopmentArtifact>{
+ DevelopmentArtifact.universal,
+ DevelopmentArtifact.web,
+ }));
+ }, overrides: <Type, Generator>{
+ DeviceManager: () => mockDeviceManager,
+ });
+ });
+}
+
+class MockDeviceManager extends Mock implements DeviceManager {}
+class MockDevice extends Mock implements Device {
+ MockDevice(this._targetPlatform);
+
+ final TargetPlatform _targetPlatform;
+
+ @override
+ Future<TargetPlatform> get targetPlatform async => _targetPlatform;
+}
+
+class TestRunCommand extends RunCommand {
+ @override
+ // ignore: must_call_super
+ Future<void> validateCommand() async {
+ devices = await deviceManager.getDevices().toList();
+ }
+}
+
+class MockStableFlutterVersion extends MockFlutterVersion {
+ @override
+ bool get isMaster => false;
+}
+
+class FakeDevice extends Fake implements Device {
+ static const int kSuccess = 1;
+ static const int kFailure = -1;
+ final TargetPlatform _targetPlatform = TargetPlatform.ios;
+
+ void _throwToolExit(int code) => throwToolExit(null, exitCode: code);
+
+ @override
+ Future<bool> get isLocalEmulator => Future<bool>.value(false);
+
+ @override
+ bool get supportsHotReload => false;
+
+ @override
+ Future<String> get sdkNameAndVersion => Future<String>.value('');
+
+ @override
+ DeviceLogReader getLogReader({ ApplicationPackage app }) {
+ return MockDeviceLogReader();
+ }
+
+ @override
+ String get name => 'FakeDevice';
+
+ @override
+ Future<TargetPlatform> get targetPlatform async => _targetPlatform;
+
+ @override
+ Future<LaunchResult> startApp(
+ ApplicationPackage package, {
+ String mainPath,
+ String route,
+ DebuggingOptions debuggingOptions,
+ Map<String, dynamic> platformArgs,
+ bool prebuiltApplication = false,
+ bool usesTerminalUi = true,
+ bool ipv6 = false,
+ }) async {
+ final String dartFlags = debuggingOptions.dartFlags;
+ // In release mode, --dart-flags should be set to the empty string and
+ // provided flags should be dropped. In debug and profile modes,
+ // --dart-flags should not be empty.
+ if (debuggingOptions.buildInfo.isRelease) {
+ if (dartFlags.isNotEmpty) {
+ _throwToolExit(kFailure);
+ }
+ _throwToolExit(kSuccess);
+ } else {
+ if (dartFlags.isEmpty) {
+ _throwToolExit(kFailure);
+ }
+ _throwToolExit(kSuccess);
+ }
+ return null;
+ }
+}
diff --git a/packages/flutter_tools/test/general.shard/commands/shell_completion_test.dart b/packages/flutter_tools/test/general.shard/commands/shell_completion_test.dart
new file mode 100644
index 0000000..00b4aac
--- /dev/null
+++ b/packages/flutter_tools/test/general.shard/commands/shell_completion_test.dart
@@ -0,0 +1,91 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'package:file/memory.dart';
+import 'package:flutter_tools/src/base/common.dart';
+import 'package:flutter_tools/src/base/context.dart';
+import 'package:flutter_tools/src/base/file_system.dart';
+import 'package:flutter_tools/src/base/io.dart';
+import 'package:flutter_tools/src/cache.dart';
+import 'package:flutter_tools/src/commands/shell_completion.dart';
+
+import '../../src/common.dart';
+import '../../src/context.dart';
+import '../../src/mocks.dart';
+
+void main() {
+ group('shell_completion', () {
+ MockStdio mockStdio;
+
+ setUp(() {
+ Cache.disableLocking();
+ mockStdio = MockStdio();
+ });
+
+ testUsingContext('generates bash initialization script to stdout', () async {
+ final ShellCompletionCommand command = ShellCompletionCommand();
+ await createTestCommandRunner(command).run(<String>['bash-completion']);
+ expect(mockStdio.writtenToStdout.length, equals(1));
+ expect(mockStdio.writtenToStdout.first, contains('__flutter_completion'));
+ }, overrides: <Type, Generator>{
+ Stdio: () => mockStdio,
+ });
+
+ testUsingContext('generates bash initialization script to stdout with arg', () async {
+ final ShellCompletionCommand command = ShellCompletionCommand();
+ await createTestCommandRunner(command).run(<String>['bash-completion', '-']);
+ expect(mockStdio.writtenToStdout.length, equals(1));
+ expect(mockStdio.writtenToStdout.first, contains('__flutter_completion'));
+ }, overrides: <Type, Generator>{
+ Stdio: () => mockStdio,
+ });
+
+ testUsingContext('generates bash initialization script to output file', () async {
+ final ShellCompletionCommand command = ShellCompletionCommand();
+ const String outputFile = 'bash-setup.sh';
+ await createTestCommandRunner(command).run(
+ <String>['bash-completion', outputFile],
+ );
+ expect(fs.isFileSync(outputFile), isTrue);
+ expect(fs.file(outputFile).readAsStringSync(), contains('__flutter_completion'));
+ }, overrides: <Type, Generator>{
+ FileSystem: () => MemoryFileSystem(),
+ Stdio: () => mockStdio,
+ });
+
+ testUsingContext("won't overwrite existing output file ", () async {
+ final ShellCompletionCommand command = ShellCompletionCommand();
+ const String outputFile = 'bash-setup.sh';
+ fs.file(outputFile).createSync();
+ try {
+ await createTestCommandRunner(command).run(
+ <String>['bash-completion', outputFile],
+ );
+ fail('Expect ToolExit exception');
+ } on ToolExit catch (error) {
+ expect(error.exitCode ?? 1, 1);
+ expect(error.message, contains('Use --overwrite'));
+ }
+ expect(fs.isFileSync(outputFile), isTrue);
+ expect(fs.file(outputFile).readAsStringSync(), isEmpty);
+ }, overrides: <Type, Generator>{
+ FileSystem: () => MemoryFileSystem(),
+ Stdio: () => mockStdio,
+ });
+
+ testUsingContext('will overwrite existing output file if given --overwrite', () async {
+ final ShellCompletionCommand command = ShellCompletionCommand();
+ const String outputFile = 'bash-setup.sh';
+ fs.file(outputFile).createSync();
+ await createTestCommandRunner(command).run(
+ <String>['bash-completion', '--overwrite', outputFile],
+ );
+ expect(fs.isFileSync(outputFile), isTrue);
+ expect(fs.file(outputFile).readAsStringSync(), contains('__flutter_completion'));
+ }, overrides: <Type, Generator>{
+ FileSystem: () => MemoryFileSystem(),
+ Stdio: () => mockStdio,
+ });
+ });
+}
diff --git a/packages/flutter_tools/test/general.shard/commands/test_test.dart b/packages/flutter_tools/test/general.shard/commands/test_test.dart
new file mode 100644
index 0000000..348ce99
--- /dev/null
+++ b/packages/flutter_tools/test/general.shard/commands/test_test.dart
@@ -0,0 +1,221 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// 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:flutter_tools/src/base/file_system.dart';
+import 'package:flutter_tools/src/base/io.dart';
+import 'package:flutter_tools/src/cache.dart';
+import 'package:flutter_tools/src/dart/sdk.dart';
+
+import '../../src/common.dart';
+import '../../src/context.dart';
+
+// This test depends on some files in ///dev/automated_tests/flutter_test/*
+
+Future<void> _testExclusionLock;
+
+void main() {
+ group('flutter test should', () {
+
+ final String automatedTestsDirectory = fs.path.join('..', '..', 'dev', 'automated_tests');
+ final String flutterTestDirectory = fs.path.join(automatedTestsDirectory, 'flutter_test');
+
+ testUsingContext('not have extraneous error messages', () async {
+ Cache.flutterRoot = '../..';
+ return _testFile('trivial_widget', automatedTestsDirectory, flutterTestDirectory, exitCode: isZero);
+ }, skip: io.Platform.isLinux); // Flutter on Linux sometimes has problems with font resolution (#7224)
+
+ testUsingContext('report nice errors for exceptions thrown within testWidgets()', () async {
+ Cache.flutterRoot = '../..';
+ return _testFile('exception_handling', automatedTestsDirectory, flutterTestDirectory);
+ }, skip: io.Platform.isWindows); // TODO(chunhtai): Dart on Windows has trouble with unicode characters in output (#35425).
+
+ testUsingContext('report a nice error when a guarded function was called without await', () async {
+ Cache.flutterRoot = '../..';
+ return _testFile('test_async_utils_guarded', automatedTestsDirectory, flutterTestDirectory);
+ }, skip: io.Platform.isWindows); // TODO(chunhtai): Dart on Windows has trouble with unicode characters in output (#35425).
+
+ testUsingContext('report a nice error when an async function was called without await', () async {
+ Cache.flutterRoot = '../..';
+ return _testFile('test_async_utils_unguarded', automatedTestsDirectory, flutterTestDirectory);
+ }, skip: io.Platform.isWindows); // TODO(chunhtai): Dart on Windows has trouble with unicode characters in output (#35425).
+
+ testUsingContext('report a nice error when a Ticker is left running', () async {
+ Cache.flutterRoot = '../..';
+ return _testFile('ticker', automatedTestsDirectory, flutterTestDirectory);
+ }, skip: io.Platform.isWindows); // TODO(chunhtai): Dart on Windows has trouble with unicode characters in output (#35425).
+
+ testUsingContext('report a nice error when a pubspec.yaml is missing a flutter_test dependency', () async {
+ final String missingDependencyTests = fs.path.join('..', '..', 'dev', 'missing_dependency_tests');
+ Cache.flutterRoot = '../..';
+ return _testFile('trivial', missingDependencyTests, missingDependencyTests);
+ }, skip: io.Platform.isWindows); // TODO(chunhtai): Dart on Windows has trouble with unicode characters in output (#35425).
+
+ testUsingContext('report which user created widget caused the error', () async {
+ Cache.flutterRoot = '../..';
+ return _testFile('print_user_created_ancestor', automatedTestsDirectory, flutterTestDirectory,
+ extraArguments: const <String>['--track-widget-creation']);
+ }, skip: io.Platform.isWindows); // TODO(chunhtai): Dart on Windows has trouble with unicode characters in output (#35425).
+
+ testUsingContext('report which user created widget caused the error - no flag', () async {
+ Cache.flutterRoot = '../..';
+ return _testFile('print_user_created_ancestor_no_flag', automatedTestsDirectory, flutterTestDirectory);
+ }, skip: io.Platform.isWindows); // TODO(chunhtai): Dart on Windows has trouble with unicode characters in output (#35425).
+
+ testUsingContext('run a test when its name matches a regexp', () async {
+ Cache.flutterRoot = '../..';
+ final ProcessResult result = await _runFlutterTest('filtering', automatedTestsDirectory, flutterTestDirectory,
+ extraArguments: const <String>['--name', 'inc.*de']);
+ if (!result.stdout.contains('+1: All tests passed'))
+ fail('unexpected output from test:\n\n${result.stdout}\n-- end stdout --\n\n');
+ expect(result.exitCode, 0);
+ });
+
+ testUsingContext('run a test when its name contains a string', () async {
+ Cache.flutterRoot = '../..';
+ final ProcessResult result = await _runFlutterTest('filtering', automatedTestsDirectory, flutterTestDirectory,
+ extraArguments: const <String>['--plain-name', 'include']);
+ if (!result.stdout.contains('+1: All tests passed'))
+ fail('unexpected output from test:\n\n${result.stdout}\n-- end stdout --\n\n');
+ expect(result.exitCode, 0);
+ });
+
+ testUsingContext('test runs to completion', () async {
+ Cache.flutterRoot = '../..';
+ final ProcessResult result = await _runFlutterTest('trivial', automatedTestsDirectory, flutterTestDirectory,
+ extraArguments: const <String>['--verbose']);
+ if ((!result.stdout.contains('+1: All tests passed')) ||
+ (!result.stdout.contains('test 0: starting shell process')) ||
+ (!result.stdout.contains('test 0: deleting temporary directory')) ||
+ (!result.stdout.contains('test 0: finished')) ||
+ (!result.stdout.contains('test package returned with exit code 0')))
+ fail('unexpected output from test:\n\n${result.stdout}\n-- end stdout --\n\n');
+ if (result.stderr.isNotEmpty)
+ fail('unexpected error output from test:\n\n${result.stderr}\n-- end stderr --\n\n');
+ expect(result.exitCode, 0);
+ });
+
+ });
+}
+
+Future<void> _testFile(
+ String testName,
+ String workingDirectory,
+ String testDirectory, {
+ Matcher exitCode,
+ List<String> extraArguments = const <String>[],
+ }) async {
+ exitCode ??= isNonZero;
+ final String fullTestExpectation = fs.path.join(testDirectory, '${testName}_expectation.txt');
+ final File expectationFile = fs.file(fullTestExpectation);
+ if (!expectationFile.existsSync())
+ fail('missing expectation file: $expectationFile');
+
+ while (_testExclusionLock != null)
+ await _testExclusionLock;
+
+ final ProcessResult exec = await _runFlutterTest(
+ testName,
+ workingDirectory,
+ testDirectory,
+ extraArguments: extraArguments,
+ );
+
+ expect(exec.exitCode, exitCode);
+ final List<String> output = exec.stdout.split('\n');
+ if (output.first == 'Waiting for another flutter command to release the startup lock...')
+ output.removeAt(0);
+ if (output.first.startsWith('Running "flutter pub get" in'))
+ output.removeAt(0);
+ output.add('<<stderr>>');
+ output.addAll(exec.stderr.split('\n'));
+ final List<String> expectations = fs.file(fullTestExpectation).readAsLinesSync();
+ bool allowSkip = false;
+ int expectationLineNumber = 0;
+ int outputLineNumber = 0;
+ bool haveSeenStdErrMarker = false;
+ while (expectationLineNumber < expectations.length) {
+ expect(
+ output,
+ hasLength(greaterThan(outputLineNumber)),
+ reason: 'Failure in $testName to compare to $fullTestExpectation',
+ );
+ final String expectationLine = expectations[expectationLineNumber];
+ String outputLine = output[outputLineNumber];
+ if (expectationLine == '<<skip until matching line>>') {
+ allowSkip = true;
+ expectationLineNumber += 1;
+ continue;
+ }
+ if (allowSkip) {
+ if (!RegExp(expectationLine).hasMatch(outputLine)) {
+ outputLineNumber += 1;
+ continue;
+ }
+ allowSkip = false;
+ }
+ if (expectationLine == '<<stderr>>') {
+ expect(haveSeenStdErrMarker, isFalse);
+ haveSeenStdErrMarker = true;
+ }
+ if (!RegExp(expectationLine).hasMatch(outputLine) && outputLineNumber + 1 < output.length) {
+ // Check if the RegExp can match the next two lines in the output so
+ // that it is possible to write expectations that still hold even if a
+ // line is wrapped slightly differently due to for example a file name
+ // being longer on one platform than another.
+ final String mergedLines = '$outputLine\n${output[outputLineNumber+1]}';
+ if (RegExp(expectationLine).hasMatch(mergedLines)) {
+ outputLineNumber += 1;
+ outputLine = mergedLines;
+ }
+ }
+
+ expect(outputLine, matches(expectationLine), reason: 'Full output:\n- - - -----8<----- - - -\n${output.join("\n")}\n- - - -----8<----- - - -');
+ expectationLineNumber += 1;
+ outputLineNumber += 1;
+ }
+ expect(allowSkip, isFalse);
+ if (!haveSeenStdErrMarker)
+ expect(exec.stderr, '');
+}
+
+Future<ProcessResult> _runFlutterTest(
+ String testName,
+ String workingDirectory,
+ String testDirectory, {
+ List<String> extraArguments = const <String>[],
+}) async {
+
+ final String testFilePath = fs.path.join(testDirectory, '${testName}_test.dart');
+ final File testFile = fs.file(testFilePath);
+ if (!testFile.existsSync())
+ fail('missing test file: $testFile');
+
+ final List<String> args = <String>[
+ ...dartVmFlags,
+ fs.path.absolute(fs.path.join('bin', 'flutter_tools.dart')),
+ 'test',
+ '--no-color',
+ ...extraArguments,
+ testFilePath
+ ];
+
+ while (_testExclusionLock != null)
+ await _testExclusionLock;
+
+ final Completer<void> testExclusionCompleter = Completer<void>();
+ _testExclusionLock = testExclusionCompleter.future;
+ try {
+ return await Process.run(
+ fs.path.join(dartSdkPath, 'bin', 'dart'),
+ args,
+ workingDirectory: workingDirectory,
+ );
+ } finally {
+ _testExclusionLock = null;
+ testExclusionCompleter.complete();
+ }
+}
diff --git a/packages/flutter_tools/test/general.shard/commands/update_packages_test.dart b/packages/flutter_tools/test/general.shard/commands/update_packages_test.dart
new file mode 100644
index 0000000..6097ba0
--- /dev/null
+++ b/packages/flutter_tools/test/general.shard/commands/update_packages_test.dart
@@ -0,0 +1,18 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'package:flutter_tools/src/commands/update_packages.dart';
+
+import '../../src/common.dart';
+import '../../src/context.dart';
+
+void main() {
+ group('UpdatePackagesCommand', () {
+ // Marking it as experimental breaks bots tests and packaging scripts on stable branches.
+ testUsingContext('is not marked as experimental', () async {
+ final UpdatePackagesCommand command = UpdatePackagesCommand();
+ expect(command.isExperimental, isFalse);
+ });
+ });
+}
diff --git a/packages/flutter_tools/test/general.shard/commands/upgrade_test.dart b/packages/flutter_tools/test/general.shard/commands/upgrade_test.dart
new file mode 100644
index 0000000..ac9879d
--- /dev/null
+++ b/packages/flutter_tools/test/general.shard/commands/upgrade_test.dart
@@ -0,0 +1,192 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'package:flutter_tools/src/base/common.dart';
+import 'package:flutter_tools/src/base/file_system.dart';
+import 'package:flutter_tools/src/base/io.dart';
+import 'package:flutter_tools/src/base/os.dart';
+import 'package:flutter_tools/src/cache.dart';
+import 'package:flutter_tools/src/commands/upgrade.dart';
+import 'package:flutter_tools/src/runner/flutter_command.dart';
+import 'package:flutter_tools/src/version.dart';
+import 'package:mockito/mockito.dart';
+import 'package:process/process.dart';
+
+import '../../src/common.dart';
+import '../../src/context.dart';
+
+void main() {
+ group('UpgradeCommandRunner', () {
+ FakeUpgradeCommandRunner fakeCommandRunner;
+ UpgradeCommandRunner realCommandRunner;
+ MockProcessManager processManager;
+ final MockFlutterVersion flutterVersion = MockFlutterVersion();
+ const GitTagVersion gitTagVersion = GitTagVersion(1, 2, 3, 4, 5, 'asd');
+ when(flutterVersion.channel).thenReturn('dev');
+
+ setUp(() {
+ fakeCommandRunner = FakeUpgradeCommandRunner();
+ realCommandRunner = UpgradeCommandRunner();
+ processManager = MockProcessManager();
+ fakeCommandRunner.willHaveUncomittedChanges = false;
+ });
+
+ test('throws on unknown tag, official branch, noforce', () async {
+ final Future<FlutterCommandResult> result = fakeCommandRunner.runCommand(
+ false,
+ const GitTagVersion.unknown(),
+ flutterVersion,
+ );
+ expect(result, throwsA(isInstanceOf<ToolExit>()));
+ });
+
+ test('does not throw on unknown tag, official branch, force', () async {
+ final Future<FlutterCommandResult> result = fakeCommandRunner.runCommand(
+ true,
+ const GitTagVersion.unknown(),
+ flutterVersion,
+ );
+ expect(await result, null);
+ });
+
+ test('throws tool exit with uncommitted changes', () async {
+ fakeCommandRunner.willHaveUncomittedChanges = true;
+ final Future<FlutterCommandResult> result = fakeCommandRunner.runCommand(
+ false,
+ gitTagVersion,
+ flutterVersion,
+ );
+ expect(result, throwsA(isA<ToolExit>()));
+ });
+
+ test('does not throw tool exit with uncommitted changes and force', () async {
+ fakeCommandRunner.willHaveUncomittedChanges = true;
+ final Future<FlutterCommandResult> result = fakeCommandRunner.runCommand(
+ true,
+ gitTagVersion,
+ flutterVersion,
+ );
+ expect(await result, null);
+ });
+
+ test('Doesn\'t throw on known tag, dev branch, no force', () async {
+ final Future<FlutterCommandResult> result = fakeCommandRunner.runCommand(
+ false,
+ gitTagVersion,
+ flutterVersion,
+ );
+ expect(await result, null);
+ });
+
+ testUsingContext('verifyUpstreamConfigured', () async {
+ when(processManager.run(
+ <String>['git', 'rev-parse', '@{u}'],
+ environment:anyNamed('environment'),
+ workingDirectory: anyNamed('workingDirectory'))
+ ).thenAnswer((Invocation invocation) async {
+ return FakeProcessResult()
+ ..exitCode = 0;
+ });
+ await realCommandRunner.verifyUpstreamConfigured();
+ }, overrides: <Type, Generator>{
+ ProcessManager: () => processManager,
+ });
+ });
+
+ group('matchesGitLine', () {
+ setUpAll(() {
+ Cache.disableLocking();
+ });
+
+ bool _match(String line) => UpgradeCommandRunner.matchesGitLine(line);
+
+ test('regex match', () {
+ expect(_match(' .../flutter_gallery/lib/demo/buttons_demo.dart | 10 +--'), true);
+ expect(_match(' dev/benchmarks/complex_layout/lib/main.dart | 24 +-'), true);
+
+ expect(_match(' rename {packages/flutter/doc => dev/docs}/styles.html (92%)'), true);
+ expect(_match(' delete mode 100644 doc/index.html'), true);
+ expect(_match(' create mode 100644 examples/flutter_gallery/lib/gallery/demo.dart'), true);
+
+ expect(_match('Fast-forward'), true);
+ });
+
+ test('regex doesn\'t match', () {
+ expect(_match('Updating 79cfe1e..5046107'), false);
+ expect(_match('229 files changed, 6179 insertions(+), 3065 deletions(-)'), false);
+ });
+
+ group('findProjectRoot', () {
+ Directory tempDir;
+
+ setUp(() async {
+ tempDir = fs.systemTempDirectory.createTempSync('flutter_tools_upgrade_test.');
+ });
+
+ tearDown(() {
+ tryToDelete(tempDir);
+ });
+
+ testUsingContext('in project', () async {
+ final String projectPath = await createProject(tempDir);
+ expect(findProjectRoot(projectPath), projectPath);
+ expect(findProjectRoot(fs.path.join(projectPath, 'lib')), projectPath);
+
+ final String hello = fs.path.join(Cache.flutterRoot, 'examples', 'hello_world');
+ expect(findProjectRoot(hello), hello);
+ expect(findProjectRoot(fs.path.join(hello, 'lib')), hello);
+ });
+
+ testUsingContext('outside project', () async {
+ final String projectPath = await createProject(tempDir);
+ expect(findProjectRoot(fs.directory(projectPath).parent.path), null);
+ expect(findProjectRoot(Cache.flutterRoot), null);
+ });
+ });
+ });
+}
+
+class FakeUpgradeCommandRunner extends UpgradeCommandRunner {
+ bool willHaveUncomittedChanges = false;
+
+ @override
+ Future<void> verifyUpstreamConfigured() async {}
+
+ @override
+ Future<bool> hasUncomittedChanges() async => willHaveUncomittedChanges;
+
+ @override
+ Future<void> resetChanges(GitTagVersion gitTagVersion) async {}
+
+ @override
+ Future<void> upgradeChannel(FlutterVersion flutterVersion) async {}
+
+ @override
+ Future<void> attemptFastForward() async {}
+
+ @override
+ Future<void> precacheArtifacts() async {}
+
+ @override
+ Future<void> updatePackages(FlutterVersion flutterVersion) async {}
+
+ @override
+ Future<void> runDoctor() async {}
+}
+
+class MockFlutterVersion extends Mock implements FlutterVersion {}
+class MockProcessManager extends Mock implements ProcessManager {}
+class FakeProcessResult implements ProcessResult {
+ @override
+ int exitCode;
+
+ @override
+ int pid = 0;
+
+ @override
+ String stderr = '';
+
+ @override
+ String stdout = '';
+}
diff --git a/packages/flutter_tools/test/general.shard/commands/version_test.dart b/packages/flutter_tools/test/general.shard/commands/version_test.dart
new file mode 100644
index 0000000..1e48004
--- /dev/null
+++ b/packages/flutter_tools/test/general.shard/commands/version_test.dart
@@ -0,0 +1,123 @@
+// Copyright 2019 The Chromium Authors. All rights reserved.
+// 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:convert';
+import 'dart:io';
+
+import 'package:flutter_tools/src/base/io.dart';
+import 'package:flutter_tools/src/cache.dart';
+import 'package:flutter_tools/src/commands/version.dart';
+import 'package:mockito/mockito.dart';
+import 'package:process/process.dart';
+
+import '../../src/common.dart';
+import '../../src/context.dart';
+import '../../src/mocks.dart' show MockProcess;
+
+void main() {
+ group('version', () {
+ setUpAll(() {
+ Cache.disableLocking();
+ });
+
+ testUsingContext('version ls', () async {
+ final VersionCommand command = VersionCommand();
+ await createTestCommandRunner(command).run(<String>['version']);
+ expect(testLogger.statusText, equals('v10.0.0\r\nv20.0.0\n' ''));
+ }, overrides: <Type, Generator>{
+ ProcessManager: () => MockProcessManager(),
+ });
+
+ testUsingContext('version switch', () async {
+ const String version = '10.0.0';
+ final VersionCommand command = VersionCommand();
+ final Future<void> runCommand = createTestCommandRunner(command).run(<String>['version', version]);
+ await Future.wait<void>(<Future<void>>[runCommand]);
+ expect(testLogger.statusText, contains('Switching Flutter to version $version'));
+ }, overrides: <Type, Generator>{
+ ProcessManager: () => MockProcessManager(),
+ });
+
+ testUsingContext('switch to not supported version without force', () async {
+ const String version = '1.1.5';
+ final VersionCommand command = VersionCommand();
+ final Future<void> runCommand = createTestCommandRunner(command).run(<String>['version', version]);
+ await Future.wait<void>(<Future<void>>[runCommand]);
+ expect(testLogger.errorText, contains('Version command is not supported in'));
+ }, overrides: <Type, Generator>{
+ ProcessManager: () => MockProcessManager(),
+ });
+
+ testUsingContext('switch to not supported version with force', () async {
+ const String version = '1.1.5';
+ final VersionCommand command = VersionCommand();
+ final Future<void> runCommand = createTestCommandRunner(command).run(<String>['version', '--force', version]);
+ await Future.wait<void>(<Future<void>>[runCommand]);
+ expect(testLogger.statusText, contains('Switching Flutter to version $version with force'));
+ }, overrides: <Type, Generator>{
+ ProcessManager: () => MockProcessManager(),
+ });
+ });
+}
+
+class MockProcessManager extends Mock implements ProcessManager {
+ String version = '';
+
+ @override
+ Future<ProcessResult> run(
+ List<dynamic> command, {
+ String workingDirectory,
+ Map<String, String> environment,
+ bool includeParentEnvironment = true,
+ bool runInShell = false,
+ Encoding stdoutEncoding = systemEncoding,
+ Encoding stderrEncoding = systemEncoding,
+ }) async {
+ if (command[0] == 'git' && command[1] == 'tag') {
+ return ProcessResult(0, 0, 'v10.0.0\r\nv20.0.0', '');
+ }
+ if (command[0] == 'git' && command[1] == 'checkout') {
+ version = command[2];
+ }
+ return ProcessResult(0, 0, '', '');
+ }
+
+ @override
+ ProcessResult runSync(
+ List<dynamic> command, {
+ String workingDirectory,
+ Map<String, String> environment,
+ bool includeParentEnvironment = true,
+ bool runInShell = false,
+ Encoding stdoutEncoding = systemEncoding,
+ Encoding stderrEncoding = systemEncoding,
+ }) {
+ final String commandStr = command.join(' ');
+ if (commandStr == 'git log -n 1 --pretty=format:%H') {
+ return ProcessResult(0, 0, '000000000000000000000', '');
+ }
+ if (commandStr ==
+ 'git describe --match v*.*.* --first-parent --long --tags') {
+ if (version.isNotEmpty) {
+ return ProcessResult(0, 0, '$version-0-g00000000', '');
+ }
+ }
+ return ProcessResult(0, 0, '', '');
+ }
+
+ @override
+ Future<Process> start(
+ List<dynamic> command, {
+ String workingDirectory,
+ Map<String, String> environment,
+ bool includeParentEnvironment = true,
+ bool runInShell = false,
+ ProcessStartMode mode = ProcessStartMode.normal,
+ }) {
+ final Completer<Process> completer = Completer<Process>();
+ completer.complete(MockProcess());
+ return completer.future;
+ }
+}
