test.dart: Serve the browser test driver page from the test file HTTP server.

tools/testing/dart/browser_controller.dart

 // Copyright (c) 2013, 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 browser;
 
 import "dart:async";
 import "dart:convert" show LineSplitter, UTF8;
 import "dart:core";
 import "dart:io";
 
 import 'android.dart';
+import 'http_server.dart';
 import 'utils.dart';
 
 class BrowserOutput {
   final StringBuffer stdout = new StringBuffer();
   final StringBuffer stderr = new StringBuffer();
   final StringBuffer eventLog = new StringBuffer();
 }
 
 /** Class describing the interface for communicating with browsers. */
 abstract class Browser {
@@ skipping 781 matching lines @@
  * Encapsulates all the functionality for running tests in browsers.
  * The interface is rather simple. After starting, the runner tests
  * are simply added to the queue and a the supplied callbacks are called
  * whenever a test completes.
  */
 class BrowserTestRunner {
   static const int MAX_NEXT_TEST_TIMEOUTS = 10;
   static const Duration NEXT_TEST_TIMEOUT = const Duration(seconds: 60);
   static const Duration RESTART_BROWSER_INTERVAL = const Duration(seconds: 60);
 
-  final Map globalConfiguration;
-  final bool checkedMode; // needed for dartium
+  final Map configuration;

[ricow1, 2014/09/05 06:45:11]

Please file a bug to remove this

 
-  String localIp;
-  String browserName;
-  int maxNumBrowsers;
+  final String localIp;
+  final String browserName;
+  final int maxNumBrowsers;
+  bool checkedMode;
   // Used to send back logs from the browser (start, stop etc)
   Function logger;
   int browserIdCount = 0;
 
   bool underTermination = false;
   int numBrowserGetTestTimeouts = 0;
 
   List<BrowserTest> testQueue = new List<BrowserTest>();
   Map<String, BrowserTestingStatus> browserStatus =
       new Map<String, BrowserTestingStatus>();
 
   var adbDeviceMapping = new Map<String, AdbDevice>();
   // This cache is used to guarantee that we never see double reporting.
   // If we do we need to provide developers with this information.
   // We don't add urls to the cache until we have run it.
   Map<int, String> testCache = new Map<int, String>();
   Map<int, String> doubleReportingOutputs = new Map<int, String>();
 
   BrowserTestingServer testingServer;
 
   /**
    * The TestRunner takes the testingServer in as a constructor parameter in
    * case we wish to have a testing server with different behavior (such as the
    * case for performance testing.
    */
-  BrowserTestRunner(this.globalConfiguration,
+  BrowserTestRunner(this.configuration,
                     this.localIp,
                     this.browserName,
                     this.maxNumBrowsers,
-                    {bool this.checkedMode: false,
-                    BrowserTestingServer this.testingServer});
+                    {BrowserTestingServer this.testingServer}) {
+      checkedMode = configuration['checked'];

[ricow1, 2014/09/05 06:45:11]

indentation

+  }
 
   Future<bool> start() {
     // If [browserName] doesn't support opening new windows, we use new iframes
     // instead.
     bool useIframe =
         !Browser.BROWSERS_WITH_WINDOW_SUPPORT.contains(browserName);
     if (testingServer == null) {
       testingServer = new BrowserTestingServer(
-          globalConfiguration, localIp, useIframe);
+          configuration, localIp, useIframe);
     }
     return testingServer.start().then((_) {
       testingServer.testDoneCallBack = handleResults;
       testingServer.testStatusUpdateCallBack = handleStatusUpdate;
       testingServer.testStartedCallBack = handleStarted;
       testingServer.nextTestCallBack = getNextTest;
       return getBrowsers().then((browsers) {
         var futures = [];
         for (var browser in browsers) {
           var url = testingServer.getDriverUrl(browser.id);
@@ skipping 18 matching lines @@
   Future<List<Browser>> getBrowsers() {
     // TODO(kustermann): This is a hackisch way to accomplish it and should
     // be encapsulated
     var browsersCompleter = new Completer();
     var androidBrowserCreationMapping = {
       'chromeOnAndroid' : (AdbDevice device) => new AndroidChrome(device),
       'ContentShellOnAndroid' : (AdbDevice device) => new AndroidBrowser(
           device,
           contentShellOnAndroidConfig,
           checkedMode,
-          globalConfiguration['drt']),
+          configuration['drt']),
       'DartiumOnAndroid' : (AdbDevice device) => new AndroidBrowser(
           device,
           dartiumOnAndroidConfig,
           checkedMode,
-          globalConfiguration['dartium']),
+          configuration['dartium']),
     };
     if (androidBrowserCreationMapping.containsKey(browserName)) {
       AdbHelper.listDevices().then((deviceIds) {
         if (deviceIds.length > 0) {
           var browsers = [];
           for (int i = 0; i < deviceIds.length; i++) {
             var id = "BROWSER$i";
             var device = new AdbDevice(deviceIds[i]);
             adbDeviceMapping[id] = device;
             var browser = androidBrowserCreationMapping[browserName](device);
@@ skipping 133 matching lines @@
 
   void restartBrowser(String id) {
     var browser;
     var new_id = id;
     if (browserName == 'chromeOnAndroid') {
       browser = new AndroidChrome(adbDeviceMapping[id]);
     } else if (browserName == 'ContentShellOnAndroid') {
       browser = new AndroidBrowser(adbDeviceMapping[id],
                                    contentShellOnAndroidConfig,
                                    checkedMode,
-                                   globalConfiguration['drt']);
+                                   configuration['drt']);
     } else if (browserName == 'DartiumOnAndroid') {
       browser = new AndroidBrowser(adbDeviceMapping[id],
                                    dartiumOnAndroidConfig,
                                    checkedMode,
-                                   globalConfiguration['dartium']);
+                                   configuration['dartium']);
     } else {
       browserStatus.remove(id);
       browser = getInstance();
       new_id = "BROWSER$browserIdCount";
       browserIdCount++;
     }
     browser.id = new_id;
     var status = new BrowserTestingStatus(browser);
     browserStatus[new_id] = status;
     status.nextTestTimeout = createNextTestTimer(status);
@@ skipping 132 matching lines @@
     underTermination = true;
     testingServer.underTermination = true;
     for (BrowserTestingStatus status in browserStatus.values) {
       futures.add(status.browser.close());
       if (status.nextTestTimeout != null) {
         status.nextTestTimeout.cancel();
         status.nextTestTimeout = null;
       }
     }
     return Future.wait(futures).then((values) {
-      testingServer.httpServer.close();
       testingServer.errorReportingServer.close();
       printDoubleReportingTests();
       return !values.contains(false);
     });
   }
 
   Browser getInstance() {
     if (browserName == 'ff') browserName = 'firefox';
-    var path = Locations.getBrowserLocation(browserName, globalConfiguration);
+    var path = Locations.getBrowserLocation(browserName, configuration);
     var browser = new Browser.byName(browserName, path, checkedMode);
     browser.logger = logger;
     return browser;
   }
 }
 
 class BrowserTestingServer {
-  final Map globalConfiguration;
+  final Map configuration;
   /// Interface of the testing server:
   ///
   /// GET /driver/BROWSER_ID -- This will get the driver page to fetch
   ///                           and run tests ...
   /// GET /next_test/BROWSER_ID -- returns "WAIT" "TERMINATE" or "url#id"
   /// where url is the test to run, and id is the id of the test.
   /// If there are currently no available tests the waitSignal is send
   /// back. If we are in the process of terminating the terminateSignal
   /// is send back and the browser will stop requesting new tasks.
   /// POST /report/BROWSER_ID?id=NUM -- sends back the dom of the executed
   ///                                   test
 
   final String localIp;
 
   static const String driverPath = "/driver";
   static const String nextTestPath = "/next_test";
   static const String reportPath = "/report";
   static const String statusUpdatePath = "/status_update";
   static const String startedPath = "/started";
   static const String waitSignal = "WAIT";
   static const String terminateSignal = "TERMINATE";
 
   var testCount = 0;
-  var httpServer;
   var errorReportingServer;
   bool underTermination = false;
   bool useIframe = false;
 
   Function testDoneCallBack;
   Function testStatusUpdateCallBack;
   Function testStartedCallBack;
   Function nextTestCallBack;
 
-  BrowserTestingServer(this.globalConfiguration, this.localIp, this.useIframe);
+  BrowserTestingServer(this.configuration, this.localIp, this.useIframe);
 
   Future start() {
-    var test_driver_port = globalConfiguration['test_driver_port'];
-    var test_driver_error_port = globalConfiguration['test_driver_error_port'];
-    return HttpServer.bind(localIp, test_driver_port)
-      .then(setupDriverServer)
-      .then((_) => HttpServer.bind(localIp, test_driver_error_port))
-      .then(setupErrorServer);
-  }
-
-  void setupDriverServer(HttpServer server) {
-    httpServer = server;
-    void handler(HttpRequest request) {
-      // Don't allow caching of resources from the browser controller, i.e.,
-      // we don't want the browser to cache the result of getNextTest.
-      request.response.headers.set("Cache-Control",
-                                   "no-cache, no-store, must-revalidate");
-      bool isReport = request.uri.path.startsWith(reportPath);
-      bool isStatusUpdate = request.uri.path.startsWith(statusUpdatePath);
-      if (isReport || isStatusUpdate) {
-        var browserId;
-        if (isStatusUpdate) {
-          browserId = request.uri.path.substring(statusUpdatePath.length + 1);
-        } else {
-          browserId = request.uri.path.substring(reportPath.length + 1);
-        }
-        var testId =
-            int.parse(request.uri.queryParameters["id"].split("=")[1]);
-        handleReport(
-            request, browserId, testId, isStatusUpdate: isStatusUpdate);
-        // handleReport will asynchroniously fetch the data and will handle
-        // the closing of the streams.
-        return;
-      }
-      if (request.uri.path.startsWith(startedPath)) {
-        var browserId = request.uri.path.substring(startedPath.length + 1);
-        var testId =
-            int.parse(request.uri.queryParameters["id"].split("=")[1]);
-        handleStarted(request, browserId, testId);
-        return;
-      }
-      var textResponse = "";
-      if (request.uri.path.startsWith(driverPath)) {
-        var browserId = request.uri.path.substring(driverPath.length + 1);
-        textResponse = getDriverPage(browserId);
-        request.response.headers.set('Content-Type', 'text/html');
-      } else if (request.uri.path.startsWith(nextTestPath)) {
-        var browserId = request.uri.path.substring(nextTestPath.length + 1);
-        textResponse = getNextTest(browserId);
-        request.response.headers.set('Content-Type', 'text/plain');
-      } else {
-        // /favicon.ico requests
-      }
-      request.response.write(textResponse);
-      request.listen((_) {}, onDone: request.response.close);
-      request.response.done.catchError((error) {
-          if (!underTermination) {
-            print("URI ${request.uri}");
-            print("Textresponse $textResponse");
-            throw "Error returning content to browser: $error";
-          }
-        });
-    }
-    void errorHandler(e) {
-      if (!underTermination) print("Error occured in httpserver: $e");
-    }
-    httpServer.listen(handler, onError: errorHandler);
+    var test_driver_error_port = configuration['test_driver_error_port'];
+    return HttpServer.bind(localIp, test_driver_error_port)
+      .then(setupErrorServer)
+      .then(setupDispatchingServer);
   }
 
   void setupErrorServer(HttpServer server) {
     errorReportingServer = server;
     void errorReportingHandler(HttpRequest request) {
       StringBuffer buffer = new StringBuffer();
       request.transform(UTF8.decoder).listen((data) {
           buffer.write(data);
         }, onDone: () {
           String back = buffer.toString();
           request.response.headers.set("Access-Control-Allow-Origin", "*");
           request.response.done.catchError((error) {
               DebugLogger.error("Error getting error from browser"
                                 "on uri ${request.uri.path}: $error");
             });
           request.response.close();
           DebugLogger.error("Error from browser on : "
                             "${request.uri.path}, data:  $back");
         }, onError: (error) { print(error); });
     }
     void errorHandler(e) {
       if (!underTermination) print("Error occured in httpserver: $e");
     }
     errorReportingServer.listen(errorReportingHandler, onError: errorHandler);
   }
 
+  void setupDispatchingServer(_) {
+    DispatchingServer server = configuration['_servers_'].server;

[ricow1, 2014/09/05 06:45:11]

I think that we should allow for this to not be passed in. If it is not,
instantiate it here

+    void noCache(request) {
+        request.response.headers.set("Cache-Control",
+                                     "no-cache, no-store, must-revalidate");
+    }
+    int testId(request) =>
+        int.parse(request.uri.queryParameters["id"].split("=")[1]);
+    String browserId(request, prefix) =>
+        request.uri.path.substring(prefix.length + 1);
+
+
+    server.addHandler(reportPath, (HttpRequest request) {
+      noCache(request);
+      handleReport(request, browserId(request, reportPath),
+                   testId(request), isStatusUpdate: false);
+    });
+    server.addHandler(statusUpdatePath, (HttpRequest request) {
+      noCache(request);
+      handleReport(request, browserId(request, statusUpdatePath),
+                   testId(request), isStatusUpdate: true);
+    });
+    server.addHandler(startedPath, (HttpRequest request) {
+      noCache(request);
+      handleStarted(request, browserId(request, startedPath),
+                   testId(request));
+    });
+
+    makeSendPageHandler(String prefix) => (HttpRequest request) {
+      noCache(request);
+      var textResponse = "";
+      if (prefix == driverPath) {
+        textResponse = getDriverPage(browserId(request, prefix));
+        request.response.headers.set('Content-Type', 'text/html');
+      }
+      if (prefix == nextTestPath) {
+        textResponse = getNextTest(browserId(request, prefix));
+        request.response.headers.set('Content-Type', 'text/plain');
+      }
+      request.response.write(textResponse);
+      request.listen((_) {}, onDone: request.response.close);
+      request.response.done.catchError((error) {
+        if (!underTermination) {
+          print("URI ${request.uri}");
+          print("Textresponse $textResponse");
+          throw "Error returning content to browser: $error";
+        }
+      });
+    };
+    server.addHandler(driverPath, makeSendPageHandler(driverPath));
+    server.addHandler(nextTestPath, makeSendPageHandler(nextTestPath));
+  }
+
   void handleReport(HttpRequest request, String browserId, var testId,
                     {bool isStatusUpdate}) {
     StringBuffer buffer = new StringBuffer();
     request.transform(UTF8.decoder).listen((data) {
       buffer.write(data);
     }, onDone: () {
       String back = buffer.toString();
       request.response.close();
       if (isStatusUpdate) {
         testStatusUpdateCallBack(browserId, back, testId);
@@ skipping 26 matching lines @@
       return terminateSignal;
     } else if (nextTest == null) {
       // We don't currently have any tests ready for consumption, wait.
       return waitSignal;
     } else {
       return "${nextTest.url}#id=${nextTest.id}";
     }
   }
 
   String getDriverUrl(String browserId) {
-    if (httpServer == null) {
+    if (errorReportingServer == null) {
       print("Bad browser testing server, you are not started yet. Can't "
             "produce driver url");
       exit(1);
       // This should never happen - exit immediately;
     }
-    return "http://$localIp:${httpServer.port}/driver/$browserId";
+    var port = configuration['_servers_'].port;
+    return "http://$localIp:$port/driver/$browserId";
   }
 
 
   String getDriverPage(String browserId) {
     var errorReportingUrl =
         "http://$localIp:${errorReportingServer.port}/$browserId";
     String driverContent = """
 <!DOCTYPE html><html>
 <head>
   <title>Driving page</title>
@@ skipping 182 matching lines @@
     Dart test driver, number of tests: <div id="number"></div><br>
     Currently executing: <div id="currently_executing"></div><br>
     Unhandled error: <div id="unhandled_error"></div>
     <iframe id="embedded_iframe"></iframe>
   </body>
 </html>
 """;
     return driverContent;
   }
 }