Add support for --pub-serve.

lib/src/runner/loader.dart

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library test.runner.loader;
 
 import 'dart:async';
 import 'dart:io';
 import 'dart:isolate';
 
 import 'package:analyzer/analyzer.dart';
 import 'package:path/path.dart' as p;
 
 import '../backend/metadata.dart';
 import '../backend/suite.dart';
 import '../backend/test_platform.dart';
 import '../util/dart.dart';
 import '../util/io.dart';
+import '../util/isolate_wrapper.dart';
 import '../util/remote_exception.dart';
 import '../utils.dart';
 import 'browser/server.dart';
 import 'load_exception.dart';
 import 'parse_metadata.dart';
 import 'vm/isolate_test.dart';
 
 /// A class for finding test files and loading them into a runnable form.
 class Loader {
   /// All platforms for which tests should be loaded.
   final List<TestPlatform> _platforms;
 
   /// Whether to enable colors for Dart compilation.
   final bool _color;
 
   /// The package root to use for loading tests, or `null` to use the automatic
   /// root.
   final String _packageRoot;
 
+  /// The URL for the `pub serve` instance to use to load tests.
+  ///
+  /// This is `null` if tests should be loaded from the filesystem.
+  final Uri _pubServeUrl;
+
   /// All isolates that have been spun up by the loader.
   final _isolates = new Set<Isolate>();
 
   /// The server that serves browser test pages.
   ///
   /// This is lazily initialized the first time it's accessed.
   Future<BrowserServer> get _browserServer {
     if (_browserServerCompleter == null) {
       _browserServerCompleter = new Completer();
-      BrowserServer.start(packageRoot: _packageRoot, color: _color)
+      BrowserServer.start(
+              packageRoot: _packageRoot,
+              pubServeUrl: _pubServeUrl,
+              color: _color)
           .then(_browserServerCompleter.complete)
           .catchError(_browserServerCompleter.completeError);
     }
     return _browserServerCompleter.future;
   }
   Completer<BrowserServer> _browserServerCompleter;
 
   /// Creates a new loader.
   ///
   /// If [packageRoot] is passed, it's used as the package root for all loaded
   /// tests. Otherwise, the `packages/` directories next to the test entrypoints
   /// will be used.
   ///
+  /// If [pubServeUrl] is passed, tests will be loaded from the `pub serve`
+  /// instance at that URL rather than from the filesystem.
+  ///
   /// If [color] is true, console colors will be used when compiling Dart.
   Loader(Iterable<TestPlatform> platforms, {String packageRoot,
-        bool color: false})
+        Uri pubServeUrl, bool color: false})
       : _platforms = platforms.toList(),
+        _pubServeUrl = pubServeUrl,
         _packageRoot = packageRoot,
         _color = color;
 
   /// Loads all test suites in [dir].
   ///
   /// This will load tests from files that end in "_test.dart".
   Future<List<Suite>> loadDir(String dir) {
     return Future.wait(new Directory(dir).listSync(recursive: true)
         .map((entry) {
       if (entry is! File) return new Future.value([]);
@@ skipping 18 matching lines @@
       // the VM's or dart2js's.
       metadata = new Metadata();
     } on FormatException catch (error) {
       throw new LoadException(path, error);
     }
 
     return Future.wait(_platforms.map((platform) {
       return new Future.sync(() {
         if (!metadata.testOn.evaluate(platform, os: currentOS)) return null;
 
+        if (_pubServeUrl != null && !p.isWithin('test', path)) {
+          throw new LoadException(path,
+              'When using "pub serve", all test files must be in test/.');
+        }
+
         if (platform == TestPlatform.chrome) return _loadBrowserFile(path);
         assert(platform == TestPlatform.vm);
         return _loadVmFile(path);
       }).then((suite) {
         if (suite == null) return null;
         return suite.change(metadata: metadata).filter(platform, os: currentOS);
       });
     })).then((suites) => suites.where((suite) => suite != null).toList());
   }
 
   /// Load the test suite at [path] in a browser.
   Future<Suite> _loadBrowserFile(String path) =>
       _browserServer.then((browserServer) => browserServer.loadSuite(path));
 
   /// Load the test suite at [path] in VM isolate.
   Future<Suite> _loadVmFile(String path) {
     var packageRoot = packageRootFor(path, _packageRoot);
     var receivePort = new ReceivePort();
-    return runInIsolate('''
+
+    return new Future.sync(() {
+      if (_pubServeUrl != null) {
+        var url = _pubServeUrl.resolve(
+            p.withoutExtension(p.relative(path, from: 'test')) +
+                '.vm_test.dart');
+        return Isolate.spawnUri(url, [], {'reply': receivePort.sendPort})
+            .then((isolate) => new IsolateWrapper(isolate, () {}))
+            .catchError((error, stackTrace) {
+          if (error is! IsolateSpawnException) throw error;
+
+          if (error.message.contains("OS Error: Connection refused")) {
+            throw new LoadException(path,
+                "Error getting $url: Connection refused\n"
+                'Make sure "pub serve" is running.');
+          } else if (error.message.contains("404 Not Found")) {
+            throw new LoadException(path,
+                "Error getting $url: 404 Not Found\n"
+                'Make sure "pub serve" is serving the test/ directory.');
+          }
+
+          throw new LoadException(path, error);
+        });
+      } else {
+        return runInIsolate('''
 import "package:test/src/runner/vm/isolate_listener.dart";
 
 import "${p.toUri(p.absolute(path))}" as test;
 
 void main(_, Map message) {
   var sendPort = message['reply'];
   IsolateListener.start(sendPort, () => test.main);
 }
 ''', {
-      'reply': receivePort.sendPort
-    }, packageRoot: packageRoot)
-        .catchError((error, stackTrace) {
+          'reply': receivePort.sendPort
+        }, packageRoot: packageRoot);
+      }
+    }).catchError((error, stackTrace) {
       receivePort.close();
+      if (error is LoadException) throw error;
       return new Future.error(new LoadException(path, error), stackTrace);
     }).then((isolate) {
       _isolates.add(isolate);
       return receivePort.first;
     }).then((response) {
       if (response["type"] == "loadException") {
         return new Future.error(new LoadException(path, response["message"]));
       } else if (response["type"] == "error") {
         var asyncError = RemoteException.deserialize(response["error"]);
         return new Future.error(
@@ skipping 12 matching lines @@
   Future close() {
     for (var isolate in _isolates) {
       isolate.kill();
     }
     _isolates.clear();
 
     if (_browserServerCompleter == null) return new Future.value();
     return _browserServer.then((browserServer) => browserServer.close());
   }
 }