Load web tests using the plugin infrastructure.

lib/src/runner/browser/platform.dart

-// Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
+// Copyright (c) 2016, 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.
 
 import 'dart:async';
 import 'dart:convert';
 import 'dart:io';
 
 import 'package:async/async.dart';
 import 'package:http_multi_server/http_multi_server.dart';
 import 'package:path/path.dart' as p;
 import 'package:pool/pool.dart';
 import 'package:shelf/shelf.dart' as shelf;
 import 'package:shelf/shelf_io.dart' as shelf_io;
 import 'package:shelf_static/shelf_static.dart';
 import 'package:shelf_web_socket/shelf_web_socket.dart';
+import 'package:stream_channel/stream_channel.dart';
 
 import '../../backend/metadata.dart';
-import '../../backend/suite.dart';
 import '../../backend/test_platform.dart';
 import '../../util/io.dart';
 import '../../util/one_off_handler.dart';
 import '../../util/path_handler.dart';
 import '../../util/stack_trace_mapper.dart';
 import '../../utils.dart';
 import '../configuration.dart';
 import '../load_exception.dart';
+import '../plugin/platform.dart';
+import '../runner_suite.dart';
 import 'browser_manager.dart';
 import 'compiler_pool.dart';
 import 'polymer.dart';
 
-/// A server that serves JS-compiled tests to browsers.
-///
-/// A test suite may be loaded for a given file using [loadSuite].
-class BrowserServer {
+class BrowserPlatform extends PlatformPlugin {
   /// Starts the server.
   ///
   /// [root] is the root directory that the server should serve. It defaults to
   /// the working directory.
-  static Future<BrowserServer> start(Configuration config, {String root})
+  static Future<BrowserPlatform> start(Configuration config, {String root})
       async {
     var server = new shelf_io.IOServer(await HttpMultiServer.loopback(0));
-    return new BrowserServer(server, config, root: root);
+    return new BrowserPlatform._(server, config, root: root);
   }
 
   /// The underlying server.
   final shelf.Server _server;
 
   /// A randomly-generated secret.
   ///
   /// This is used to ensure that other users on the same system can't snoop
   /// on data being served through this server.
   final _secret = randomBase64(24, urlSafe: true);
@@ skipping 30 matching lines @@
   /// Pub itself ensures that only one compilation runs at a time; we just use
   /// this pool to make sure that the output is nice and linear.
   final _pubServePool = new Pool(1);
 
   /// The HTTP client to use when caching JS files in `pub serve`.
   final HttpClient _http;
 
   /// Whether [close] has been called.
   bool get _closed => _closeMemo.hasRun;
 
-  /// The memoizer for running [close] exactly once.
-  final _closeMemo = new AsyncMemoizer();
-
   /// A map from browser identifiers to futures that will complete to the
   /// [BrowserManager]s for those browsers, or the errors that occurred when
   /// trying to load those managers.
   ///
   /// This should only be accessed through [_browserManagerFor].
   final _browserManagers =
       new Map<TestPlatform, Future<Result<BrowserManager>>>();
 
   /// A map from test suite paths to Futures that will complete once those
   /// suites are finished compiling.
   ///
   /// This is used to make sure that a given test suite is only compiled once
   /// per run, rather than once per browser per run.
   final _compileFutures = new Map<String, Future>();
 
+  /// Mappers for Dartifying stack traces, indexed by test path.
   final _mappers = new Map<String, StackTraceMapper>();
 
-  BrowserServer(this._server, Configuration config, {String root})
+  BrowserPlatform._(this._server, Configuration config, {String root})
       : _root = root == null ? p.current : root,
         _config = config,
         _compiledDir = config.pubServeUrl == null ? createTempDir() : null,
         _http = config.pubServeUrl == null ? null : new HttpClient(),
         _compilers = new CompilerPool(color: config.color) {
     var cascade = new shelf.Cascade()
         .add(_webSocketHandler.handler);
 
     if (_config.pubServeUrl == null) {
       cascade = cascade
@@ skipping 29 matching lines @@
 
       return new shelf.Response.notFound("Not found.");
     };
   }
 
   /// A handler that serves wrapper files used to bootstrap tests.
   shelf.Response _wrapperHandler(shelf.Request request) {
     var path = p.fromUri(request.url);
 
     if (path.endsWith(".browser_test.dart")) {
+      var testPath = p.basename(p.withoutExtension(p.withoutExtension(path)));
       return new shelf.Response.ok('''
-import "package:test/src/runner/browser/iframe_listener.dart";
+        import "package:stream_channel/stream_channel.dart";
 
-import "${p.basename(p.withoutExtension(p.withoutExtension(path)))}" as test;
+        import "package:test/src/runner/plugin/remote_platform_helpers.dart";
+        import "package:test/src/runner/browser/post_message_channel.dart";
 
-void main() {
-  IframeListener.start(() => test.main);
-}
-''', headers: {'Content-Type': 'application/dart'});
+        import "$testPath" as test;
+
+        void main() {
+          var channel = serializeSuite(() => test.main, hidePrints: false);
+          postMessageChannel().pipe(channel);
+        }
+      ''', headers: {'Content-Type': 'application/dart'});
     }
 
     if (path.endsWith(".html")) {
       var test = p.withoutExtension(path) + ".dart";
 
       // Link to the Dart wrapper on Dartium and the compiled JS version
       // elsewhere.
       var scriptBase =
           "${HTML_ESCAPE.convert(p.basename(test))}.browser_test.dart";
       var script = request.headers['user-agent'].contains('(Dart)')
           ? 'type="application/dart" src="$scriptBase"'
           : 'src="$scriptBase.js"';
 
       return new shelf.Response.ok('''
-<!DOCTYPE html>
-<html>
-<head>
-  <title>${HTML_ESCAPE.convert(test)} Test</title>
-  <script $script></script>
-</head>
-</html>
-''', headers: {'Content-Type': 'text/html'});
+        <!DOCTYPE html>
+        <html>
+        <head>
+          <title>${HTML_ESCAPE.convert(test)} Test</title>
+          <script $script></script>
+        </head>
+        </html>
+      ''', headers: {'Content-Type': 'text/html'});
     }
 
     return new shelf.Response.notFound('Not found.');
   }
 
   /// Loads the test suite at [path] on the browser [browser].
   ///
   /// This will start a browser to load the suite if one isn't already running.
   /// Throws an [ArgumentError] if [browser] isn't a browser platform.
-  Future<Suite> loadSuite(String path, TestPlatform browser,
+  Future<RunnerSuite> load(String path, TestPlatform browser,
       Metadata metadata) async {
     if (!browser.isBrowser) {
       throw new ArgumentError("$browser is not a browser.");
     }
 
     var htmlPath = p.withoutExtension(path) + '.html';
     if (new File(htmlPath).existsSync() &&
         !new File(htmlPath).readAsStringSync()
             .contains('packages/test/dart.js')) {
       throw new LoadException(
@@ skipping 29 matching lines @@
       suiteUrl = url.resolveUri(p.toUri(
           p.withoutExtension(p.relative(path, from: _root)) + ".html"));
     }
 
     if (_closed) return null;
 
     // TODO(nweiz): Don't start the browser until all the suites are compiled.
     var browserManager = await _browserManagerFor(browser);
     if (_closed) return null;
 
-    var suite = await browserManager.loadSuite(path, suiteUrl, metadata,
+    var suite = await browserManager.load(path, suiteUrl, metadata,
         mapper: browser.isJS ? _mappers[path] : null);
     if (_closed) return null;
     return suite;
   }
 
+  StreamChannel loadChannel(String path, TestPlatform platform) =>
+      throw new UnimplementedError();
+
   /// Loads a test suite at [path] from the `pub serve` URL [dartUrl].
   ///
   /// This ensures that only one suite is loaded at a time, and that any errors
   /// are exposed as [LoadException]s.
   Future _pubServeSuite(String path, Uri dartUrl, TestPlatform browser) {
     return _pubServePool.withResource(() async {
       var timer = new Timer(new Duration(seconds: 1), () {
         print('"pub serve" is compiling $path...');
       });
 
@@ skipping 112 matching lines @@
     // an explicit [Result] fixes that.
     _browserManagers[platform] = Result.capture(future);
 
     return future;
   }
 
   /// Close all the browsers that the server currently has open.
   ///
   /// Note that this doesn't close the server itself. Browser tests can still be
   /// loaded, they'll just spawn new browsers.
-  Future closeBrowsers() {
+  Future closeEphemeral() {
     var managers = _browserManagers.values.toList();
     _browserManagers.clear();
     return Future.wait(managers.map((manager) async {
       var result = await manager;
       if (result.isError) return;
       await result.asValue.value.close();
     }));
   }
 
   /// Closes the server and releases all its resources.
   ///
   /// Returns a [Future] that completes once the server is closed and its
   /// resources have been fully released.
-  Future close() {
-    return _closeMemo.runOnce(() async {
-      var futures = _browserManagers.values.map((future) async {
-        var result = await future;
-        if (result.isError) return;
+  Future close() => _closeMemo.runOnce(() async {
+    var futures = _browserManagers.values.map((future) async {
+      var result = await future;
+      if (result.isError) return;
 
-        await result.asValue.value.close();
-      }).toList();
+      await result.asValue.value.close();
+    }).toList();
 
-      futures.add(_server.close());
-      futures.add(_compilers.close());
+    futures.add(_server.close());
+    futures.add(_compilers.close());
 
-      await Future.wait(futures);
+    await Future.wait(futures);
 
-      if (_config.pubServeUrl == null) {
-        new Directory(_compiledDir).deleteSync(recursive: true);
-      } else {
-        _http.close();
-      }
-    });
-  }
+    if (_config.pubServeUrl == null) {
+      new Directory(_compiledDir).deleteSync(recursive: true);
+    } else {
+      _http.close();
+    }
+  });
+  final _closeMemo = new AsyncMemoizer();
 }