Implement a periodic timer which sends the current state of a browser test back to the browser cont…

dart/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";
 
@@ skipping 612 matching lines @@
   }
 
   String toString() => "Firefox";
 }
 
 
 /**
  * Describes the current state of a browser used for testing.
  */
 class BrowserTestingStatus {
-// TODO(ricow): Add prefetching to the browsers. We spend a lot of time waiting
-// for the next test. Handling timeouts is the hard part of this!
-
   Browser browser;
   BrowserTest currentTest;
+
   // This is currently not used for anything except for error reporting.
   // Given the usefulness of this in debugging issues this should not be
   // removed even when we have really stable system.
   BrowserTest lastTest;
   bool timeout = false;
   BrowserTestingStatus(Browser this.browser);
 }
 
 
 /**
  * Describes a single test to be run int the browser.
  */
 class BrowserTest {
   // TODO(ricow): Add timeout callback instead of the string passing hack.
   Function doneCallback;
   String url;
   int timeout;
+  String lastKnownMessage = '';
   Stopwatch stopwatch;
 
   // This might be null
   Duration delayUntilTestStarted;
 
   // We store this here for easy access when tests time out (instead of
   // capturing this in a closure)
   Timer timeoutTimer;
 
   // Used for debugging, this is simply a unique identifier assigned to each
@@ skipping 61 matching lines @@
 
   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);
     testingServer = new BrowserTestingServer(
         globalConfiguration, 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);
           var future = browser.start(url).then((success) {
             if (success) {
               browserStatus[browser.id] = new BrowserTestingStatus(browser);
             }
@@ skipping 94 matching lines @@
     } else {
       print("\nThis is bad, should never happen, handleResult no test");
       print("URL: ${status.lastTest.url}");
       print(output);
       terminate().then((_) {
         exit(1);
       });
     }
   }
 
+  void handleStatusUpdate(String browserId, String output, int testId) {
+    var status = browserStatus[browserId];
+
+    if (status == null || status.timeout) {
+      // We don't do anything, this browser is currently being killed and
+      // replaced. The browser here can be null if we decided to kill the
+      // browser.
+    } else if (status.currentTest != null && status.currentTest.id != testId) {
+      status.currentTest.lastKnownMessage = output;
+    }
+  }
+
   void handleStarted(String browserId, String output, int testId) {
     var status = browserStatus[browserId];
 
     if (status != null && !status.timeout && status.currentTest != null) {
       status.currentTest.timeoutTimer.cancel();
       status.currentTest.timeoutTimer =
           createTimeoutTimer(status.currentTest, status);
       status.currentTest.delayUntilTestStarted =
           status.currentTest.stopwatch.elapsed;
     }
   }
 
   void handleTimeout(BrowserTestingStatus status) {
     // We simply kill the browser and starts up a new one!
     // We could be smarter here, but it does not seems like it is worth it.
     status.timeout = true;
     timedOut.add(status.currentTest.url);
     var id = status.browser.id;
 
     status.currentTest.stopwatch.stop();
     status.browser.close().then((_) {
+      var lastKnownMessage =
+          'Dom could not be fetched, since the test timed out.';
+      if (status.currentTest.lastKnownMessage.length > 0) {
+        lastKnownMessage = status.currentTest.lastKnownMessage;
+      }
       // Wait until the browser is closed before reporting the test as timeout.
       // This will enable us to capture stdout/stderr from the browser
       // (which might provide us with information about what went wrong).
       var browserTestOutput = new BrowserTestOutput(
           status.currentTest.delayUntilTestStarted,
           status.currentTest.stopwatch.elapsed,
-          'Dom could not be fetched, since the test timed out.',
+          lastKnownMessage,
           status.browser.testBrowserOutput,
           didTimeout: true);
       status.currentTest.doneCallback(browserTestOutput);
       status.currentTest = null;
 
       // We don't want to start a new browser if we are terminating.
       if (underTermination) return;
       var browser;
       var new_id = id;
       if (browserName == 'chromeOnAndroid') {
@@ skipping 40 matching lines @@
     if (testQueue.isEmpty) return null;
     var status = browserStatus[browserId];
     if (status == null) return null;
 
     // We are currently terminating this browser, don't start a new test.
     if (status.timeout) return null;
 
     BrowserTest test = testQueue.removeLast();
     if (status.currentTest == null) {
       status.currentTest = test;
+      status.currentTest.lastKnownMessage = '';
     } else {
       // TODO(ricow): Handle this better.
       print("This is bad, should never happen, getNextTest all full");
       print("This happened for browser $browserId");
       print("Old test was: ${status.currentTest.url}");
       print("Timed out tests:");
       for (var v in timedOut) {
         print("  $v");
       }
       exit(1);
@@ skipping 74 matching lines @@
   /// 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);
 
   Future start() {
     int port = globalConfiguration['test_driver_port'];
     return HttpServer.bind(localIp, port).then((createdServer) {
       httpServer = createdServer;
       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");
-        if (request.uri.path.startsWith(reportPath)) {
-          var browserId = request.uri.path.substring(reportPath.length + 1);
+        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);
+          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;
@@ skipping 45 matching lines @@
                                "${request.uri.path}, data:  $back");
           }, onError: (error) { print(error); });
         }
         errorReportingServer.listen(errorReportingHandler,
                                     onError: errorHandler);
         return true;
       });
     });
   }
 
-  void handleReport(HttpRequest request, String browserId, var testId) {
+  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();
-      testDoneCallBack(browserId, back, testId);
+      if (isStatusUpdate) {
+        testStatusUpdateCallBack(browserId, back, testId);
+      } else {
+        testDoneCallBack(browserId, back, testId);
+      }
       // TODO(ricow): We should do something smart if we get an error here.
     }, onError: (error) { DebugLogger.error("$error"); });
   }
 
   void handleStarted(HttpRequest request, String browserId, var testId) {
     StringBuffer buffer = new StringBuffer();
     // If an error occurs while receiving the data from the request stream,
     // we don't handle it specially. We can safely ignore it, since the started
     // events are not crucial.
     request.transform(UTF8.decoder).listen((data) {
@@ skipping 31 matching lines @@
 
 
   String getDriverPage(String browserId) {
     var errorReportingUrl =
         "http://$localIp:${errorReportingServer.port}/$browserId";
     String driverContent = """
 <!DOCTYPE html><html>
 <head>
   <title>Driving page</title>
   <script type='text/javascript'>
-
     function startTesting() {
       var number_of_tests = 0;
       var current_id;
       var next_id;
       // Describes a state where we are currently fetching the next test
       // from the server. We use this to never double request tasks.
       var test_completed = true;
       var testing_window;
 
       var embedded_iframe = document.getElementById('embedded_iframe');
@@ skipping 75 matching lines @@
           if (this.readyState == this.DONE && this.status != 200) {
             var error = 'Sending back error did not succeeed: ' + this.status;
             error = error + '. Failed to send msg: ' + msg;
             error_div.innerHTML = error;
           }
         }
         contactBrowserController(
             'POST', '$errorReportingUrl?test=1', handleReady, msg, true); 
       }
 
-      function reportMessage(msg) {
-        if (msg == 'STARTING') {
+      function reportMessage(msg, isFirstMessage, isStatusUpdate) {
+        if (isFirstMessage) {
           test_completed = false;
           current_id = next_id;
           contactBrowserController(
             'POST', '$startedPath/${browserId}?id=' + current_id,
             function () {}, msg, true);
-          return;
-        }
+        } else if (isStatusUpdate) {
+            contactBrowserController(
+              'POST', '$statusUpdatePath/${browserId}?id=' + current_id,
+              function() {}, msg, true);
+        } else {
+          var is_double_report = test_completed;
+          test_completed = true;
 
-        var is_double_report = test_completed;
-        test_completed = true;
-
-        function handleReady() {
-          if (this.readyState == this.DONE) {
-            if (this.status == 200) {
-              if (!is_double_report) {
-                getNextTask();
+          function handleReady() {
+            if (this.readyState == this.DONE) {
+              if (this.status == 200) {
+                if (!is_double_report) {
+                  getNextTask();
+                }
+              } else {
+                reportError('Error sending result to server');
               }
-            } else {
-              reportError('Error sending result to server');
             }
           }
-        }
-        contactBrowserController(
+          contactBrowserController(
             'POST', '$reportPath/${browserId}?id=' + current_id, handleReady,
             msg, true);
+        }
+      }
+
+      function parseResult(result) {
+        var parsedData = null;
+        try {
+          parsedData = JSON.parse(result);
+        } catch(error) { }
+        return parsedData;
       }
 
       function messageHandler(e) {
         var msg = e.data;
         if (typeof msg != 'string') return;
-        reportMessage(msg);
+        
+        var parsedData = parseResult(msg);
+        if (parsedData) {
+          // Only if the JSON was valid, we'll post it back.
+          var message = parsedData['message'];
+          var isFirstMessage = parsedData['is_first_message'];
+          var isStatusUpdate = parsedData['is_status_update'];
+          var isDone = parsedData['is_done'];
+          if (!isFirstMessage && !isStatusUpdate) {
+            if (!isDone) {
+              alert("Bug in test_controller.js: " +
+                    "isFirstMessage/isStatusUpdate/isDone were all false");
+            }
+          }
+          if (message) {
+            reportMessage(message, isFirstMessage, isStatusUpdate);
+          }
+        } else {
+          reportMessage(msg, msg == 'STARTING', false);
+        }
       }
 
       window.addEventListener('message', messageHandler, false);
       waitForDone = false;
 
       getNextTask();
     }
 
   </script>
 </head>
   <body onload="startTesting()">
     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;
   }
 }