Pass Configuration to Loader and Server.

lib/src/runner/browser/server.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.browser.server;
 
 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 '../../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 '../application_exception.dart';
+import '../configuration.dart';
 import '../load_exception.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 {
   /// Starts the server.
   ///
   /// [root] is the root directory that the server should serve. It defaults to
   /// the working directory.
-  ///
-  /// If [packageRoot] is passed, it's used for all package imports when
-  /// compiling tests to JS. Otherwise, the package root is inferred from
-  /// [root].
-  ///
-  /// 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.
-  ///
-  /// If [jsTrace] is true, raw JavaScript stack traces will be used for tests
-  /// that are compiled to JavaScript.
-  ///
-  /// If the package root doesn't exist, throws an [ApplicationException].
-  static Future<BrowserServer> start({String root, String packageRoot,
-      Uri pubServeUrl, bool color: false, bool jsTrace: false}) async {
-    var server = new BrowserServer._(
-        root, packageRoot, pubServeUrl, color, jsTrace);
+  static Future<BrowserServer> start(Configuration config, {String root})
+      async {
+    var server = new BrowserServer._(root, config);
     await server._load();
     return server;
   }
 
   /// The underlying HTTP server.
   HttpServer _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);
 
   /// The URL for this server.
   Uri get url => baseUrlForAddress(_server.address, _server.port)
       .resolve(_secret + "/");
 
+  /// The test runner configuration.
+  Configuration _config;
+
   /// A [OneOffHandler] for servicing WebSocket connections for
   /// [BrowserManager]s.
   ///
   /// This is one-off because each [BrowserManager] can only connect to a single
   /// WebSocket,
   final _webSocketHandler = new OneOffHandler();
 
   /// A [PathHandler] used to serve compiled JS.
   final _jsHandler = new PathHandler();
 
   /// The [CompilerPool] managing active instances of `dart2js`.
   ///
   /// This is `null` if tests are loaded from `pub serve`.
   final CompilerPool _compilers;
 
   /// The temporary directory in which compiled JS is emitted.
   final String _compiledDir;
 
   /// The root directory served statically by this server.
   final String _root;
 
-  /// The package root.
-  final String _packageRoot;
-
-  final bool _jsTrace;
-
-  /// The URL for the `pub serve` instance to use to load tests.
-  ///
-  /// This is `null` if tests should be compiled manually.
-  final Uri _pubServeUrl;
-
   /// The pool of active `pub serve` compilations.
   ///
   /// 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.
@@ skipping 12 matching lines @@
 
   /// 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>();
 
   final _mappers = new Map<String, StackTraceMapper>();
 
-  BrowserServer._(String root, String packageRoot, Uri pubServeUrl, bool color,
-          this._jsTrace)
+  BrowserServer._(String root, Configuration config)
       : _root = root == null ? p.current : root,
-        _packageRoot = packageRootFor(root, packageRoot),
-        _pubServeUrl = pubServeUrl,
-        _compiledDir = pubServeUrl == null ? createTempDir() : null,
-        _http = pubServeUrl == null ? null : new HttpClient(),
-        _compilers = new CompilerPool(color: color);
+        _config = config,
+        _compiledDir = config.pubServeUrl == null ? createTempDir() : null,
+        _http = config.pubServeUrl == null ? null : new HttpClient(),
+        _compilers = new CompilerPool(color: config.color);
 
   /// Starts the underlying server.
   Future _load() async {
     var cascade = new shelf.Cascade()
         .add(_webSocketHandler.handler);
 
-    if (_pubServeUrl == null) {
+    if (_config.pubServeUrl == null) {
       cascade = cascade
           .add(_createPackagesHandler())
           .add(_jsHandler.handler)
           .add(createStaticHandler(_root))
           .add(_wrapperHandler);
     }
 
     var pipeline = new shelf.Pipeline()
       .addMiddleware(nestingMiddleware(_secret))
       .addHandler(cascade.handler);
 
     _server = await HttpMultiServer.loopback(0);
     shelf_io.serveRequests(_server, pipeline);
   }
 
   /// Returns a handler that serves the contents of the "packages/" directory
   /// for any URL that contains "packages/".
   ///
   /// This is a factory so it can wrap a static handler.
   shelf.Handler _createPackagesHandler() {
     var staticHandler =
-      createStaticHandler(_packageRoot, serveFilesOutsidePath: true);
+      createStaticHandler(_config.packageRoot, serveFilesOutsidePath: true);
 
     return (request) {
       var segments = p.url.split(shelfUrl(request).path);
 
       for (var i = 0; i < segments.length; i++) {
         if (segments[i] != "packages") continue;
         return staticHandler(
             shelfChange(request, path: p.url.joinAll(segments.take(i + 1))));
       }
 
@@ skipping 56 matching lines @@
     if (new File(htmlPath).existsSync() &&
         !new File(htmlPath).readAsStringSync()
             .contains('packages/test/dart.js')) {
       throw new LoadException(
           path,
           '"${htmlPath}" must contain <script src="packages/test/dart.js">'
               '</script>.');
     }
 
     var suiteUrl;
-    if (_pubServeUrl != null) {
+    if (_config.pubServeUrl != null) {
       var suitePrefix = p.withoutExtension(
           p.relative(path, from: p.join(_root, 'test')));
 
       var jsUrl;
       // Polymer generates a bootstrap entrypoint that wraps the entrypoint we
       // see on disk, and modifies the HTML file to point to the bootstrap
       // instead. To make sure we get the right source maps and wait for the
       // right file to compile, we have some Polymer-specific logic here to load
       // the boostrap instead of the unwrapped file.
       if (isPolymerEntrypoint(path)) {
-        jsUrl = _pubServeUrl.resolve(
+        jsUrl = _config.pubServeUrl.resolve(
             "$suitePrefix.html.polymer.bootstrap.dart.browser_test.dart.js");
       } else {
-        jsUrl = _pubServeUrl.resolve(
+        jsUrl = _config.pubServeUrl.resolve(
           '$suitePrefix.dart.browser_test.dart.js');
       }
 
       await _pubServeSuite(path, jsUrl);
-      suiteUrl = _pubServeUrl.resolveUri(p.toUri('$suitePrefix.html'));
+      suiteUrl = _config.pubServeUrl.resolveUri(p.toUri('$suitePrefix.html'));
     } else {
       if (browser.isJS) await _compileSuite(path);
       if (_closed) return null;
       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.
@@ skipping 29 matching lines @@
           // We don't care about the response body, but we have to drain it or
           // else the process can't exit.
           response.listen((_) {});
 
           throw new LoadException(path,
               "Error getting $mapUrl: ${response.statusCode} "
                   "${response.reasonPhrase}\n"
               'Make sure "pub serve" is serving the test/ directory.');
         }
 
-        if (_jsTrace) {
+        if (_config.jsTrace) {
           // Drain the response stream.
           response.listen((_) {});
           return;
         }
 
         _mappers[path] = new StackTraceMapper(
             await UTF8.decodeStream(response),
             mapUrl: mapUrl,
-            packageRoot: _pubServeUrl.resolve('packages'),
-            sdkRoot: _pubServeUrl.resolve('packages/\$sdk'));
+            packageRoot: _config.pubServeUrl.resolve('packages'),
+            sdkRoot: _config.pubServeUrl.resolve('packages/\$sdk'));
       } on IOException catch (error) {
         var message = getErrorMessage(error);
         if (error is SocketException) {
           message = "${error.osError.message} "
               "(errno ${error.osError.errorCode})";
         }
 
         throw new LoadException(path,
             "Error getting $mapUrl: $message\n"
             'Make sure "pub serve" is running.');
       } finally {
         timer.cancel();
       }
     });
   }
 
   /// Compile the test suite at [dartPath] to JavaScript.
   ///
   /// Once the suite has been compiled, it's added to [_jsHandler] so it can be
   /// served.
   Future _compileSuite(String dartPath) {
     return _compileFutures.putIfAbsent(dartPath, () async {
       var dir = new Directory(_compiledDir).createTempSync('test_').path;
       var jsPath = p.join(dir, p.basename(dartPath) + ".js");
 
-      await _compilers.compile(dartPath, jsPath, packageRoot: _packageRoot);
+      await _compilers.compile(dartPath, jsPath,
+          packageRoot: _config.packageRoot);
       if (_closed) return;
 
       var jsUrl = p.toUri(p.relative(dartPath, from: _root)).path +
           '.browser_test.dart.js';
       _jsHandler.add(jsUrl, (request) {
         return new shelf.Response.ok(new File(jsPath).readAsStringSync(),
             headers: {'Content-Type': 'application/javascript'});
       });
 
       var mapUrl = p.toUri(p.relative(dartPath, from: _root)).path +
           '.browser_test.dart.js.map';
       _jsHandler.add(mapUrl, (request) {
         return new shelf.Response.ok(
             new File(jsPath + '.map').readAsStringSync(),
             headers: {'Content-Type': 'application/json'});
       });
 
-      if (_jsTrace) return;
+      if (_config.jsTrace) return;
       var mapPath = jsPath + '.map';
       _mappers[dartPath] = new StackTraceMapper(
           new File(mapPath).readAsStringSync(),
           mapUrl: p.toUri(mapPath),
-          packageRoot: p.toUri(_packageRoot),
+          packageRoot: p.toUri(_config.packageRoot),
           sdkRoot: p.toUri(sdkDir));
     });
   }
 
   /// Returns the [BrowserManager] for [platform], which should be a browser.
   ///
   /// If no browser manager is running yet, starts one.
   Future<BrowserManager> _browserManagerFor(TestPlatform platform) {
     var manager = _browserManagers[platform];
     if (manager != null) return Result.release(manager);
 
     var completer = new Completer.sync();
     var path = _webSocketHandler.create(webSocketHandler(completer.complete));
     var webSocketUrl = url.replace(scheme: 'ws').resolve(path);
-    var hostUrl = (_pubServeUrl == null ? url : _pubServeUrl)
+    var hostUrl = (_config.pubServeUrl == null ? url : _config.pubServeUrl)
         .resolve('packages/test/src/runner/browser/static/index.html')
         .replace(queryParameters: {'managerUrl': webSocketUrl.toString()});
 
     var future = BrowserManager.start(platform, hostUrl, completer.future);
 
     // Capture errors and release them later to avoid Zone issues. This call to
     // [_browserManagerFor] is running in a different [LoadSuite] than future
     // calls, which means they're also running in different error zones so
     // errors can't be freely passed between them. Storing the error or value as
     // an explicit [Result] fixes that.
@@ skipping 13 matching lines @@
         if (result.isError) return;
 
         await result.asValue.value.close();
       }).toList();
 
       futures.add(_server.close());
       futures.add(_compilers.close());
 
       await Future.wait(futures);
 
-      if (_pubServeUrl == null) {
+      if (_config.pubServeUrl == null) {
         new Directory(_compiledDir).deleteSync(recursive: true);
       } else {
         _http.close();
       }
     });
   }
 }