gabrielg-xultestrunner 0.1.0

data/.gitignore

@@ -0,0 +1 @@
+.DS_Store

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,6 @@
+XULTestRunner
+=============
+
+This is a XUL based test runner for running the quasi-scriptaculous-unittest.js-based tests that Conflagration and WaterTower use.
+
+Yes, it is a XUL app in a RubyGem, yes I am in touch with this.

data/Rakefile

@@ -0,0 +1,47 @@
+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"]
+  end
+  
+  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.1.0

data/bin/xultest

@@ -0,0 +1,12 @@
+#!/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
+
+exec(firefox_location, *["-app", xulapp_ini_path, *ARGV])

data/xulapp/application.ini

@@ -0,0 +1,9 @@
+[App]
+Name=XULTestRunner
+Version=0.1.0
+BuildID=a8de3f80-a874-4802-9c8f-60c958660398
+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/lib/shortcuts.js

@@ -0,0 +1,15 @@
+Cc = Components.classes;
+Ci = Components.interfaces;
+Cr = Components.results;
+Cu = Components.utils;
+loader = Cc["@mozilla.org/moz/jssubscript-loader;1"].getService(Ci.mozIJSSubScriptLoader);
+load = function(fileURI, moduleScope) {
+  try {
+    loader.loadSubScript(fileURI, moduleScope);
+  } catch (e) {
+    throw({name: "LoadError", message: "Failed to load " + fileURI + ": " + e.message});
+  }
+};
+
+print = dump;
+puts = function(str) { print(str + "\n"); };

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

@@ -0,0 +1,126 @@
+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(e) {
+    puts("There was a problem loading the test case from '" + fileURI + "'");
+  }
+  
+});
+
+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});
+    }
+  }
+});
+
+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,114 @@
+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 crashes. Wee.
+    this._testResults.push(data.evalJSON());
+    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: "file://" + 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);
+  }
+});
+
+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;
+  }
+});

data/xulapp/chrome/content/vendor/prototype/LICENSE

@@ -0,0 +1,16 @@
+Copyright (c) 2005-2008 Sam Stephenson
+
+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 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.