Merge pull request #2204 from yjbanov/driver-ios-emulator

decouple `flutter drive` from `flutter start`; make things in `flutter_tools` more testable

packages/flutter_tools/lib/src/android/android_device.dart

@@ -54,6 +54,8 @@ class AndroidDevice extends Device {
 
   bool _connected;
 
+  bool get isLocalEmulator => false;
+
   List<String> adbCommandForDevice(List<String> args) {
     return <String>[androidSdk.adbPath, '-s', id]..addAll(args);
   }

packages/flutter_tools/lib/src/base/os.dart

@@ -5,7 +5,10 @@
 import 'dart:async';
 import 'dart:io';
 
-final OperatingSystemUtils os = new OperatingSystemUtils._();
+import 'context.dart';
+
+/// Returns [OperatingSystemUtils] active in the current app context (i.e. zone).
+OperatingSystemUtils get os => context[OperatingSystemUtils] ?? (context[OperatingSystemUtils] = new OperatingSystemUtils._());
 
 abstract class OperatingSystemUtils {
   factory OperatingSystemUtils._() {
@@ -16,6 +19,14 @@ abstract class OperatingSystemUtils {
     }
   }
 
+  OperatingSystemUtils._private();
+
+  String get operatingSystem => Platform.operatingSystem;
+
+  bool get isMacOS => operatingSystem == 'macos';
+  bool get isWindows => operatingSystem == 'windows';
+  bool get isLinux => operatingSystem == 'linux';
+
   /// Make the given file executable. This may be a no-op on some platforms.
   ProcessResult makeExecutable(File file);
 
@@ -24,7 +35,9 @@ abstract class OperatingSystemUtils {
   File which(String execName);
 }
 
-class _PosixUtils implements OperatingSystemUtils {
+class _PosixUtils extends OperatingSystemUtils {
+  _PosixUtils() : super._private();
+
   ProcessResult makeExecutable(File file) {
     return Process.runSync('chmod', ['u+x', file.path]);
   }
@@ -40,7 +53,9 @@ class _PosixUtils implements OperatingSystemUtils {
   }
 }
 
-class _WindowsUtils implements OperatingSystemUtils {
+class _WindowsUtils extends OperatingSystemUtils {
+  _WindowsUtils() : super._private();
+
   // This is a no-op.
   ProcessResult makeExecutable(File file) {
     return new ProcessResult(0, 0, null, null);

packages/flutter_tools/lib/src/commands/apk.dart

@@ -420,7 +420,7 @@ Future<int> buildAndroid({
 
 // TODO(mpcomplete): move this to Device?
 /// This is currently Android specific.
-Future buildAll(
+Future<int> buildAll(
   DeviceStore devices,
   ApplicationPackageStore applicationPackages,
   Toolchain toolchain,
@@ -434,31 +434,44 @@ Future buildAll(
       continue;
 
     // TODO(mpcomplete): Temporary hack. We only support the apk builder atm.
-    if (package == applicationPackages.android) {
-      // TODO(devoncarew): Remove this warning after a few releases.
-      if (FileSystemEntity.isDirectorySync('apk') && !FileSystemEntity.isDirectorySync('android')) {
-        // Tell people the android directory location changed.
-        printStatus(
-          "Warning: Flutter now looks for Android resources in the android/ directory; "
-          "consider renaming your 'apk/' directory to 'android/'.");
-      }
-
-      if (!FileSystemEntity.isFileSync(_kDefaultAndroidManifestPath)) {
-        printStatus('Using pre-built SkyShell.apk.');
-        continue;
-      }
-
-      int result = await buildAndroid(
-        toolchain: toolchain,
-        configs: configs,
-        enginePath: enginePath,
-        force: false,
-        target: target
-      );
-      if (result != 0)
-        return result;
+    if (package != applicationPackages.android)
+      continue;
+
+    // TODO(devoncarew): Remove this warning after a few releases.
+    if (FileSystemEntity.isDirectorySync('apk') && !FileSystemEntity.isDirectorySync('android')) {
+      // Tell people the android directory location changed.
+      printStatus(
+        "Warning: Flutter now looks for Android resources in the android/ directory; "
+        "consider renaming your 'apk/' directory to 'android/'.");
     }
+
+    int result = await build(toolchain, configs, enginePath: enginePath,
+        target: target);
+    if (result != 0)
+      return result;
   }
 
   return 0;
 }
+
+Future<int> build(
+  Toolchain toolchain,
+  List<BuildConfiguration> configs, {
+  String enginePath,
+  String target: ''
+}) async {
+  if (!FileSystemEntity.isFileSync(_kDefaultAndroidManifestPath)) {
+    printStatus('Using pre-built SkyShell.apk.');
+    return 0;
+  }
+
+  int result = await buildAndroid(
+    toolchain: toolchain,
+    configs: configs,
+    enginePath: enginePath,
+    force: false,
+    target: target
+  );
+
+  return result;
+}

packages/flutter_tools/lib/src/commands/drive.dart

@@ -7,15 +7,18 @@ import 'dart:async';
 import 'package:path/path.dart' as path;
 import 'package:test/src/executable.dart' as executable;
 
+import '../base/common.dart';
 import '../base/file_system.dart';
+import '../base/os.dart';
+import '../device.dart';
 import '../globals.dart';
+import '../ios/simulators.dart' show SimControl, IOSSimulatorUtils;
+import '../android/android_device.dart' show AndroidDevice;
+import '../application_package.dart';
+import 'apk.dart' as apk;
 import 'run.dart';
 import 'stop.dart';
 
-typedef Future<int> RunAppFunction();
-typedef Future<Null> RunTestsFunction(List<String> testArgs);
-typedef Future<int> StopAppFunction();
-
 /// Runs integration (a.k.a. end-to-end) tests.
 ///
 /// An integration test is a program that runs in a separate process from your
@@ -36,31 +39,8 @@ typedef Future<int> StopAppFunction();
 /// the application is stopped and the command exits. If all these steps are
 /// successful the exit code will be `0`. Otherwise, you will see a non-zero
 /// exit code.
-class DriveCommand extends RunCommand {
-  final String name = 'drive';
-  final String description = 'Runs Flutter Driver tests for the current project.';
-  final List<String> aliases = <String>['driver'];
-
-  RunAppFunction _runApp;
-  RunTestsFunction _runTests;
-  StopAppFunction _stopApp;
-
-  /// Creates a drive command with custom process management functions.
-  ///
-  /// [runAppFn] starts a Flutter application.
-  ///
-  /// [runTestsFn] runs tests.
-  ///
-  /// [stopAppFn] stops the test app after tests are finished.
-  DriveCommand.custom({
-      RunAppFunction runAppFn,
-      RunTestsFunction runTestsFn,
-      StopAppFunction stopAppFn
-  }) {
-    _runApp = runAppFn ?? super.runInProject;
-    _runTests = runTestsFn ?? executable.main;
-    _stopApp = stopAppFn ?? this.stop;
-
+class DriveCommand extends RunCommandBase {
+  DriveCommand() {
     argParser.addFlag(
       'keep-app-running',
       negatable: true,
@@ -79,19 +59,35 @@ class DriveCommand extends RunCommand {
         'already running instance. This will also cause the driver to keep '
         'the application running after tests are done.'
     );
+
+    argParser.addOption('debug-port',
+        defaultsTo: observatoryDefaultPort.toString(),
+        help: 'Listen to the given port for a debug connection.');
   }
 
-  DriveCommand() : this.custom();
+  final String name = 'drive';
+  final String description = 'Runs Flutter Driver tests for the current project.';
+  final List<String> aliases = <String>['driver'];
+
+  Device _device;
+  Device get device => _device;
 
-  bool get requiresDevice => true;
+  int get debugPort => int.parse(argResults['debug-port']);
 
   @override
   Future<int> runInProject() async {
+    await toolchainDownloader(this);
+
     String testFile = _getTestFile();
     if (testFile == null) {
       return 1;
     }
 
+    this._device = await targetDeviceFinder();
+    if (device == null) {
+      return 1;
+    }
+
     if (await fs.type(testFile) != FileSystemEntityType.FILE) {
       printError('Test file not found: $testFile');
       return 1;
@@ -99,17 +95,17 @@ class DriveCommand extends RunCommand {
 
     if (!argResults['use-existing-app']) {
       printStatus('Starting application: ${argResults["target"]}');
-      int result = await _runApp();
+      int result = await appStarter(this);
       if (result != 0) {
         printError('Application failed to start. Will not run test. Quitting.');
         return result;
       }
     } else {
-      printStatus('Will connect to already running application instance');
+      printStatus('Will connect to already running application instance.');
     }
 
     try {
-      return await _runTests([testFile])
+      return await testRunner([testFile])
         .then((_) => 0)
         .catchError((error, stackTrace) {
           printError('CAUGHT EXCEPTION: $error\n$stackTrace');
@@ -117,10 +113,15 @@ class DriveCommand extends RunCommand {
         });
     } finally {
       if (!argResults['keep-app-running'] && !argResults['use-existing-app']) {
-        printStatus('Stopping application instance');
-        await _stopApp();
+        printStatus('Stopping application instance.');
+        try {
+          await appStopper(this);
+        } catch(error, stackTrace) {
+          // TODO(yjbanov): remove this guard when this bug is fixed: https://github.com/dart-lang/sdk/issues/25862
+          printStatus('Could not stop application: $error\n$stackTrace');
+        }
       } else {
-        printStatus('Leaving the application running');
+        printStatus('Leaving the application running.');
       }
     }
   }
@@ -130,7 +131,7 @@ class DriveCommand extends RunCommand {
   }
 
   String _getTestFile() {
-    String appFile = path.normalize(argResults['target']);
+    String appFile = path.normalize(target);
 
     // This command extends `flutter start` and therefore CWD == package dir
     String packageDir = getCurrentDirectory();
@@ -166,3 +167,159 @@ class DriveCommand extends RunCommand {
     return '${pathWithNoExtension}_test${path.extension(appFile)}';
   }
 }
+
+/// Finds a device to test on. May launch a simulator, if necessary.
+typedef Future<Device> TargetDeviceFinder();
+TargetDeviceFinder targetDeviceFinder = findTargetDevice;
+void restoreTargetDeviceFinder() {
+  targetDeviceFinder = findTargetDevice;
+}
+
+Future<Device> findTargetDevice() async {
+  if (deviceManager.hasSpecifiedDeviceId) {
+    return deviceManager.getDeviceById(deviceManager.specifiedDeviceId);
+  }
+
+  List<Device> devices = await deviceManager.getAllConnectedDevices();
+
+  if (os.isMacOS) {
+    // On Mac we look for the iOS Simulator. If available, we use that. Then
+    // we look for an Android device. If there's one, we use that. Otherwise,
+    // we launch a new iOS Simulator.
+    Device reusableDevice = devices.firstWhere(
+      (d) => d.isLocalEmulator,
+      orElse: () {
+        return devices.firstWhere((d) => d is AndroidDevice,
+            orElse: () => null);
+      }
+    );
+
+    if (reusableDevice != null) {
+      printStatus('Found connected ${reusableDevice.isLocalEmulator ? "emulator" : "device"} "${reusableDevice.name}"; will reuse it.');
+      return reusableDevice;
+    }
+
+    // No running emulator found. Attempt to start one.
+    printStatus('Starting iOS Simulator, because did not find existing connected devices.');
+    bool started = await SimControl.instance.boot();
+    if (started) {
+      return IOSSimulatorUtils.instance.getAttachedDevices().first;
+    } else {
+      printError('Failed to start iOS Simulator.');
+      return null;
+    }
+  } else if (os.isLinux) {
+    // On Linux, for now, we just grab the first connected device we can find.
+    if (devices.isEmpty) {
+      printError('No devices found.');
+      return null;
+    } else if (devices.length > 1) {
+      printStatus('Found multiple connected devices:');
+      printStatus(devices.map((d) => '  - ${d.name}\n').join(''));
+    }
+    printStatus('Using device ${devices.first.name}.');
+    return devices.first;
+  } else if (os.isWindows) {
+    printError('Windows is not yet supported.');
+    return null;
+  } else {
+    printError('The operating system on this computer is not supported.');
+    return null;
+  }
+}
+
+/// Starts the application on the device given command configuration.
+typedef Future<int> AppStarter(DriveCommand command);
+AppStarter appStarter = startApp;
+void restoreAppStarter() {
+  appStarter = startApp;
+}
+
+Future<int> startApp(DriveCommand command) async {
+  String mainPath = findMainDartFile(command.target);
+  if (await fs.type(mainPath) != FileSystemEntityType.FILE) {
+    printError('Tried to run $mainPath, but that file does not exist.');
+    return 1;
+  }
+
+  if (command.device is AndroidDevice) {
+    printTrace('Building an APK.');
+    int result = await apk.build(command.toolchain, command.buildConfigurations,
+      enginePath: command.runner.enginePath, target: command.target);
+
+    if (result != 0)
+      return result;
+  }
+
+  printTrace('Stopping previously running application, if any.');
+  await appStopper(command);
+
+  printTrace('Installing application package.');
+  ApplicationPackage package = command.applicationPackages
+      .getPackageForPlatform(command.device.platform);
+  await command.device.installApp(package);
+
+  printTrace('Starting application.');
+  bool started = await command.device.startApp(
+    package,
+    command.toolchain,
+    mainPath: mainPath,
+    route: command.route,
+    checked: command.checked,
+    clearLogs: true,
+    startPaused: true,
+    debugPort: command.debugPort,
+    platformArgs: <String, dynamic>{
+      'trace-startup': command.traceStartup,
+    }
+  );
+
+  if (command.device.supportsStartPaused) {
+    await delayUntilObservatoryAvailable('localhost', command.debugPort);
+  }
+
+  return started ? 0 : 2;
+}
+
+/// Runs driver tests.
+typedef Future<Null> TestRunner(List<String> testArgs);
+TestRunner testRunner = runTests;
+void restoreTestRunner() {
+  testRunner = runTests;
+}
+
+Future<Null> runTests(List<String> testArgs) {
+  printTrace('Running driver tests.');
+  return executable.main(testArgs);
+}
+
+
+/// Stops the application.
+typedef Future<int> AppStopper(DriveCommand command);
+AppStopper appStopper = stopApp;
+void restoreAppStopper() {
+  appStopper = stopApp;
+}
+
+Future<int> stopApp(DriveCommand command) async {
+  printTrace('Stopping application.');
+  ApplicationPackage package = command.applicationPackages
+      .getPackageForPlatform(command.device.platform);
+  bool stopped = await command.device.stopApp(package);
+  return stopped ? 0 : 1;
+}
+
+/// Downloads Flutter toolchain.
+typedef Future<Null> ToolchainDownloader(DriveCommand command);
+ToolchainDownloader toolchainDownloader = downloadToolchain;
+void restoreToolchainDownloader() {
+  toolchainDownloader = downloadToolchain;
+}
+
+Future<Null> downloadToolchain(DriveCommand command) async {
+  printTrace('Downloading toolchain.');
+  await Future.wait([
+    command.downloadToolchain(),
+    command.downloadApplicationPackagesAndConnectToDevices(),
+  ], eagerError: true);
+}

packages/flutter_tools/lib/src/commands/run.dart

@@ -51,6 +51,11 @@ abstract class RunCommandBase extends FlutterCommand {
     argParser.addOption('route',
         help: 'Which route to load when starting the app.');
   }
+
+  bool get checked => argResults['checked'];
+  bool get traceStartup => argResults['trace-startup'];
+  String get target => argResults['target'];
+  String get route => argResults['route'];
 }
 
 class RunCommand extends RunCommandBase {
@@ -219,7 +224,7 @@ Future<int> startApp(
       // wait for the observatory port to become available before returning from
       // `startApp()`.
       if (startPaused && device.supportsStartPaused) {
-        await _delayUntilObservatoryAvailable('localhost', debugPort);
+        await delayUntilObservatoryAvailable('localhost', debugPort);
       }
     }
   }
@@ -242,7 +247,7 @@ Future<int> startApp(
 ///
 /// This does not fail if we're unable to connect, and times out after the given
 /// [timeout].
-Future _delayUntilObservatoryAvailable(String host, int port, {
+Future delayUntilObservatoryAvailable(String host, int port, {
   Duration timeout: const Duration(seconds: 10)
 }) async {
   Stopwatch stopwatch = new Stopwatch()..start();

packages/flutter_tools/lib/src/device.dart

@@ -130,6 +130,9 @@ abstract class Device {
 
   bool get supportsStartPaused => true;
 
+  /// Whether it is an emulated device running on localhost.
+  bool get isLocalEmulator;
+
   /// Install an app package on the current device
   bool installApp(ApplicationPackage app);
 
@@ -259,7 +262,7 @@ class DeviceStore {
           break;
         case TargetPlatform.iOSSimulator:
           assert(iOSSimulator == null);
-          iOSSimulator = _deviceForConfig(config, IOSSimulator.getAttachedDevices());
+          iOSSimulator = _deviceForConfig(config, IOSSimulatorUtils.instance.getAttachedDevices());
           break;
         case TargetPlatform.mac:
         case TargetPlatform.linux:

packages/flutter_tools/lib/src/ios/devices.dart

@@ -62,6 +62,8 @@ class IOSDevice extends Device {
 
   final String name;
 
+  bool get isLocalEmulator => false;
+
   bool get supportsStartPaused => false;
 
   static List<IOSDevice> getAttachedDevices([IOSDevice mockIOS]) {

packages/flutter_tools/lib/src/ios/simulators.dart

@@ -10,6 +10,7 @@ import 'package:path/path.dart' as path;
 
 import '../application_package.dart';
 import '../base/common.dart';
+import '../base/context.dart';
 import '../base/process.dart';
 import '../build_configuration.dart';
 import '../device.dart';
@@ -26,12 +27,29 @@ class IOSSimulators extends PollingDeviceDiscovery {
   IOSSimulators() : super('IOSSimulators');
 
   bool get supportsPlatform => Platform.isMacOS;
-  List<Device> pollingGetDevices() => IOSSimulator.getAttachedDevices();
+  List<Device> pollingGetDevices() => IOSSimulatorUtils.instance.getAttachedDevices();
+}
+
+class IOSSimulatorUtils {
+  /// Returns [IOSSimulatorUtils] active in the current app context (i.e. zone).
+  static IOSSimulatorUtils get instance => context[IOSSimulatorUtils] ?? (context[IOSSimulatorUtils] = new IOSSimulatorUtils());
+
+  List<IOSSimulator> getAttachedDevices() {
+    if (!xcode.isInstalledAndMeetsVersionCheck)
+      return <IOSSimulator>[];
+
+    return SimControl.instance.getConnectedDevices().map((SimDevice device) {
+      return new IOSSimulator(device.udid, name: device.name);
+    }).toList();
+  }
 }
 
 /// A wrapper around the `simctl` command line tool.
 class SimControl {
-  static Future<bool> boot({String deviceId}) async {
+  /// Returns [SimControl] active in the current app context (i.e. zone).
+  static SimControl get instance => context[SimControl] ?? (context[SimControl] = new SimControl());
+
+  Future<bool> boot({String deviceId}) async {
     if (_isAnyConnected())
       return true;
 
@@ -65,7 +83,7 @@ class SimControl {
   }
 
   /// Returns a list of all available devices, both potential and connected.
-  static List<SimDevice> getDevices() {
+  List<SimDevice> getDevices() {
     // {
     //   "devices" : {
     //     "com.apple.CoreSimulator.SimRuntime.iOS-8-2" : [
@@ -102,18 +120,18 @@ class SimControl {
   }
 
   /// Returns all the connected simulator devices.
-  static List<SimDevice> getConnectedDevices() {
+  List<SimDevice> getConnectedDevices() {
     return getDevices().where((SimDevice device) => device.isBooted).toList();
   }
 
-  static StreamController<List<SimDevice>> _trackDevicesControler;
+  StreamController<List<SimDevice>> _trackDevicesControler;
 
   /// Listens to changes in the set of connected devices. The implementation
   /// currently uses polling. Callers should be careful to call cancel() on any
   /// stream subscription when finished.
   ///
   /// TODO(devoncarew): We could investigate using the usbmuxd protocol directly.
-  static Stream<List<SimDevice>> trackDevices() {
+  Stream<List<SimDevice>> trackDevices() {
     if (_trackDevicesControler == null) {
       Timer timer;
       Set<String> deviceIds = new Set<String>();
@@ -138,7 +156,7 @@ class SimControl {
   }
 
   /// Update the cached set of device IDs and return whether there were any changes.
-  static bool _updateDeviceIds(List<SimDevice> devices, Set<String> deviceIds) {
+  bool _updateDeviceIds(List<SimDevice> devices, Set<String> deviceIds) {
     Set<String> newIds = new Set<String>.from(devices.map((SimDevice device) => device.udid));
 
     bool changed = false;
@@ -159,13 +177,13 @@ class SimControl {
     return changed;
   }
 
-  static bool _isAnyConnected() => getConnectedDevices().isNotEmpty;
+  bool _isAnyConnected() => getConnectedDevices().isNotEmpty;
 
-  static void install(String deviceId, String appPath) {
+  void install(String deviceId, String appPath) {
     runCheckedSync([_xcrunPath, 'simctl', 'install', deviceId, appPath]);
   }
 
-  static void launch(String deviceId, String appIdentifier, [List<String> launchArgs]) {
+  void launch(String deviceId, String appIdentifier, [List<String> launchArgs]) {
     List<String> args = [_xcrunPath, 'simctl', 'launch', deviceId, appIdentifier];
     if (launchArgs != null)
       args.addAll(launchArgs);
@@ -190,17 +208,10 @@ class SimDevice {
 class IOSSimulator extends Device {
   IOSSimulator(String id, { this.name }) : super(id);
 
-  static List<IOSSimulator> getAttachedDevices() {
-    if (!xcode.isInstalledAndMeetsVersionCheck)
-      return <IOSSimulator>[];
-
-    return SimControl.getConnectedDevices().map((SimDevice device) {
-      return new IOSSimulator(device.udid, name: device.name);
-    }).toList();
-  }
-
   final String name;
 
+  bool get isLocalEmulator => true;
+
   String get xcrunPath => path.join('/usr', 'bin', 'xcrun');
 
   String _getSimulatorPath() {
@@ -220,7 +231,7 @@ class IOSSimulator extends Device {
       return false;
 
     try {
-      SimControl.install(id, app.localPath);
+      SimControl.instance.install(id, app.localPath);
       return true;
     } catch (e) {
       return false;
@@ -231,7 +242,7 @@ class IOSSimulator extends Device {
   bool isConnected() {
     if (!Platform.isMacOS)
       return false;
-    return SimControl.getConnectedDevices().any((SimDevice device) => device.udid == id);
+    return SimControl.instance.getConnectedDevices().any((SimDevice device) => device.udid == id);
   }
 
   @override
@@ -333,7 +344,7 @@ class IOSSimulator extends Device {
     }
 
     // Step 3: Install the updated bundle to the simulator.
-    SimControl.install(id, path.absolute(bundle.path));
+    SimControl.instance.install(id, path.absolute(bundle.path));
 
     // Step 4: Prepare launch arguments.
     List<String> args = <String>[];
@@ -349,7 +360,7 @@ class IOSSimulator extends Device {
 
     // Step 5: Launch the updated application in the simulator.
     try {
-      SimControl.launch(id, app.id, args);
+      SimControl.instance.launch(id, app.id, args);
     } catch (error) {
       printError('$error');
       return false;

packages/flutter_tools/test/drive_test.dart

@@ -5,10 +5,15 @@
 import 'dart:async';
 
 import 'package:file/file.dart';
-import 'package:flutter_tools/src/commands/drive.dart';
+import 'package:flutter_tools/src/android/android_device.dart';
 import 'package:flutter_tools/src/base/file_system.dart';
 import 'package:flutter_tools/src/base/logger.dart';
+import 'package:flutter_tools/src/base/os.dart';
+import 'package:flutter_tools/src/commands/drive.dart';
+import 'package:flutter_tools/src/device.dart';
 import 'package:flutter_tools/src/globals.dart';
+import 'package:flutter_tools/src/ios/simulators.dart';
+import 'package:mockito/mockito.dart';
 import 'package:test/test.dart';
 
 import 'src/common.dart';
@@ -19,18 +24,45 @@ main() => defineTests();
 
 defineTests() {
   group('drive', () {
+    DriveCommand command;
+    Device mockDevice;
+
+    void withMockDevice([Device mock]) {
+      mockDevice = mock ?? new MockDevice();
+      targetDeviceFinder = () async => mockDevice;
+      testDeviceManager.addDevice(mockDevice);
+    }
+
     setUp(() {
+      command = new DriveCommand();
+      applyMocksToCommand(command);
       useInMemoryFileSystem(cwd: '/some/app');
+      toolchainDownloader = (_) async { };
+      targetDeviceFinder = () {
+        throw 'Unexpected call to targetDeviceFinder';
+      };
+      appStarter = (_) {
+        throw 'Unexpected call to appStarter';
+      };
+      testRunner = (_) {
+        throw 'Unexpected call to testRunner';
+      };
+      appStopper = (_) {
+        throw 'Unexpected call to appStopper';
+      };
     });
 
     tearDown(() {
+      command = null;
       restoreFileSystem();
+      restoreAppStarter();
+      restoreAppStopper();
+      restoreTestRunner();
+      restoreTargetDeviceFinder();
     });
 
     testUsingContext('returns 1 when test file is not found', () {
-      DriveCommand command = new DriveCommand();
-      applyMocksToCommand(command);
-
+      withMockDevice();
       List<String> args = [
         'drive',
         '--target=/some/app/test/e2e.dart',
@@ -44,10 +76,8 @@ defineTests() {
     });
 
     testUsingContext('returns 1 when app fails to run', () async {
-      DriveCommand command = new DriveCommand.custom(runAppFn: expectAsync(() {
-        return new Future.value(1);
-      }));
-      applyMocksToCommand(command);
+      withMockDevice();
+      appStarter = expectAsync((_) async => 1);
 
       String testApp = '/some/app/test_driver/e2e.dart';
       String testFile = '/some/app/test_driver/e2e_test.dart';
@@ -72,8 +102,6 @@ defineTests() {
     testUsingContext('returns 1 when app file is outside package', () async {
       String packageDir = '/my/app';
       useInMemoryFileSystem(cwd: packageDir);
-      DriveCommand command = new DriveCommand();
-      applyMocksToCommand(command);
 
       String appFile = '/not/in/my/app.dart';
       List<String> args = [
@@ -92,8 +120,6 @@ defineTests() {
     testUsingContext('returns 1 when app file is in the root dir', () async {
       String packageDir = '/my/app';
       useInMemoryFileSystem(cwd: packageDir);
-      DriveCommand command = new DriveCommand();
-      applyMocksToCommand(command);
 
       String appFile = '/my/app/main.dart';
       List<String> args = [
@@ -111,22 +137,21 @@ defineTests() {
     });
 
     testUsingContext('returns 0 when test ends successfully', () async {
+      withMockDevice();
+
       String testApp = '/some/app/test/e2e.dart';
       String testFile = '/some/app/test_driver/e2e_test.dart';
 
-      DriveCommand command = new DriveCommand.custom(
-        runAppFn: expectAsync(() {
-          return new Future<int>.value(0);
-        }),
-        runTestsFn: expectAsync((List<String> testArgs) {
-          expect(testArgs, [testFile]);
-          return new Future<Null>.value();
-        }),
-        stopAppFn: expectAsync(() {
-          return new Future<int>.value(0);
-        })
-      );
-      applyMocksToCommand(command);
+      appStarter = expectAsync((_) {
+        return new Future<int>.value(0);
+      });
+      testRunner = expectAsync((List<String> testArgs) {
+        expect(testArgs, [testFile]);
+        return new Future<Null>.value();
+      });
+      appStopper = expectAsync((_) {
+        return new Future<int>.value(0);
+      });
 
       MemoryFileSystem memFs = fs;
       await memFs.file(testApp).writeAsString('main() {}');
@@ -142,5 +167,88 @@ defineTests() {
         expect(buffer.errorText, isEmpty);
       });
     });
+
+
+    group('findTargetDevice', () {
+      testUsingContext('uses specified device', () async {
+        testDeviceManager.specifiedDeviceId = '123';
+        withMockDevice();
+        when(mockDevice.name).thenReturn('specified-device');
+        when(mockDevice.id).thenReturn('123');
+
+        Device device = await findTargetDevice();
+        expect(device.name, 'specified-device');
+      });
+    });
+
+    group('findTargetDevice on iOS', () {
+      setOs() {
+        when(os.isMacOS).thenReturn(true);
+        when(os.isLinux).thenReturn(false);
+      }
+
+      testUsingContext('uses existing emulator', () async {
+        setOs();
+        withMockDevice();
+        when(mockDevice.name).thenReturn('mock-simulator');
+        when(mockDevice.isLocalEmulator).thenReturn(true);
+
+        Device device = await findTargetDevice();
+        expect(device.name, 'mock-simulator');
+      });
+
+      testUsingContext('uses existing Android device if and there are no simulators', () async {
+        setOs();
+        mockDevice = new MockAndroidDevice();
+        when(mockDevice.name).thenReturn('mock-android-device');
+        when(mockDevice.isLocalEmulator).thenReturn(false);
+        withMockDevice(mockDevice);
+
+        Device device = await findTargetDevice();
+        expect(device.name, 'mock-android-device');
+      });
+
+      testUsingContext('launches emulator', () async {
+        setOs();
+        when(SimControl.instance.boot()).thenReturn(true);
+        Device emulator = new MockDevice();
+        when(emulator.name).thenReturn('new-simulator');
+        when(IOSSimulatorUtils.instance.getAttachedDevices())
+            .thenReturn([emulator]);
+
+        Device device = await findTargetDevice();
+        expect(device.name, 'new-simulator');
+      });
+    });
+
+    group('findTargetDevice on Linux', () {
+      setOs() {
+        when(os.isMacOS).thenReturn(false);
+        when(os.isLinux).thenReturn(true);
+      }
+
+      testUsingContext('returns null if no devices found', () async {
+        setOs();
+        expect(await findTargetDevice(), isNull);
+      });
+
+      testUsingContext('uses existing Android device', () async {
+        setOs();
+        mockDevice = new MockAndroidDevice();
+        when(mockDevice.name).thenReturn('mock-android-device');
+        withMockDevice(mockDevice);
+
+        Device device = await findTargetDevice();
+        expect(device.name, 'mock-android-device');
+      });
+    });
   });
 }
+
+class MockDevice extends Mock implements Device {
+  MockDevice() {
+    when(this.isSupported()).thenReturn(true);
+  }
+}
+
+class MockAndroidDevice extends Mock implements AndroidDevice { }

packages/flutter_tools/test/listen_test.dart

@@ -15,7 +15,7 @@ defineTests() {
   group('listen', () {
     testUsingContext('returns 1 when no device is connected', () {
       ListenCommand command = new ListenCommand(singleRun: true);
-      applyMocksToCommand(command, noDevices: true);
+      applyMocksToCommand(command);
       return createTestCommandRunner(command).run(['listen']).then((int code) {
         expect(code, equals(1));
       });

packages/flutter_tools/test/src/context.dart

@@ -7,9 +7,13 @@ import 'dart:io';
 
 import 'package:flutter_tools/src/base/context.dart';
 import 'package:flutter_tools/src/base/logger.dart';
+import 'package:flutter_tools/src/base/os.dart';
 import 'package:flutter_tools/src/device.dart';
 import 'package:flutter_tools/src/doctor.dart';
 import 'package:flutter_tools/src/ios/mac.dart';
+import 'package:flutter_tools/src/ios/simulators.dart';
+
+import 'package:mockito/mockito.dart';
 import 'package:test/test.dart';
 
 /// Return the test logger. This assumes that the current Logger is a BufferLogger.
@@ -38,6 +42,15 @@ void testUsingContext(String description, dynamic testMethod(), {
     if (!overrides.containsKey(Doctor))
       testContext[Doctor] = new MockDoctor();
 
+    if (!overrides.containsKey(SimControl))
+      testContext[SimControl] = new MockSimControl();
+
+    if (!overrides.containsKey(OperatingSystemUtils))
+      testContext[OperatingSystemUtils] = new MockOperatingSystemUtils();
+
+    if (!overrides.containsKey(IOSSimulatorUtils))
+      testContext[IOSSimulatorUtils] = new MockIOSSimulatorUtils();
+
     if (Platform.isMacOS) {
       if (!overrides.containsKey(XCode))
         testContext[XCode] = new XCode();
@@ -76,3 +89,13 @@ class MockDoctor extends Doctor {
   // True for testing.
   bool get canLaunchAnything => true;
 }
+
+class MockSimControl extends Mock implements SimControl {
+  MockSimControl() {
+    when(this.getConnectedDevices()).thenReturn([]);
+  }
+}
+
+class MockOperatingSystemUtils extends Mock implements OperatingSystemUtils {}
+
+class MockIOSSimulatorUtils extends Mock implements IOSSimulatorUtils {}

packages/flutter_tools/test/src/mocks.dart

@@ -12,8 +12,6 @@ import 'package:flutter_tools/src/runner/flutter_command.dart';
 import 'package:flutter_tools/src/toolchain.dart';
 import 'package:mockito/mockito.dart';
 
-import 'context.dart';
-
 class MockApplicationPackageStore extends ApplicationPackageStore {
   MockApplicationPackageStore() : super(
     android: new AndroidApk(localPath: '/mock/path/to/android/SkyShell.apk'),
@@ -53,13 +51,10 @@ class MockDeviceStore extends DeviceStore {
     iOSSimulator: new MockIOSSimulator());
 }
 
-void applyMocksToCommand(FlutterCommand command, { bool noDevices: false }) {
+void applyMocksToCommand(FlutterCommand command) {
   command
     ..applicationPackages = new MockApplicationPackageStore()
     ..toolchain = new MockToolchain()
     ..devices = new MockDeviceStore()
     ..projectRootValidator = () => true;
-
-  if (!noDevices)
-    testDeviceManager.addDevice(command.devices.android);
 }