2019-11-27 23:04:02 +00:00
|
|
|
// Copyright 2014 The Flutter Authors. All rights reserved.
|
2016-03-04 22:36:32 +00:00
|
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
|
|
// found in the LICENSE file.
|
|
|
|
|
2019-11-10 01:08:53 +00:00
|
|
|
import 'dart:async';
|
|
|
|
|
|
|
|
import 'package:file/file.dart';
|
|
|
|
import 'package:file/memory.dart';
|
2019-06-11 18:37:47 +00:00
|
|
|
import 'package:args/command_runner.dart';
|
|
|
|
import 'package:flutter_tools/src/application_package.dart';
|
2019-12-09 23:13:02 +00:00
|
|
|
import 'package:flutter_tools/src/artifacts.dart';
|
2016-11-14 03:09:03 +00:00
|
|
|
import 'package:flutter_tools/src/base/common.dart';
|
2019-11-10 01:08:53 +00:00
|
|
|
import 'package:flutter_tools/src/base/context.dart';
|
2019-12-10 18:26:14 +00:00
|
|
|
import 'package:flutter_tools/src/base/file_system.dart';
|
|
|
|
import 'package:flutter_tools/src/base/logger.dart';
|
2019-12-09 23:13:02 +00:00
|
|
|
import 'package:flutter_tools/src/base/user_messages.dart';
|
2019-12-12 18:43:58 +00:00
|
|
|
import 'package:flutter_tools/src/base/net.dart';
|
2019-04-08 20:49:09 +00:00
|
|
|
import 'package:flutter_tools/src/build_info.dart';
|
2019-06-11 18:37:47 +00:00
|
|
|
import 'package:flutter_tools/src/cache.dart';
|
2016-03-04 22:36:32 +00:00
|
|
|
import 'package:flutter_tools/src/commands/run.dart';
|
2019-04-08 20:49:09 +00:00
|
|
|
import 'package:flutter_tools/src/device.dart';
|
2019-11-10 01:08:53 +00:00
|
|
|
import 'package:flutter_tools/src/features.dart';
|
2019-12-10 18:26:14 +00:00
|
|
|
import 'package:flutter_tools/src/globals.dart';
|
2019-11-10 01:08:53 +00:00
|
|
|
import 'package:flutter_tools/src/project.dart';
|
2019-12-09 23:13:02 +00:00
|
|
|
import 'package:flutter_tools/src/reporting/reporting.dart';
|
2019-11-10 01:08:53 +00:00
|
|
|
import 'package:flutter_tools/src/resident_runner.dart';
|
2019-04-08 20:49:09 +00:00
|
|
|
import 'package:flutter_tools/src/runner/flutter_command.dart';
|
2019-06-11 18:37:47 +00:00
|
|
|
import 'package:flutter_tools/src/version.dart';
|
2019-11-10 01:08:53 +00:00
|
|
|
import 'package:flutter_tools/src/web/web_runner.dart';
|
2019-04-08 20:49:09 +00:00
|
|
|
import 'package:mockito/mockito.dart';
|
2016-03-04 22:36:32 +00:00
|
|
|
|
2019-07-13 18:51:44 +00:00
|
|
|
import '../../src/common.dart';
|
|
|
|
import '../../src/context.dart';
|
|
|
|
import '../../src/mocks.dart';
|
2019-11-10 01:08:53 +00:00
|
|
|
import '../../src/testbed.dart';
|
2016-03-04 22:36:32 +00:00
|
|
|
|
2016-03-10 01:43:14 +00:00
|
|
|
void main() {
|
2019-06-08 02:33:14 +00:00
|
|
|
group('run', () {
|
2019-06-11 18:37:47 +00:00
|
|
|
MockApplicationPackageFactory mockApplicationPackageFactory;
|
|
|
|
MockDeviceManager mockDeviceManager;
|
|
|
|
MockFlutterVersion mockStableFlutterVersion;
|
|
|
|
MockFlutterVersion mockUnstableFlutterVersion;
|
|
|
|
|
|
|
|
setUpAll(() {
|
|
|
|
Cache.disableLocking();
|
|
|
|
mockApplicationPackageFactory = MockApplicationPackageFactory();
|
|
|
|
mockDeviceManager = MockDeviceManager();
|
|
|
|
mockStableFlutterVersion = MockFlutterVersion(isStable: true);
|
|
|
|
mockUnstableFlutterVersion = MockFlutterVersion(isStable: false);
|
|
|
|
});
|
|
|
|
|
2016-11-14 03:09:03 +00:00
|
|
|
testUsingContext('fails when target not found', () async {
|
2018-09-12 06:29:29 +00:00
|
|
|
final RunCommand command = RunCommand();
|
2016-03-04 22:36:32 +00:00
|
|
|
applyMocksToCommand(command);
|
2016-11-14 03:09:03 +00:00
|
|
|
try {
|
2019-10-08 21:53:28 +00:00
|
|
|
await createTestCommandRunner(command).run(<String>['run', '-t', 'abc123', '--no-pub']);
|
2016-11-14 03:09:03 +00:00
|
|
|
fail('Expect exception');
|
|
|
|
} on ToolExit catch (e) {
|
|
|
|
expect(e.exitCode ?? 1, 1);
|
|
|
|
}
|
2016-03-04 22:36:32 +00:00
|
|
|
});
|
2019-04-08 20:49:09 +00:00
|
|
|
|
2019-12-10 18:26:14 +00:00
|
|
|
testUsingContext('does not support "--use-application-binary" and "--fast-start"', () async {
|
|
|
|
fs.file(fs.path.join('lib', 'main.dart')).createSync(recursive: true);
|
|
|
|
fs.file('pubspec.yaml').createSync();
|
|
|
|
fs.file('.packages').createSync();
|
|
|
|
|
|
|
|
final RunCommand command = RunCommand();
|
|
|
|
applyMocksToCommand(command);
|
|
|
|
try {
|
|
|
|
await createTestCommandRunner(command).run(<String>[
|
|
|
|
'run',
|
|
|
|
'--use-application-binary=app/bar/faz',
|
|
|
|
'--fast-start',
|
|
|
|
'--no-pub',
|
|
|
|
'--show-test-device',
|
|
|
|
]);
|
|
|
|
fail('Expect exception');
|
|
|
|
} catch (e) {
|
|
|
|
expect(e.toString(), contains('--fast-start is not supported with --use-application-binary'));
|
|
|
|
}
|
|
|
|
}, overrides: <Type, Generator>{
|
|
|
|
FileSystem: () => MemoryFileSystem(),
|
|
|
|
ProcessManager: () => FakeProcessManager.any(),
|
|
|
|
});
|
|
|
|
|
|
|
|
testUsingContext('Forces fast start off for devices that do not support it', () async {
|
|
|
|
final MockDevice mockDevice = MockDevice(TargetPlatform.android_arm);
|
|
|
|
when(mockDevice.name).thenReturn('mockdevice');
|
|
|
|
when(mockDevice.supportsFastStart).thenReturn(false);
|
|
|
|
when(mockDevice.supportsHotReload).thenReturn(true);
|
|
|
|
when(mockDevice.isLocalEmulator).thenAnswer((Invocation invocation) async => false);
|
|
|
|
when(deviceManager.hasSpecifiedAllDevices).thenReturn(false);
|
|
|
|
when(deviceManager.findTargetDevices(any)).thenAnswer((Invocation invocation) {
|
|
|
|
return Future<List<Device>>.value(<Device>[mockDevice]);
|
|
|
|
});
|
|
|
|
when(deviceManager.getDevices()).thenAnswer((Invocation invocation) {
|
|
|
|
return Stream<Device>.value(mockDevice);
|
|
|
|
});
|
|
|
|
fs.file(fs.path.join('lib', 'main.dart')).createSync(recursive: true);
|
|
|
|
fs.file('pubspec.yaml').createSync();
|
|
|
|
fs.file('.packages').createSync();
|
|
|
|
|
|
|
|
final RunCommand command = RunCommand();
|
|
|
|
applyMocksToCommand(command);
|
|
|
|
try {
|
|
|
|
await createTestCommandRunner(command).run(<String>[
|
|
|
|
'run',
|
|
|
|
'--fast-start',
|
|
|
|
'--no-pub',
|
|
|
|
]);
|
|
|
|
fail('Expect exception');
|
|
|
|
} catch (e) {
|
|
|
|
expect(e, isInstanceOf<ToolExit>());
|
|
|
|
}
|
|
|
|
|
|
|
|
final BufferLogger bufferLogger = logger as BufferLogger;
|
|
|
|
expect(bufferLogger.statusText, contains(
|
|
|
|
'Using --fast-start option with device mockdevice, but this device '
|
|
|
|
'does not support it. Overriding the setting to false.'
|
|
|
|
));
|
|
|
|
}, overrides: <Type, Generator>{
|
|
|
|
FileSystem: () => MemoryFileSystem(),
|
|
|
|
ProcessManager: () => FakeProcessManager.any(),
|
|
|
|
DeviceManager: () => MockDeviceManager(),
|
|
|
|
});
|
|
|
|
|
|
|
|
|
2019-12-09 23:13:02 +00:00
|
|
|
group('run app', () {
|
2019-11-26 17:02:34 +00:00
|
|
|
MemoryFileSystem fs;
|
2019-12-09 23:13:02 +00:00
|
|
|
MockArtifacts mockArtifacts;
|
2019-11-26 17:02:34 +00:00
|
|
|
MockCache mockCache;
|
|
|
|
MockProcessManager mockProcessManager;
|
2019-12-09 23:13:02 +00:00
|
|
|
MockUsage mockUsage;
|
2019-11-26 17:02:34 +00:00
|
|
|
Directory tempDir;
|
|
|
|
|
|
|
|
setUpAll(() {
|
2019-12-09 23:13:02 +00:00
|
|
|
mockArtifacts = MockArtifacts();
|
2019-11-26 17:02:34 +00:00
|
|
|
mockCache = MockCache();
|
2019-12-09 23:13:02 +00:00
|
|
|
mockUsage = MockUsage();
|
2019-11-26 17:02:34 +00:00
|
|
|
fs = MemoryFileSystem();
|
|
|
|
mockProcessManager = MockProcessManager();
|
|
|
|
|
|
|
|
tempDir = fs.systemTempDirectory.createTempSync('flutter_run_test.');
|
|
|
|
fs.currentDirectory = tempDir;
|
|
|
|
|
|
|
|
tempDir.childFile('pubspec.yaml')
|
|
|
|
..writeAsStringSync('name: flutter_app');
|
|
|
|
tempDir.childFile('.packages')
|
|
|
|
..writeAsStringSync('# Generated by pub on 2019-11-25 12:38:01.801784.');
|
|
|
|
final Directory libDir = tempDir.childDirectory('lib');
|
|
|
|
libDir.createSync();
|
|
|
|
final File mainFile = libDir.childFile('main.dart');
|
|
|
|
mainFile.writeAsStringSync('void main() {}');
|
|
|
|
|
|
|
|
when(mockDeviceManager.hasSpecifiedDeviceId).thenReturn(false);
|
|
|
|
when(mockDeviceManager.hasSpecifiedAllDevices).thenReturn(false);
|
|
|
|
});
|
|
|
|
|
2019-12-09 23:13:02 +00:00
|
|
|
testUsingContext('exits with a user message when no supported devices attached', () async {
|
2019-11-26 17:02:34 +00:00
|
|
|
final RunCommand command = RunCommand();
|
|
|
|
applyMocksToCommand(command);
|
|
|
|
|
2019-12-09 23:13:02 +00:00
|
|
|
const List<Device> noDevices = <Device>[];
|
|
|
|
when(mockDeviceManager.getDevices()).thenAnswer(
|
|
|
|
(Invocation invocation) => Stream<Device>.fromIterable(noDevices)
|
|
|
|
);
|
|
|
|
when(mockDeviceManager.findTargetDevices(any)).thenAnswer(
|
|
|
|
(Invocation invocation) => Future<List<Device>>.value(noDevices)
|
|
|
|
);
|
|
|
|
|
|
|
|
try {
|
|
|
|
await createTestCommandRunner(command).run(<String>[
|
|
|
|
'run',
|
|
|
|
'--no-pub',
|
|
|
|
'--no-hot',
|
|
|
|
]);
|
|
|
|
fail('Expect exception');
|
|
|
|
} on ToolExit catch (e) {
|
|
|
|
expect(e.message, null);
|
|
|
|
}
|
|
|
|
|
|
|
|
expect(testLogger.statusText, contains(userMessages.flutterNoSupportedDevices));
|
|
|
|
}, overrides: <Type, Generator>{
|
|
|
|
DeviceManager: () => mockDeviceManager,
|
|
|
|
FileSystem: () => fs,
|
|
|
|
ProcessManager: () => mockProcessManager,
|
|
|
|
});
|
|
|
|
|
|
|
|
testUsingContext('updates cache before checking for devices', () async {
|
|
|
|
final RunCommand command = RunCommand();
|
|
|
|
applyMocksToCommand(command);
|
|
|
|
|
|
|
|
// Called as part of requiredArtifacts()
|
2019-11-26 17:02:34 +00:00
|
|
|
when(mockDeviceManager.getDevices()).thenAnswer(
|
|
|
|
(Invocation invocation) => Stream<Device>.fromIterable(<Device>[])
|
|
|
|
);
|
2019-12-09 23:13:02 +00:00
|
|
|
// No devices are attached, we just want to verify update the cache
|
|
|
|
// BEFORE checking for devices
|
2019-11-26 17:02:34 +00:00
|
|
|
when(mockDeviceManager.findTargetDevices(any)).thenAnswer(
|
|
|
|
(Invocation invocation) => Future<List<Device>>.value(<Device>[])
|
|
|
|
);
|
|
|
|
|
|
|
|
try {
|
|
|
|
await createTestCommandRunner(command).run(<String>[
|
|
|
|
'run',
|
|
|
|
'--no-pub',
|
|
|
|
]);
|
|
|
|
fail('Exception expected');
|
|
|
|
} on ToolExit catch (e) {
|
|
|
|
// We expect a ToolExit because no devices are attached
|
|
|
|
expect(e.message, null);
|
|
|
|
} catch (e) {
|
|
|
|
fail('ToolExit expected');
|
|
|
|
}
|
|
|
|
|
|
|
|
verifyInOrder(<void>[
|
2019-12-09 23:13:02 +00:00
|
|
|
// cache update
|
2019-11-26 17:02:34 +00:00
|
|
|
mockCache.updateAll(<DevelopmentArtifact>{DevelopmentArtifact.universal}),
|
2019-12-09 23:13:02 +00:00
|
|
|
// as part of gathering `requiredArtifacts`
|
|
|
|
mockDeviceManager.getDevices(),
|
|
|
|
// in validateCommand()
|
2019-11-26 17:02:34 +00:00
|
|
|
mockDeviceManager.findTargetDevices(any),
|
|
|
|
]);
|
|
|
|
}, overrides: <Type, Generator>{
|
|
|
|
ApplicationPackageFactory: () => mockApplicationPackageFactory,
|
|
|
|
Cache: () => mockCache,
|
|
|
|
DeviceManager: () => mockDeviceManager,
|
|
|
|
FileSystem: () => fs,
|
|
|
|
ProcessManager: () => mockProcessManager,
|
|
|
|
});
|
2019-12-09 23:13:02 +00:00
|
|
|
|
|
|
|
testUsingContext('passes device target platform to usage', () async {
|
|
|
|
final RunCommand command = RunCommand();
|
|
|
|
applyMocksToCommand(command);
|
|
|
|
final MockDevice mockDevice = MockDevice(TargetPlatform.ios);
|
|
|
|
when(mockDevice.isLocalEmulator).thenAnswer((Invocation invocation) => Future<bool>.value(false));
|
|
|
|
when(mockDevice.getLogReader(app: anyNamed('app'))).thenReturn(MockDeviceLogReader());
|
2019-12-10 18:26:14 +00:00
|
|
|
when(mockDevice.supportsFastStart).thenReturn(true);
|
2019-12-17 22:09:34 +00:00
|
|
|
when(mockDevice.sdkNameAndVersion).thenAnswer((Invocation invocation) => Future<String>.value('iOS 13'));
|
2019-12-09 23:13:02 +00:00
|
|
|
// App fails to start because we're only interested in usage
|
|
|
|
when(mockDevice.startApp(
|
|
|
|
any,
|
|
|
|
mainPath: anyNamed('mainPath'),
|
|
|
|
debuggingOptions: anyNamed('debuggingOptions'),
|
|
|
|
platformArgs: anyNamed('platformArgs'),
|
|
|
|
route: anyNamed('route'),
|
|
|
|
prebuiltApplication: anyNamed('prebuiltApplication'),
|
|
|
|
ipv6: anyNamed('ipv6'),
|
|
|
|
)).thenAnswer((Invocation invocation) => Future<LaunchResult>.value(LaunchResult.failed()));
|
|
|
|
|
|
|
|
when(mockArtifacts.getArtifactPath(
|
|
|
|
Artifact.flutterPatchedSdkPath,
|
|
|
|
platform: anyNamed('platform'),
|
|
|
|
mode: anyNamed('mode'),
|
|
|
|
)).thenReturn('/path/to/sdk');
|
|
|
|
|
|
|
|
when(mockDeviceManager.getDevices()).thenAnswer(
|
|
|
|
(Invocation invocation) => Stream<Device>.fromIterable(<Device>[mockDevice]),
|
|
|
|
);
|
|
|
|
|
|
|
|
when(mockDeviceManager.findTargetDevices(any)).thenAnswer(
|
|
|
|
(Invocation invocation) => Future<List<Device>>.value(<Device>[mockDevice])
|
|
|
|
);
|
|
|
|
|
2019-12-17 22:09:34 +00:00
|
|
|
final Directory tempDir = fs.systemTempDirectory.createTempSync('flutter_run_test.');
|
|
|
|
tempDir.childDirectory('ios').childFile('AppDelegate.swift').createSync(recursive: true);
|
|
|
|
tempDir.childFile('.packages').createSync();
|
|
|
|
tempDir.childDirectory('lib').childFile('main.dart').createSync(recursive: true);
|
|
|
|
tempDir.childFile('pubspec.yaml')
|
|
|
|
..createSync()
|
|
|
|
..writeAsStringSync('# Hello, World');
|
|
|
|
fs.currentDirectory = tempDir;
|
|
|
|
|
2019-12-09 23:13:02 +00:00
|
|
|
try {
|
|
|
|
await createTestCommandRunner(command).run(<String>[
|
|
|
|
'run',
|
|
|
|
'--no-pub',
|
|
|
|
'--no-hot',
|
|
|
|
]);
|
|
|
|
fail('Exception expected');
|
|
|
|
} on ToolExit catch (e) {
|
|
|
|
// We expect a ToolExit because app does not start
|
|
|
|
expect(e.message, null);
|
|
|
|
} catch (e) {
|
|
|
|
fail('ToolExit expected');
|
|
|
|
}
|
|
|
|
final List<dynamic> captures = verify(mockUsage.sendCommand(
|
|
|
|
captureAny,
|
|
|
|
parameters: captureAnyNamed('parameters'),
|
|
|
|
)).captured;
|
|
|
|
expect(captures[0], 'run');
|
|
|
|
final Map<String, String> parameters = captures[1] as Map<String, String>;
|
2019-12-17 22:09:34 +00:00
|
|
|
|
|
|
|
expect(parameters[cdKey(CustomDimensions.commandRunIsEmulator)], 'false');
|
|
|
|
expect(parameters[cdKey(CustomDimensions.commandRunTargetName)], 'ios');
|
|
|
|
expect(parameters[cdKey(CustomDimensions.commandRunProjectHostLanguage)], 'swift');
|
|
|
|
expect(parameters[cdKey(CustomDimensions.commandRunTargetOsVersion)], 'iOS 13');
|
|
|
|
expect(parameters[cdKey(CustomDimensions.commandRunModeName)], 'debug');
|
|
|
|
expect(parameters[cdKey(CustomDimensions.commandRunProjectModule)], 'false');
|
|
|
|
expect(parameters.containsKey(cdKey(CustomDimensions.commandRunAndroidEmbeddingVersion)), false);
|
2019-12-09 23:13:02 +00:00
|
|
|
}, overrides: <Type, Generator>{
|
|
|
|
ApplicationPackageFactory: () => mockApplicationPackageFactory,
|
|
|
|
Artifacts: () => mockArtifacts,
|
|
|
|
Cache: () => mockCache,
|
|
|
|
DeviceManager: () => mockDeviceManager,
|
|
|
|
FileSystem: () => fs,
|
|
|
|
ProcessManager: () => mockProcessManager,
|
|
|
|
Usage: () => mockUsage,
|
|
|
|
});
|
2019-11-26 17:02:34 +00:00
|
|
|
});
|
|
|
|
|
2019-06-11 18:37:47 +00:00
|
|
|
group('dart-flags option', () {
|
|
|
|
setUpAll(() {
|
2019-11-26 17:02:34 +00:00
|
|
|
final FakeDevice fakeDevice = FakeDevice();
|
2019-06-11 18:37:47 +00:00
|
|
|
when(mockDeviceManager.getDevices()).thenAnswer((Invocation invocation) {
|
|
|
|
return Stream<Device>.fromIterable(<Device>[
|
2019-11-26 17:02:34 +00:00
|
|
|
fakeDevice,
|
2019-06-11 18:37:47 +00:00
|
|
|
]);
|
|
|
|
});
|
2019-11-26 17:02:34 +00:00
|
|
|
when(mockDeviceManager.findTargetDevices(any)).thenAnswer(
|
|
|
|
(Invocation invocation) => Future<List<Device>>.value(<Device>[fakeDevice])
|
|
|
|
);
|
2019-06-11 18:37:47 +00:00
|
|
|
});
|
|
|
|
|
|
|
|
RunCommand command;
|
|
|
|
List<String> args;
|
|
|
|
setUp(() {
|
|
|
|
command = TestRunCommand();
|
|
|
|
args = <String> [
|
|
|
|
'run',
|
|
|
|
'--dart-flags', '"--observe"',
|
|
|
|
'--no-hot',
|
2019-10-08 21:53:28 +00:00
|
|
|
'--no-pub',
|
2019-06-11 18:37:47 +00:00
|
|
|
];
|
|
|
|
});
|
|
|
|
|
|
|
|
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,
|
|
|
|
});
|
|
|
|
});
|
|
|
|
|
2019-04-08 20:49:09 +00:00
|
|
|
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,
|
2019-09-17 15:19:33 +00:00
|
|
|
DevelopmentArtifact.androidGenSnapshot,
|
2019-04-08 20:49:09 +00:00
|
|
|
}));
|
|
|
|
|
|
|
|
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,
|
2019-09-17 15:19:33 +00:00
|
|
|
DevelopmentArtifact.androidGenSnapshot,
|
2019-04-08 20:49:09 +00:00
|
|
|
}));
|
|
|
|
|
|
|
|
when(mockDeviceManager.getDevices()).thenAnswer((Invocation invocation) {
|
|
|
|
return Stream<Device>.fromIterable(<Device>[
|
2019-06-04 06:19:42 +00:00
|
|
|
MockDevice(TargetPlatform.web_javascript),
|
2019-04-08 20:49:09 +00:00
|
|
|
]);
|
|
|
|
});
|
|
|
|
|
|
|
|
expect(await RunCommand().requiredArtifacts, unorderedEquals(<DevelopmentArtifact>{
|
|
|
|
DevelopmentArtifact.universal,
|
|
|
|
DevelopmentArtifact.web,
|
|
|
|
}));
|
|
|
|
}, overrides: <Type, Generator>{
|
|
|
|
DeviceManager: () => mockDeviceManager,
|
|
|
|
});
|
2019-11-10 01:08:53 +00:00
|
|
|
|
|
|
|
group('--dart-define option', () {
|
|
|
|
MemoryFileSystem fs;
|
|
|
|
MockProcessManager mockProcessManager;
|
|
|
|
MockWebRunnerFactory mockWebRunnerFactory;
|
|
|
|
|
|
|
|
setUpAll(() {
|
2019-11-26 17:02:34 +00:00
|
|
|
final FakeDevice fakeDevice = FakeDevice().._targetPlatform = TargetPlatform.web_javascript;
|
|
|
|
when(mockDeviceManager.getDevices()).thenAnswer(
|
|
|
|
(Invocation invocation) => Stream<Device>.fromIterable(<Device>[fakeDevice])
|
|
|
|
);
|
|
|
|
when(mockDeviceManager.findTargetDevices(any)).thenAnswer(
|
|
|
|
(Invocation invocation) => Future<List<Device>>.value(<Device>[fakeDevice])
|
|
|
|
);
|
2019-11-10 01:08:53 +00:00
|
|
|
});
|
|
|
|
|
|
|
|
RunCommand command;
|
|
|
|
List<String> args;
|
|
|
|
setUp(() {
|
|
|
|
command = TestRunCommand();
|
|
|
|
args = <String> [
|
|
|
|
'run',
|
|
|
|
'--dart-define=FOO=bar',
|
|
|
|
'--no-hot',
|
|
|
|
'--no-pub',
|
|
|
|
];
|
|
|
|
applyMocksToCommand(command);
|
|
|
|
fs = MemoryFileSystem();
|
|
|
|
mockProcessManager = MockProcessManager();
|
|
|
|
mockWebRunnerFactory = MockWebRunnerFactory();
|
|
|
|
});
|
|
|
|
|
|
|
|
testUsingContext('populates the environment', () async {
|
|
|
|
final Directory tempDir = fs.systemTempDirectory.createTempSync('flutter_run_test.');
|
|
|
|
fs.currentDirectory = tempDir;
|
|
|
|
|
|
|
|
final Directory libDir = tempDir.childDirectory('lib');
|
|
|
|
libDir.createSync();
|
|
|
|
final File mainFile = libDir.childFile('main.dart');
|
|
|
|
mainFile.writeAsStringSync('void main() {}');
|
|
|
|
|
|
|
|
final Directory webDir = tempDir.childDirectory('web');
|
|
|
|
webDir.createSync();
|
|
|
|
final File indexFile = libDir.childFile('index.html');
|
|
|
|
indexFile.writeAsStringSync('<h1>Hello</h1>');
|
|
|
|
|
|
|
|
await createTestCommandRunner(command).run(args);
|
|
|
|
expect(mockWebRunnerFactory._dartDefines, <String>['FOO=bar']);
|
|
|
|
}, overrides: <Type, Generator>{
|
|
|
|
FeatureFlags: () => TestFeatureFlags(
|
|
|
|
isWebEnabled: true,
|
|
|
|
),
|
|
|
|
FileSystem: () => fs,
|
|
|
|
ProcessManager: () => mockProcessManager,
|
|
|
|
DeviceManager: () => mockDeviceManager,
|
|
|
|
FlutterVersion: () => mockStableFlutterVersion,
|
|
|
|
WebRunnerFactory: () => mockWebRunnerFactory,
|
|
|
|
});
|
2019-11-22 16:57:14 +00:00
|
|
|
|
|
|
|
testUsingContext('populates dartDefines in --machine mode', () async {
|
|
|
|
final Directory tempDir = fs.systemTempDirectory.createTempSync('flutter_run_test.');
|
|
|
|
fs.currentDirectory = tempDir;
|
|
|
|
|
|
|
|
final Directory libDir = tempDir.childDirectory('lib');
|
|
|
|
libDir.createSync();
|
|
|
|
final File mainFile = libDir.childFile('main.dart');
|
|
|
|
mainFile.writeAsStringSync('void main() {}');
|
|
|
|
|
|
|
|
final Directory webDir = tempDir.childDirectory('web');
|
|
|
|
webDir.createSync();
|
|
|
|
final File indexFile = libDir.childFile('index.html');
|
|
|
|
indexFile.writeAsStringSync('<h1>Hello</h1>');
|
|
|
|
|
|
|
|
when(mockDeviceManager.deviceDiscoverers).thenReturn(<DeviceDiscovery>[]);
|
|
|
|
|
|
|
|
args.add('--machine');
|
|
|
|
await createTestCommandRunner(command).run(args);
|
|
|
|
expect(mockWebRunnerFactory._dartDefines, <String>['FOO=bar']);
|
|
|
|
}, overrides: <Type, Generator>{
|
|
|
|
DeviceManager: () => mockDeviceManager,
|
|
|
|
FeatureFlags: () => TestFeatureFlags(
|
|
|
|
isWebEnabled: true,
|
|
|
|
),
|
|
|
|
FileSystem: () => fs,
|
|
|
|
ProcessManager: () => mockProcessManager,
|
|
|
|
DeviceManager: () => mockDeviceManager,
|
|
|
|
FlutterVersion: () => mockStableFlutterVersion,
|
|
|
|
WebRunnerFactory: () => mockWebRunnerFactory,
|
|
|
|
});
|
2019-11-10 01:08:53 +00:00
|
|
|
});
|
2016-03-04 22:36:32 +00:00
|
|
|
});
|
|
|
|
}
|
2019-04-08 20:49:09 +00:00
|
|
|
|
2019-12-09 23:13:02 +00:00
|
|
|
class MockArtifacts extends Mock implements Artifacts {}
|
2019-11-26 17:02:34 +00:00
|
|
|
class MockCache extends Mock implements Cache {}
|
2019-12-09 23:13:02 +00:00
|
|
|
class MockUsage extends Mock implements Usage {}
|
2019-11-26 17:02:34 +00:00
|
|
|
|
2019-04-08 20:49:09 +00:00
|
|
|
class MockDeviceManager extends Mock implements DeviceManager {}
|
|
|
|
class MockDevice extends Mock implements Device {
|
|
|
|
MockDevice(this._targetPlatform);
|
|
|
|
|
|
|
|
final TargetPlatform _targetPlatform;
|
|
|
|
|
|
|
|
@override
|
2019-12-09 23:13:02 +00:00
|
|
|
Future<TargetPlatform> get targetPlatform async => Future<TargetPlatform>.value(_targetPlatform);
|
2019-04-29 23:02:42 +00:00
|
|
|
}
|
2019-06-11 18:37:47 +00:00
|
|
|
|
|
|
|
class TestRunCommand extends RunCommand {
|
|
|
|
@override
|
|
|
|
// ignore: must_call_super
|
|
|
|
Future<void> validateCommand() async {
|
|
|
|
devices = await deviceManager.getDevices().toList();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
class MockStableFlutterVersion extends MockFlutterVersion {
|
|
|
|
@override
|
2019-06-28 02:04:02 +00:00
|
|
|
bool get isMaster => false;
|
2019-06-11 18:37:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
class FakeDevice extends Fake implements Device {
|
|
|
|
static const int kSuccess = 1;
|
|
|
|
static const int kFailure = -1;
|
2019-11-10 01:08:53 +00:00
|
|
|
TargetPlatform _targetPlatform = TargetPlatform.ios;
|
2019-06-11 18:37:47 +00:00
|
|
|
|
2019-11-22 16:57:14 +00:00
|
|
|
@override
|
|
|
|
String get id => 'fake_device';
|
|
|
|
|
2019-06-11 18:37:47 +00:00
|
|
|
void _throwToolExit(int code) => throwToolExit(null, exitCode: code);
|
|
|
|
|
|
|
|
@override
|
|
|
|
Future<bool> get isLocalEmulator => Future<bool>.value(false);
|
|
|
|
|
|
|
|
@override
|
|
|
|
bool get supportsHotReload => false;
|
|
|
|
|
2019-12-10 18:26:14 +00:00
|
|
|
@override
|
|
|
|
bool get supportsFastStart => false;
|
|
|
|
|
2019-06-11 18:37:47 +00:00
|
|
|
@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;
|
|
|
|
|
2019-10-30 21:11:18 +00:00
|
|
|
@override
|
|
|
|
final PlatformType platformType = PlatformType.ios;
|
|
|
|
|
2019-06-11 18:37:47 +00:00
|
|
|
@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;
|
|
|
|
}
|
|
|
|
}
|
2019-11-10 01:08:53 +00:00
|
|
|
|
|
|
|
class MockWebRunnerFactory extends Mock implements WebRunnerFactory {
|
|
|
|
List<String> _dartDefines;
|
|
|
|
|
|
|
|
@override
|
|
|
|
ResidentRunner createWebRunner(
|
|
|
|
FlutterDevice device, {
|
|
|
|
String target,
|
|
|
|
bool stayResident,
|
|
|
|
FlutterProject flutterProject,
|
|
|
|
bool ipv6,
|
|
|
|
DebuggingOptions debuggingOptions,
|
|
|
|
List<String> dartDefines,
|
2019-12-12 18:43:58 +00:00
|
|
|
UrlTunneller urlTunneller,
|
2019-11-10 01:08:53 +00:00
|
|
|
}) {
|
|
|
|
_dartDefines = dartDefines;
|
|
|
|
return MockWebRunner();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
class MockWebRunner extends Mock implements ResidentRunner {
|
2019-11-22 16:57:14 +00:00
|
|
|
@override
|
|
|
|
bool get debuggingEnabled => false;
|
|
|
|
|
2019-11-10 01:08:53 +00:00
|
|
|
@override
|
|
|
|
Future<int> run({
|
|
|
|
Completer<DebugConnectionInfo> connectionInfoCompleter,
|
|
|
|
Completer<void> appStartedCompleter,
|
|
|
|
String route,
|
|
|
|
}) async {
|
|
|
|
return 0;
|
|
|
|
}
|
2019-11-22 16:57:14 +00:00
|
|
|
|
|
|
|
@override
|
|
|
|
Future<int> waitForAppToFinish() async => 0;
|
2019-11-10 01:08:53 +00:00
|
|
|
}
|