xultestrunner 0.2.8

data/.gitignore

@@ -0,0 +1,2 @@
+.DS_Store
+*.gem

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "xulapp/chrome/content/vendor/xpcomcore"]
+	path = xulapp/chrome/content/vendor/xpcomcore
+	url = git://github.com/gabrielg/xpcomcore.git

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) <2009> <Gabriel Gironda>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README

@@ -0,0 +1,17 @@
+XULTestRunner
+=============
+
+This is a XUL based test runner for running the quasi-scriptaculous-unittest.js-based tests that Conflagration and WaterTower and XPCOMCore use.
+
+Yes, it is a XUL app in a RubyGem, yes I am in touch with this.
+
+NOTE
+====
+
+This project uses git submodules. Remember to 'git submodule init' and 'git submodule update'.
+
+TODO
+====
+
+* Better error output.
+* Write its own tests in itself.

data/Rakefile

@@ -0,0 +1,50 @@
+begin
+  require 'jeweler'
+  require 'uuidtools'
+  require 'pathname'
+  
+  Jeweler::Tasks.new do |s|
+    s.name = "xultestrunner"
+    s.executables = "xultest"
+    s.summary = "XUL based test runner for running your JS unit tests."
+    s.email = "contact@gironda.org"
+    s.homepage = "http://github.com/gabrielg/xultestrunner"
+    s.description = "XUL based test runner for running your JS unit tests."
+    s.authors = ["Gabriel Gironda"]
+    # FIXME - weird hack around jeweler ignoring the submoduled in xpcomcore.
+    s.files = (s.files + FileList["xulapp/chrome/content/vendor/**/*"]).uniq
+  end
+  Jeweler::GemcutterTasks.new
+  
+  application_ini_path = (Pathname(__FILE__).parent + "xulapp/application.ini").expand_path
+  
+  desc "Writes out a random UUID for the Build ID when we release to the XUL application's application.ini"
+  task :write_xul_build_id do
+    build_id = UUIDTools::UUID.random_create.to_s
+    ini_contents = application_ini_path.read
+    application_ini_path.open('w') do |f|
+      f << ini_contents.sub(/^BuildID=.*$/, "BuildID=#{build_id}")
+    end
+  end
+  
+  desc "Writes out the gem version to the XUL application's application.ini"
+  task :write_xul_version do
+    version = (Pathname(__FILE__).parent + "VERSION").read.chomp
+    ini_contents = application_ini_path.read
+    application_ini_path.open('w') do |f|
+      f << ini_contents.sub(/^Version=.*$/, "Version=#{version}")
+    end
+  end
+  
+  desc "Commits the application ini before a release"
+  task :commit_application_ini do
+    system("git", "add", application_ini_path.to_s)
+    system("git", "commit", "-m", "Bumping application.ini", application_ini_path.to_s)
+  end
+  
+  task :release => [:write_xul_build_id, :write_xul_version, :commit_application_ini]
+  
+rescue LoadError
+  puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.2.8

data/bin/xultest

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+require 'pathname'
+
+firefox_location = [`which firefox-bin`.chomp, `which firefox`.chomp].detect do |loc|
+  !loc.length.zero?
+end
+
+raise "Could not find `firefox-bin` or `firefox` in your path. Please rectify this and try again." unless firefox_location
+
+xulapp_ini_path = (Pathname(__FILE__).parent.parent + "xulapp/application.ini").expand_path
+
+puts("")
+exec(firefox_location, *["-app", xulapp_ini_path, *ARGV])

data/lib/xultestrunner.rb

@@ -0,0 +1 @@
+warn("There isn't much here, buddy. Just us lonely old Ruby files.")

data/xulapp/application.ini

@@ -0,0 +1,9 @@
+[App]
+Name=XULTestRunner
+Version=0.2.8
+BuildID=c3a91f64-3063-4bc5-b4ef-4ebf2cc114bf
+ID=XULTestRunner@conflagrationjs.org
+Vendor=Conflagration JS
+
+[Gecko]
+MinVersion=1.9.1

data/xulapp/chrome/chrome.manifest

@@ -0,0 +1,2 @@
+content xultestrunner file:content/
+resource xultestrunner file:content/

data/xulapp/chrome/content/interface/boot.xul

@@ -0,0 +1,20 @@
+<?xml version="1.0"?>
+<?xml-stylesheet href="chrome://global/skin/" type="text/css"?>
+
+<window id="main" title="XULTestRunner Console" width="800" height="600" xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
+  <script type="text/javascript">XPCOMCore({scope: this});</script>
+  <script type="text/javascript" src="resource://xultestrunner/vendor/prototype/prototype.js" />
+  <script type="text/javascript" src="resource://xultestrunner/lib/xultestrunner.js" />
+  <script type="text/javascript">  
+    window.addEventListener('load', function(){
+      var cmdService = $Cc["@conflagrationjs.org/xultestrunner/app-startup-clh;1"].getService().wrappedJSObject;
+      var harnessURI = "chrome://xultestrunner/content/interface/testharness.html";
+      var xulTestRunner = XULTestRunner.initializeFromCmdArgs(cmdService.args, {browser: $('test-browser'), harnessURI: harnessURI});
+      xulTestRunner.go();
+    }, false);
+  </script>
+
+  <caption label="XULTestRunner Console" />
+  <browser src="about:blank" id="test-browser" type="content-primary" flex="1" />
+  
+</window>

data/xulapp/chrome/content/interface/testharness.html

@@ -0,0 +1,30 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+  <title>Unit Test Harness</title>
+  <script type="text/javascript">XPCOMCore({scope: this});</script>
+  <script type="text/javascript" src="resource://xultestrunner/vendor/prototype/prototype.js"></script>
+  <script type="text/javascript" src="resource://xultestrunner/vendor/scriptaculous/unittest.js"></script>
+  <link rel="stylesheet" href="resource://xultestrunner/vendor/scriptaculous/test.css" type="text/css" />
+  <script type="text/javascript">
+  $(document).observe('dom:loaded', function(){
+    // FIXME - add stuff to xpcomcore for doing this jacked up crap
+    var ioService = $Cc["@mozilla.org/network/io-service;1"].getService($Ci.nsIIOService);
+    var resProt = ioService.getProtocolHandler("resource").QueryInterface($Ci.nsIResProtocolHandler);
+    var libPath = ioService.newURI(resProt.resolveURI(ioService.newURI("resource://xultestrunner/lib", null, null)), null, null).QueryInterface(Components.interfaces.nsIURL).path;
+
+    $LOAD_PATH.push(libPath);
+    require("xultestcase");
+
+    var qp = window.location.search.toQueryParams();
+    var testCase = XULTestCase.loadFromFile(qp.testFile);
+    testCase.go();
+  });
+  </script>
+</head>
+<body>
+<h1>Unit Test Harness</h1>
+  <!-- Log output -->
+  <div id="testlog"></div>
+</body>
+</html>

data/xulapp/chrome/content/lib/xultestcase.js

@@ -0,0 +1,140 @@
+var XULTestCase = Class.create({
+  initialize: function(testName, testDef) {
+    this.testRunner = new XULTestCase.TestRunner(testDef);
+    this.testRunner.name = testName;
+  },
+  
+  go: function() {
+    this.testRunner.runTests();
+  }
+  
+});
+
+Object.extend(XULTestCase, {
+  create: function(testName, testDefinitionFunc) {
+    var tests = {};
+    var setupCollector = function(givenSetup) { tests['setup'] = givenSetup; };
+    var teardownCollector = function(givenTeardown) { tests['teardown'] = givenTeardown; };
+    var testCollector = function(testName, testDef) { tests["test " + testName] = testDef; };
+    testDefinitionFunc(setupCollector, teardownCollector, testCollector);
+    var testCase = new XULTestCase(testName, tests);
+    this.__LAST_DEFINED_TESTCASE__ = testCase;
+    return testCase
+  },
+  
+  loadFromFile: function(fileURI) {
+    try {
+      load(fileURI);
+      if (this.__LAST_DEFINED_TESTCASE__) {
+        return this.__LAST_DEFINED_TESTCASE__;
+      } else {
+        throw("Wuh Oh");
+      }
+    } catch (e) {
+      this._handleTestLoadError(fileURI, e);
+    } finally {
+      this.__LAST_DEFINED_TESTCASE__ = null;
+    }
+  },
+  
+  _handleTestLoadError: function(fileURI, e) {
+    // Notify observers we failed and hope for the best
+    // FIXME - this sucks error reporting wise
+    var observerService = $Cc["@mozilla.org/observer-service;1"].getService($Ci.nsIObserverService);
+    observerService.notifyObservers(null, "xultestrunner-testloaderror", Object.toJSON({file: fileURI, exception: e.toString()}));
+  }
+  
+});
+
+XULTestCase.Logger = Class.create(Test.Unit.Logger, {
+  consoleOutputMapping: {failed: 'F', error: 'E', passed: '.'},
+  
+  initialize: function($super, log) {
+    $super(log);
+    this.unpassedTests = [];
+  },
+  
+  finish: function ($super, status, summary) {
+    $super(status, summary);
+    print(this.consoleOutputMapping[status]);
+    if (status != "passed") {
+      this.unpassedTests.push({name: this.testName, status: status, summary: summary});
+    }
+  }
+});
+
+var testUnitInspect = Test.Unit.inspect;
+Test.Unit.inspect = function(object) {
+  // FIXME - kinda seedy way to check if we got an Error rather than
+  // anything else and inspect it differently
+  if (object.stack && object.message) {
+    return "#{name}: #{message}\nFile: #{fileName} - Line: #{lineNumber}\n#{stack}".interpolate(object);
+  } else { 
+    return testUnitInspect(object); 
+  }
+};
+
+XULTestCase.TestRunner = Class.create(Test.Unit.Runner, {
+  // FIXME - ugh. straight rip from unittest.js just so we can ditch the settimeout 
+  // and instantiate our own logger.
+  
+  initialize: function(testcases) {
+    this.options = Object.extend({
+      testLog: 'testlog'
+    }, arguments[1] || {});
+    this.options.resultsURL = this.parseResultsURLQueryParameter();
+    this.options.tests      = this.parseTestsQueryParameter();
+    if (this.options.testLog) {
+      this.options.testLog = $(this.options.testLog) || null;
+    }
+    if(this.options.tests) {
+      this.tests = [];
+      for(var i = 0; i < this.options.tests.length; i++) {
+        if(/^test/.test(this.options.tests[i])) {
+          this.tests.push(new Test.Unit.Testcase(this.options.tests[i], testcases[this.options.tests[i]], testcases["setup"], testcases["teardown"]));
+        }
+      }
+    } else {
+      if (this.options.test) {
+        this.tests = [new Test.Unit.Testcase(this.options.test, testcases[this.options.test], testcases["setup"], testcases["teardown"])];
+      } else {
+        this.tests = [];
+        for(var testcase in testcases) {
+          if(/^test/.test(testcase)) {
+            this.tests.push(
+               new Test.Unit.Testcase(
+                 this.options.context ? ' -> ' + this.options.titles[testcase] : testcase, 
+                 testcases[testcase], testcases["setup"], testcases["teardown"]
+               ));
+          }
+        }
+      }
+    }
+    this.currentTest = 0;
+    this.logger = new XULTestCase.Logger(this.options.testLog);
+  },
+  
+  postResults: function($super) {
+    $super();
+    this._finishUpTestCase();
+  },
+  
+  _finishUpTestCase: function() {
+    var observerService = $Cc["@mozilla.org/observer-service;1"].getService($Ci.nsIObserverService);
+    var data = {name: this.name, unpassedTests: this.logger.unpassedTests, 
+                summary: this._summaryData(), testLength: this.tests.length};
+    // Need to pass between observers as JSON to avoid crashes. Wee.
+    observerService.notifyObservers(null, "xultestrunner-testdone", Object.toJSON(data));
+  },
+  
+  _summaryData: function() {
+    var assertions = 0, failures = 0, errors = 0;
+    $A(this.tests).each(function(test) {
+      assertions += test.assertions;
+      failures += test.failures;
+      errors += test.errors;
+    });
+    return {assertions: assertions, failures: failures, errors: errors};
+  }
+  
+});

data/xulapp/chrome/content/lib/xultestrunner.js

@@ -0,0 +1,120 @@
+var XULTestRunner = Class.create({
+  initialize: function(options) {
+    this.options = options;
+    this._testResults = [];
+    this.appStartup = $Cc["@mozilla.org/toolkit/app-startup;1"].getService($Ci.nsIAppStartup);
+  },
+  
+  handleExit: function (exitWithFailure) {
+    if (exitWithFailure) {
+      puts("Test Failures!");
+      // We kill ourselves this way because we need a non-zero exit status. This is really hacky.
+      // Really, really hacky.
+      var envFile = $Cc["@mozilla.org/file/local;1"].createInstance($Ci.nsILocalFile);
+      envFile.initWithPath("/usr/bin/env");
+      var process = $Cc["@mozilla.org/process/util;1"].createInstance($Ci.nsIProcess);
+      process.init(envFile);
+      process.run(true, ["ruby", "-e", "Process.kill(9, Process.ppid)"], 3);
+    }
+    this.appStartup.quit($Ci.nsIAppStartup.eForceQuit);
+  },
+  
+  
+  go: function () {
+    this._registerObservers();
+    var testsToRun = $A(this.options.tests).collect(function(testFile) { return '"' + testFile.path + '"'; });
+    puts("Running tests...");
+    puts(testsToRun.join(" ") + "\n");
+    this._runNextTest();
+  },
+  
+  observe: function(subject, topic, data) {
+    // Need to pass between observers as JSON to avoid XPCOM crashes. Wee.
+    var data = data.evalJSON();
+    if (topic == "xultestrunner-testdone") {
+      this._testResults.push(data);
+    } else if (topic == "xultestrunner-testloaderror") {
+      puts("There was an error loading test '#{file}': #{exception}".interpolate(data));
+    }
+    this._runNextTest();
+  },
+  
+  _runNextTest: function() {
+    var testFile = this.options.tests.shift();
+    if (testFile) {
+      this._runTest(testFile);
+    } else {
+      this._finishTestRun()
+    }
+  },
+  
+  _runTest: function(testFile) {
+    var qs = Object.toQueryString({testFile: encodeURI(testFile.path)});
+    var harnessWithPath = this.options.harnessURI + "?" + qs;
+    this.options.browser.loadURI(harnessWithPath);
+  },
+  
+  _finishTestRun: function() {
+    print("\n\n");
+    var exitWithFailure = this._doSummary();
+    this.handleExit(exitWithFailure);    
+  },
+  
+  _doSummary: function() {
+    var testRunners = 0, testCases = 0, unpassedLength = 0, assertions = 0, failures = 0, errors = 0;
+    $A(this._testResults).each(function(testResult) {
+      $A(testResult.unpassedTests).each(function(unpassedTest) { 
+        unpassedLength += 1;
+        this._showSummaryForTestResult(testResult.name, unpassedTest, unpassedLength); 
+      }, this);
+      testRunners++;
+      testCases += testResult.testLength;
+      assertions += testResult.summary.assertions;
+      failures += testResult.summary.failures;
+      errors += testResult.summary.errors;
+    }, this);
+    
+    var overallSummary = "\n\n#{runners} runners, #{cases} cases, #{unpassed} unpassed, #{assertions} assertions, #{failures} failures, #{errors} errors.\n";
+    puts(overallSummary.interpolate({runners: testRunners, cases: testCases, 
+                                     unpassed: unpassedLength, assertions: assertions, failures: failures, errors: errors}));
+    return unpassedLength > 0;
+  },
+  
+  _showSummaryForTestResult: function(testName, testResult, failureIndex) {
+    puts("#{index}) #{testName} - #{name}".interpolate({index: failureIndex, testName: testName, name: testResult.name}));
+    puts("  " + testResult.status.toUpperCase() + ":\n");
+    puts(testResult.summary.replace(/^/mg, "  ") + "\n\n");
+  },
+  
+  _registerObservers: function() {
+    var observerService = $Cc["@mozilla.org/observer-service;1"].getService($Ci.nsIObserverService);
+    observerService.addObserver(this, "xultestrunner-testdone", false);
+    observerService.addObserver(this, "xultestrunner-testloaderror", false);
+  }
+});
+
+Object.extend(XULTestRunner, {
+  testFileMatcher: /_test\.js$/,
+  initializeFromCmdArgs: function(cmdArgs, options) {
+    if (cmdArgs.testDir) {
+      var tests = this._findTestsFromDir(cmdArgs.testDir);
+    } else if (cmdArgs.testFile) {
+      var tests = [cmdArgs.testFile];
+    }
+    return new this(Object.extend({tests: $A(tests)}, options));
+  },
+  
+  _findTestsFromDir: function(rootDir) {
+    var testFiles = [];
+    var entries = rootDir.directoryEntries;
+    while (entries.hasMoreElements()) {
+      var entry = entries.getNext().QueryInterface($Ci.nsIFile);
+      if (entry.isDirectory()) {
+        testFiles = testFiles.concat(this._findTestsFromDir(entry));
+      } else if (this.testFileMatcher.test(entry.path)) {
+        testFiles.push(entry);
+      }
+    }
+    return testFiles;
+  }
+});