pjs/testing/mochitest/browser-harness.xul

<?xml version="1.0"?>
<?xml-stylesheet href="chrome://global/skin" type="text/css"?>
<!-- ***** BEGIN LICENSE BLOCK *****
   - Version: MPL 1.1/GPL 2.0/LGPL 2.1
   -
   - The contents of this file are subject to the Mozilla Public License Version
   - 1.1 (the "License"); you may not use this file except in compliance with
   - the License. You may obtain a copy of the License at
   - http://www.mozilla.org/MPL/
   -
   - Software distributed under the License is distributed on an "AS IS" basis,
   - WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
   - for the specific language governing rights and limitations under the
   - License.
   -
   - The Original Code is Browser Test Harness.
   -
   - The Initial Developer of the Original Code is
   - Mozilla Corporation.
   -
   - Portions created by the Initial Developer are Copyright (C) 2007
   - the Initial Developer. All Rights Reserved.
   -
   - Contributor(s):
   -      Gavin Sharp <gavin@gavinsharp.com> (original author)
   -      Ehsan Akhgari <ehsan.akhgari@gmail.com>
   -
   - Alternatively, the contents of this file may be used under the terms of
   - either the GNU General Public License Version 2 or later (the "GPL"), or
   - the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
   - in which case the provisions of the GPL or the LGPL are applicable instead
   - of those above. If you wish to allow use of your version of this file only
   - under the terms of either the GPL or the LGPL, and not to allow others to
   - use your version of this file under the terms of the MPL, indicate your
   - decision by deleting the provisions above and replace them with the notice
   - and other provisions required by the LGPL or the GPL. If you do not delete
   - the provisions above, a recipient may use your version of this file under
   - the terms of any one of the MPL, the GPL or the LGPL.
   -
   - ***** END LICENSE BLOCK ***** -->

<window id="browserTestHarness"
        xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
        onload="TestStart();"
        title="Browser chrome tests"
        width="1024">
  <script src="chrome://mochikit/content/tests/SimpleTest/MozillaFileLogger.js"/>
  <script src="chrome://mochikit/content/tests/SimpleTest/quit.js"/>
  <style xmlns="http://www.w3.org/1999/xhtml"><![CDATA[
    #results {
      margin: 5px;
      background-color: window;
      -moz-user-select: text;
    }

    #summary {
      color: white;
      border: 2px solid black;
    }

    #summary.success {
      background-color: #0d0;
    }

    #summary.failure {
      background-color: red;
    }

    #summary.todo {
      background-color: orange;
    }

    .info {
      color: grey;
    }

    .failed {
      color: red;
      font-weight: bold;
    }

    .testHeader {
      margin-top: 1em;
    }

    p {
      margin: 0.1em;
    }
  ]]></style>
  <script type="application/javascript;version=1.7"><![CDATA[
    var gConfig;

    var gDumper = {
      get fileLogger() {
        let logger = null;
        if (gConfig.logPath) {
          try {
            MozillaFileLogger.init(gConfig.logPath);
            logger = MozillaFileLogger;
          } catch (ex) {
            dump("TEST-UNEXPECTED-FAIL | (browser-harness.xul) | " +
                 "Error trying to log to " + gConfig.logPath + ": " + ex + "\n");
          }
        }
        delete this.fileLogger;
        return this.fileLogger = logger;
      },

      dump: function (str) {
        dump(str);

        if (this.fileLogger)
          this.fileLogger._foStream.write(str, str.length);
      },

      done: function () {
        if (this.fileLogger)
          this.fileLogger.close();
      }
    }

    function TestStart() {
      gConfig = readConfig();

      // If MochiTest was started with the --test-path flag specifying a subset
      // of tests to run, put that path in the label of the "Run Tests" button
      // so the tester knows which tests will run when they press that button.
      if (gConfig.testPath)
        document.getElementById("runTestsButton").label =
          "Run " + gConfig.testPath + " tests";

      if (gConfig.autoRun)
        setTimeout(runTests, 0);
    }

    function readConfig() {
      var fileLocator = Cc["@mozilla.org/file/directory_service;1"].
                        getService(Ci.nsIProperties);
      var configFile = fileLocator.get("ProfD", Ci.nsIFile);
      configFile.append("testConfig.js");

      if (!configFile.exists())
        return;

      var fileInStream = Cc["@mozilla.org/network/file-input-stream;1"].
                         createInstance(Ci.nsIFileInputStream);
      var sstream = Cc["@mozilla.org/scriptableinputstream;1"].
                    createInstance(Ci.nsIScriptableInputStream);
      fileInStream.init(configFile, -1, 0, 0);
      sstream.init(fileInStream);

      var config = "";
      var str = sstream.read(4096);
      while (str.length > 0) {
        config += str;
        str = sstream.read(4096);
      }

      sstream.close();
      fileInStream.close();

      return eval(config);
    }

    function getChromeDir() {
      const Cc = Components.classes; const Ci = Components.interfaces;

      /** Find our chrome dir **/
      var ios = Cc["@mozilla.org/network/io-service;1"].
                  getService(Ci.nsIIOService);
      var chromeURI = ios.newURI("chrome://mochikit/content/",
                                 null, null);
      var resolvedURI = Cc["@mozilla.org/chrome/chrome-registry;1"].
                        getService(Ci.nsIChromeRegistry).
                        convertChromeURL(chromeURI);
      var fileHandler = Cc["@mozilla.org/network/protocol;1?name=file"].
                        getService(Ci.nsIFileProtocolHandler);
      var chromeDir = fileHandler.getFileFromURLSpec(resolvedURI.spec);

      return chromeDir.parent.QueryInterface(Ci.nsILocalFile);
    }

    function browserTest(aTestFile) {
      this.path = aTestFile;
      this.dumper = gDumper;
      this.results = [];
      this.scope = null;
    }
    browserTest.prototype = {
      get passCount() {
        return this.results.filter(function (t) !t.info && !t.todo && t.pass).length;
      },
      get todoCount() {
        return this.results.filter(function (t) !t.info && t.todo && t.pass).length;
      },
      get failCount() {
        return this.results.filter(function (t) !t.info && !t.pass).length;
      },

      addResult: function addResult(result) {
        this.results.push(result);

        this.dumper.dump(result.result + " | " + this.path + " | " + result.msg + "\n");
      },

      get htmlLog() {
        let txtToHTML = Cc["@mozilla.org/txttohtmlconv;1"].
                        getService(Ci.mozITXTToHTMLConv);
        function _entityEncode(str) {
          return txtToHTML.scanTXT(str, Ci.mozITXTToHTMLConv.kEntities);
        }
        var path = _entityEncode(this.path);
        return this.results.map(function (t) {
          var class = t.info ? "info" : "result " + (t.pass ? "passed" : "failed");
          return "<p class=\"" + class + "\">" + t.result + " | " + path +
                 " | " + _entityEncode(t.msg) + "</p>";
        }).join("\n");
      }
    };

    // Returns an array of browserTest objects for all the selected tests
    function listTests() {
      const Cc = Components.classes; const Ci = Components.interfaces;

      var ioSvc = Cc["@mozilla.org/network/io-service;1"].
                  getService(Ci.nsIIOService);

      var testsDir = getChromeDir();
      testsDir.appendRelativePath("browser");

      var requestPath = "chrome://mochikit/content/browser";
      var fileNameRegexp = /browser_.+\.js$/;

      if (gConfig.testPath) {
        var testsDirURI = ioSvc.newFileURI(testsDir);
        testsDir = ioSvc.newURI(gConfig.testPath, null, testsDirURI)
                        .QueryInterface(Ci.nsIFileURL).file;

        // Invalid testPath...
        if (!testsDir.exists())
          return [];

        // If we were passed a specific file, run only that test.
        if (testsDir.isFile()) {
          if (fileNameRegexp.test(testsDir.leafName))
            return [new browserTest(requestPath + "/" + gConfig.testPath)];

          // We were passed a file that's not a test...
          return [];
        }

        // otherwise, we were passed a directory of tests
        requestPath += "/" + gConfig.testPath;
      }

      // load server.js in so we can share template functions
      var scriptLoader = Cc["@mozilla.org/moz/jssubscript-loader;1"].
                         getService(Ci.mozIJSSubScriptLoader);
      var srvScope = {};
      scriptLoader.loadSubScript("chrome://mochikit/content/server.js", srvScope);

      var [links, ] = srvScope.list(requestPath, testsDir, true);
      var fileNames = [];
      srvScope.arrayOfTestFiles(links, fileNames, fileNameRegexp);

      return fileNames.map(function (f) new browserTest(f));
    }

    function setStatus(aStatusString) {
      document.getElementById("status").value = aStatusString;
    }

    function runTests() {
      var windowMediator = Cc['@mozilla.org/appshell/window-mediator;1'].
                             getService(Ci.nsIWindowMediator);
      var testWin = windowMediator.getMostRecentWindow("navigator:browser");

      setStatus("Running...");
      testWin.focus();

      var Tester = new testWin.Tester(listTests(), gDumper, testsFinished);
      Tester.start();
    }

    function sum(a, b) {
      return a + b;
    }

    function getHTMLLogFromTests(aTests) {
      if (!aTests.length)
        return "<div id=\"summary\" class=\"failure\">No tests to run." +
                 " Did you pass an invalid --test-path?</div>";

      var log = "";

      var passCount = aTests.map(function (f) f.passCount).reduce(sum);
      var failCount = aTests.map(function (f) f.failCount).reduce(sum);
      var todoCount = aTests.map(function (f) f.todoCount).reduce(sum);
      log += "<div id=\"summary\" class=\"";
      log += failCount != 0 ? "failure" :
               passCount == 0 ? "todo" : "success";
      log += "\">\n<p>Passed: " + passCount + "</p>\n" +
             "<p>Failed: " + failCount + "</p>\n" +
             "<p>Todo: " + todoCount + "</p>\n</div>\n<div id=\"log\">\n";

      return log + aTests.map(function (f) {
                                return "<p class=\"testHeader\">Running " + f.path + "...</p>\n" + f.htmlLog;
                              }).join("\n") + "</div>";
    }

    function testsFinished(aTests) {
      // Focus our window, to display the results
      window.focus();

      if (gConfig.closeWhenDone) {
        goQuitApplication();
        return;
      }

      // UI
      document.getElementById("results").innerHTML = getHTMLLogFromTests(aTests);
      setStatus("Done.");
    }
  ]]></script>
  <button id="runTestsButton" oncommand="runTests();" label="Run All Tests"/>
  <label id="status"/>
  <scrollbox flex="1" style="overflow: auto" align="stretch">
    <div id="results" xmlns="http://www.w3.org/1999/xhtml" flex="1"/>
  </scrollbox>
</window>