pkg/unittest: cleanup to InteractiveHtmlConfiguration

pkg/unittest/lib/interactive_html_config.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.
 
 /**
  * This configuration can be used to rerun selected tests, as well
  * as see diagnostic output from tests. It runs each test in its own
  * IFrame, so the configuration consists of two parts - a 'parent'
  * config that manages all the tests, and a 'child' config for the
  * IFrame that runs the individual tests.
- * 
+ *
  * Note: this unit test configuration will not work with the debugger (the tests
  * are executed in a separate IFrame).
  */
 library unittest_interactive_html_config;
 
 // TODO(gram) - add options for: remove IFrame on done/keep
 // IFrame for failed tests/keep IFrame for all tests.
 
 import 'dart:html';
 import 'dart:async';
 import 'dart:math';
 import 'unittest.dart';
 
 /** The messages exchanged between parent and child. */
-
 class _Message {
   static const START = 'start';
   static const LOG = 'log';
   static const STACK = 'stack';
   static const PASS = 'pass';
   static const FAIL = 'fail';
   static const ERROR = 'error';
+  static const _PREFIX = 'TestMsg:';
 
-  String messageType;
-  int elapsed;
-  String body;
+  final String messageType;
+  final int elapsed;
+  final String body;
 
   static String text(String messageType,
                      [int elapsed = 0, String body = '']) =>
-      '$messageType $elapsed $body';
+      '$_PREFIX$messageType $elapsed $body';
 
   _Message(this.messageType, [this.elapsed = 0, this.body = '']);
 
-  _Message.fromString(String msg) {
-    int idx = msg.indexOf(' ');
-    messageType = msg.substring(0, idx);
+  factory _Message.fromString(String msg) {
+    if(!msg.startsWith(_PREFIX)) {
+      return null;
+    }
+    int idx = msg.indexOf(' ', _PREFIX.length);
+    var messageType = msg.substring(_PREFIX.length, idx);
     ++idx;
     int idx2 = msg.indexOf(' ', idx);
-    elapsed = int.parse(msg.substring(idx, idx2));
+    var elapsed = int.parse(msg.substring(idx, idx2));
     ++idx2;
-    body = msg.substring(idx2);
+    var body = msg.substring(idx2);
+
+    return new _Message(messageType, elapsed, body);
   }
 
   String toString() => text(messageType, elapsed, body);
 }
 
 
 class HtmlConfiguration extends Configuration {
   StreamSubscription _errorSubscription;
 
   void _installErrorHandler() {
@@ skipping 14 matching lines @@
 
 /**
  * The child configuration that is used to run individual tests in
  * an IFrame and post the results back to the parent. In principle
  * this can run more than one test in the IFrame but currently only
  * one is used.
  */
 class ChildInteractiveHtmlConfiguration extends HtmlConfiguration {
 
   /** The window to which results must be posted. */
-  WindowBase parentWindow;
+  WindowBase _parentWindow;
 
   /** The time at which tests start. */
-  Map<int,DateTime> _testStarts;
+  final Map<int,DateTime> _testStarts;
 
   ChildInteractiveHtmlConfiguration() :
       _testStarts = new Map<int,DateTime>();
 
   /** Don't start running tests automatically. */
   get autoStart => false;
 
   void onInit() {
     _installErrorHandler();
 
     /**
      *  The parent posts a 'start' message to kick things off,
      *  which is handled by this handler. It saves the parent
      *  window, gets the test ID from the query parameter in the
      *  IFrame URL, sets that as a solo test and starts test execution.
      */
     window.onMessage.listen((MessageEvent e) {
       // Get the result, do any logging, then do a pass/fail.
       var m = new _Message.fromString(e.data);
-      if (m.messageType == _Message.START) {
-        parentWindow = e.source;
+      if (m != null && m.messageType == _Message.START) {
+        _parentWindow = e.source;
         String search = window.location.search;
         int pos = search.indexOf('t=');
         String ids = search.substring(pos+2);
         int id = int.parse(ids);
         setSoloTest(id);
         runTests();
       }
     });
   }
 
@@ skipping 13 matching lines @@
    * a timestamp and posts them back to the parent window.
    */
   void onLogMessage(TestCase testCase, String message) {
     int elapsed;
     if (testCase == null) {
       elapsed = -1;
     } else {
       DateTime end = new DateTime.now();
       elapsed = end.difference(_testStarts[testCase.id]).inMilliseconds;
     }
-    parentWindow.postMessage(
+    _parentWindow.postMessage(
       _Message.text(_Message.LOG, elapsed, message).toString(), '*');
   }
 
   /**
    * Get the elapsed time for the test, anbd post the test result
    * back to the parent window. If the test failed due to an exception
    * the stack is posted back too (before the test result).
    */
   void onTestResult(TestCase testCase) {
     super.onTestResult(testCase);
     DateTime end = new DateTime.now();
     int elapsed = end.difference(_testStarts[testCase.id]).inMilliseconds;
     if (testCase.stackTrace != null) {
-      parentWindow.postMessage(
+      _parentWindow.postMessage(
           _Message.text(_Message.STACK, elapsed, testCase.stackTrace), '*');
     }
-    parentWindow.postMessage(
+    _parentWindow.postMessage(
         _Message.text(testCase.result, elapsed, testCase.message), '*');
   }
   void onSummary(int passed, int failed, int errors, List<TestCase> results,
       String uncaughtError) {
   }
 
   void onDone(bool success) {
     _uninstallErrorHandler();
   }
 }
 
 /**
  * The parent configuration runs in the top-level window; it wraps the tests
  * in new functions that create child IFrames and run the real tests.
  */
 class ParentInteractiveHtmlConfiguration extends HtmlConfiguration {
-  Map<int,DateTime> _testStarts;
+  final Map<int,DateTime> _testStarts;
 
 
   /** The stack that was posted back from the child, if any. */
   String _stack;
 
   int _testTime;
   /**
    * Whether or not we have already wrapped the TestCase test functions
    * in new closures that instead create an IFrame and get it to run the
    * test.
    */
   bool _doneWrap = false;
 
   StreamSubscription _messageSubscription;
 
   ParentInteractiveHtmlConfiguration() :
       _testStarts = new Map<int,DateTime>();
 
   // We need to block until the test is done, so we make a
   // dummy async callback that we will use to flag completion.
-  Function completeTest = null;
+  Function _completeTest = null;
 
-  wrapTest(TestCase testCase) {
+  Function _wrapTest(TestCase testCase) {
     String baseUrl = window.location.toString();
     String url = '${baseUrl}?t=${testCase.id}';
     return () {
       // Rebuild the child IFrame.
       Element childDiv = document.query('#child');
       childDiv.nodes.clear();
       IFrameElement child = new Element.html("""
           <iframe id='childFrame${testCase.id}' src='$url' style='display:none'>
           </iframe>""");
       childDiv.nodes.add(child);
-      completeTest = expectAsync0((){ });
+      _completeTest = expectAsync0((){ });
       // Kick off the test when the IFrame is loaded.
       child.onLoad.listen((e) {
         child.contentWindow.postMessage(_Message.text(_Message.START), '*');
       });
     };
   }
 
   void _handleMessage(MessageEvent e) {
     // Get the result, do any logging, then do a pass/fail.
     var msg = new _Message.fromString(e.data);
+
+    if(msg == null) {
+      return;
+    }
     if (msg.messageType == _Message.LOG) {
       logMessage(e.data);
     } else if (msg.messageType == _Message.STACK) {
       _stack = msg.body;
     } else {
       _testTime = msg.elapsed;
       logMessage(_Message.text(_Message.LOG, _testTime, 'Complete'));
       if (msg.messageType == _Message.PASS) {
         currentTestCase.pass();
       } else if (msg.messageType == _Message.FAIL) {
         currentTestCase.fail(msg.body, _stack);
       } else if (msg.messageType == _Message.ERROR) {
         currentTestCase.error(msg.body, _stack);
       }
-      completeTest();
+      _completeTest();
     }
   }
 
   void onInit() {
     _installErrorHandler();
     document.query('#group-divs').innerHtml = "";
   }
 
   void onStart() {
     _installErrorHandler();
     if (!_doneWrap) {
       _doneWrap = true;
       for (int i = 0; i < testCases.length; i++) {
-        testCases[i].testFunction = wrapTest(testCases[i]);
+        testCases[i].testFunction = _wrapTest(testCases[i]);
         testCases[i].setUp = null;
         testCases[i].tearDown = null;
       }
     }
     assert(_messageSubscription == null);
     _messageSubscription = window.onMessage.listen(_handleMessage);
   }
 
   static final _notAlphaNumeric = new RegExp('[^a-z0-9A-Z]');
 
@@ skipping 197 matching lines @@
         "</img></div>"));
   }
   if (document.query('#child') == null) {
     document.body.nodes.add(new Element.html("<div id='child'></div>"));
   }
 }
 
 /**
  * Allocate a Configuration. We allocate either a parent or child, depending on
  * whether the URL has a search part.
- * 
+ *
  * Note: this unit test configuration will not work with the debugger (the tests
  * are executed in a separate IFrame).
  */
 void useInteractiveHtmlConfiguration() {
   if (window.location.search == '') { // This is the parent.
     _prepareDom();
     unittestConfiguration = _singletonParent;
   } else {
     unittestConfiguration = _singletonChild;
   }
 }
 
 final _singletonParent = new ParentInteractiveHtmlConfiguration();
 final _singletonChild = new ChildInteractiveHtmlConfiguration();
 
-String _CSS = """
+const String _CSS = """
 body {
 font-family: Arial, sans-serif;
 margin: 0;
 font-size: 14px;
 }
 
 #application h2,
 #specs h2 {
 margin: 0;
 padding: 0.5em;
@@ skipping 176 matching lines @@
 
 ul, menu, dir {
 display: block;
 list-style-type: disc;
 -webkit-margin-before: 1em;
 -webkit-margin-after: 1em;
 -webkit-margin-start: 0px;
 -webkit-margin-end: 0px;
 -webkit-padding-start: 40px;
 }
-
-  """;
+""";