qunited 0.0.1 → 0.1.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Aaron Royer
+
+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.md

@@ -0,0 +1,57 @@
+# QUnited
+
+QUnited is a tool to run headless JavaScript tests with QUnit.
+
+Right now it exists in a proof-of-concept phase and only runs tests with Rhino/Envjs. Give it a try and let me know if you have any feedback.
+
+## Installation
+
+```
+$ gem install qunited
+```
+
+## Running Tests
+
+Add the QUnited Rake task to your Rakefile.
+
+```ruby
+require 'qunited/rake_task'
+
+QUnited::RakeTask.new do |t|
+  t.source_files_pattern = 'lib/js/**/*.js'
+  t.test_files_pattern = 'test/js/**/*.js'
+end
+```
+
+Source and test files can also be configured as an array of file names. This may be desirable for source files since the order of their execution is often important. A glob pattern may not order the files correctly but configuring the task with an array can guarantee they are executed in the correct order.
+
+Note that all JavaScript dependencies will have to be loaded with source files. They will often need to be loaded before your own code so using an array to configure source files may be appropriate.
+
+```ruby
+require 'qunited/rake_task'
+
+QUnited::RakeTask.new do |t|
+  t.source_files = ['lib/js/jquery.js', 'lib/js/my_utils.js', 'lib/js/my_app.js']
+  t.test_files = ['test/js/test_my_utils.js', 'test/js/test_my_app.js']
+end
+```
+
+Note that you can also use an array to configure the test files but a glob pattern is usually more convenient since test files usually do not need to be loaded in a particular order.
+
+## Dependencies
+
+Right now only Rhino is set up to run tests. This means you'll need to have Java (version 1.1 minimum) in your path to use QUnited.
+
+## Attribution
+
+QUnited builds on work done on the following projects:
+
+[QUnit](https://github.com/jquery/qunit/) QUnit is a nice little JavaScript testing library and is, of course, central to what this project does.
+
+[Rhino](http://www.mozilla.org/rhino/) Rhino is a JavaScript interpreter that runs on the JVM.
+
+[Envjs](http://www.envjs.com/) Envjs is a simulated browser environment written in JavaScript.
+
+## License
+
+QUnited is MIT licensed

data/lib/qunited/driver/base.rb

@@ -0,0 +1,56 @@
+module QUnited
+  module Driver
+    class Base
+      attr_reader :results, :source_files, :test_files
+
+      # Finds an executable on the PATH. Returns the absolute path of the
+      # executable if found, otherwise nil.
+      def self.which(cmd)
+        exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+        ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+          exts.each do |ext|
+            exe = "#{path}/#{cmd}#{ext}"
+            return exe if File.executable? exe
+          end
+        end
+        return nil
+      end
+
+      # Get the path of the common (to all drivers) supporting files directory
+      def self.support_dir
+        @@support_dir = File.expand_path('../support', __FILE__)
+      end
+
+      # Array of file names? Glob pattern?
+      def initialize(source_files, test_files)
+        @source_files = if source_files.is_a? String
+          Dir.glob(source_files)
+        elsif source_files.is_a? Array
+          source_files
+        end
+
+        @test_files = if test_files.is_a? String
+          Dir.glob(test_files)
+        elsif test_files.is_a? Array
+          test_files
+        end
+      end
+
+      def run
+        raise 'run not implemented'
+      end
+
+      def support_file_path(filename)
+        File.join(self.class.support_dir, filename)
+      end
+
+      def support_file_contents(filename)
+        IO.read(support_file_path(filename))
+      end
+
+      def name
+        self.class.name.split('::')[-1]
+      end
+    end
+  end
+end

data/lib/qunited/driver/phantomjs/phantomjs.rb

@@ -0,0 +1,69 @@
+require 'pathname'
+require 'tempfile'
+require 'fileutils'
+require 'erb'
+require 'open3'
+
+module QUnited
+  module Driver
+    class PhantomJs < Base
+
+      # Determines whether this driver available to use.
+      # Checks whether phantomjs is on the PATH.
+      def self.available?
+        !!which('phantomjs')
+      end
+
+      def name
+        "PhantomJS" # Slightly more accurate than our class name
+      end
+
+      def run
+        self.tests_file = Tempfile.new(['tests_page', '.html'])
+        tests_file.write(tests_page_content)
+        tests_file.close
+
+        results_file = Tempfile.new('qunited_results')
+        results_file.close
+
+        cmd = %{phantomjs "#{File.expand_path('../support/runner.js', __FILE__)}" }
+        cmd << %{#{tests_file.path} #{results_file.path}}
+
+        Open3.popen3(cmd) do |stdin, stdout, stderr|
+          # PhantomJS sometimes puts error messages to stdout - redirect them to stderr
+          [stdout, stderr].each do |io|
+            unless (io_str = io.read).strip.empty? then $stderr.puts(io_str) end
+          end
+        end
+
+        @results = ::QUnited::Results.from_javascript_produced_yaml(IO.read(results_file))
+      end
+
+      private
+
+      attr_accessor :tests_file
+
+      def tests_page_content
+        ERB.new(IO.read(File.expand_path('../support/tests_page.html.erb', __FILE__))).result(binding)
+      end
+
+      def script_tag(file)
+        js_file_path, tests_file_path = Pathname.new(file).realpath, Pathname.new(tests_file)
+        begin
+          rel_path = js_file_path.relative_path_from(tests_file_path)
+          # Attempt to convert paths to relative URLs if Windows... should really test this
+          return %{<script type="text/javascript" src="#{rel_path.to_s.gsub(/\\/, '/')}"></script>}
+        rescue ArgumentError
+          # If we cannot get a relative path to the js file then just put the contents
+          # of the file inline. This can happen for a few reasons, like if the drive
+          # letter is different on Windows.
+          return <<-SCRIPT_ELEMENT
+<script type="text/javascript">
+  #{IO.read(file)}
+</script>
+          SCRIPT_ELEMENT
+        end
+      end
+    end
+  end
+end

data/lib/qunited/driver/phantomjs/support/runner.js

@@ -0,0 +1,103 @@
+/*
+Portions of this file are from the PhantomJS project from Ofi Labs.
+
+  Copyright (C) 2011 Ariya Hidayat <ariya.hidayat@gmail.com>
+  Copyright (C) 2011 Ivan De Marino <ivan.de.marino@gmail.com>
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+  * Neither the name of the <organization> nor the
+    names of its contributors may be used to endorse or promote products
+    derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+var system = require('system'), fs = require("fs");
+
+/**
+ * Wait until the test condition is true or a timeout occurs. Useful for waiting
+ * on a server response or for a ui change (fadeIn, etc.) to occur.
+ *
+ * @param testFx javascript condition that evaluates to a boolean,
+ * it can be passed in as a string (e.g.: "1 == 1" or "$('#bar').is(':visible')" or
+ * as a callback function.
+ * @param onReady what to do when testFx condition is fulfilled,
+ * it can be passed in as a string (e.g.: "1 == 1" or "$('#bar').is(':visible')" or
+ * as a callback function.
+ * @param timeOutMillis the max amount of time to wait. If not specified, 3 sec is used.
+ */
+function waitFor(testFx, onReady, timeOutMillis) {
+	var maxtimeOutMillis = timeOutMillis ? timeOutMillis : 3001, //< Default Max Timeout is 3s
+	start = new Date().getTime(),
+	condition = false,
+	interval = setInterval(function() {
+		if ( (new Date().getTime() - start < maxtimeOutMillis) && !condition ) {
+			// If not time-out yet and condition not yet fulfilled
+			condition = (typeof(testFx) === "string" ? eval(testFx) : testFx()); //< defensive code
+		} else {
+			if (!condition) {
+				// If condition still not fulfilled (timeout but condition is 'false')
+				console.log("ERROR: Timeout waiting for tests to complete");
+				phantom.exit(1);
+			} else {
+				// Condition fulfilled (timeout and/or condition is 'true')
+				//console.log("'waitFor()' finished in " + (new Date().getTime() - start) + "ms.");
+				typeof(onReady) === "string" ? eval(onReady) : onReady(); //< Do what it's supposed to do once the condition is fulfilled
+				clearInterval(interval); //< Stop this interval
+			}
+		}
+	}, 100);
+};
+
+
+if (system.args.length < 2) {
+	console.log('No tests file specified');
+	phantom.exit(1);
+} else if (system.args.length < 3) {
+	console.log('No results output file specified');
+	phantom.exit(1);
+}
+
+var page = require('webpage').create(),
+		tests_html_file = system.args[1],
+		results_output_file = system.args[2];
+
+page.open(tests_html_file, function(status) {
+    if (status !== "success") {
+        console.log("Could not open tests file");
+        phantom.exit(1);
+    } else {
+        waitFor(function(){
+						// Done when all tests have run (the results have been rendered)
+            return page.evaluate(function(){
+                var el = document.getElementById('qunit-testresult');
+                if (el && el.innerText.match('completed')) {
+                    return true;
+                }
+                return false;
+            });
+        }, function(){
+						// Results should have been collected with code in qunited.js. Check that file
+						// for more details. Grab the YAML it outputs and write it to the results file.
+            var results = page.evaluate(function() { return QUnited.collectedTestResultsAsYaml(); });
+						fs.write(results_output_file, results, 'a');
+            phantom.exit(0);
+        });
+    }
+});

data/lib/qunited/driver/phantomjs/support/tests_page.html.erb

@@ -0,0 +1,28 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <title>QUnit Test Suite</title>
+</head>
+<body>
+    <h1 id="qunit-header">QUnit Test Suite</h1>
+    <h2 id="qunit-banner"></h2>
+    <div id="qunit-testrunner-toolbar"></div>
+    <h2 id="qunit-userAgent"></h2>
+    <ol id="qunit-tests"></ol>
+</body>
+<%= script_tag support_file_path('qunit.js') %>
+<%= script_tag support_file_path('yaml.js') %>
+<%= script_tag support_file_path('qunited.js') %>
+
+<script type="text/javascript" charset="utf-8">
+	QUnited.startCollectingTestResults();
+</script>
+
+<% source_files.each do |source_file| %>
+	<%= script_tag source_file %>
+<% end %>
+<% test_files.each do |test_file| %>
+	<%= script_tag test_file %>
+<% end %>
+
+</html>

data/lib/qunited/driver/rhino/rhino.rb

@@ -0,0 +1,51 @@
+require 'tempfile'
+require 'fileutils'
+require 'open3'
+
+module QUnited
+  module Driver
+    class Rhino < Base
+
+      # Determines whether this driver available to use. Checks whether java
+      # is on the PATH and whether Java is version 1.1 or greater.
+      def self.available?
+        java_exe = which('java')
+        if java_exe
+          stdin, stdout, stderr = Open3.popen3('java -version')
+          begin
+            version = Float(stderr.read.split("\n").first[/(\d+\.\d+)/, 1])
+            version >= 1.1
+          rescue
+            false
+          end
+        end
+      end
+
+      def run
+        support_dir = File.expand_path('../support', __FILE__)
+        js_jar, runner = File.join(support_dir, 'js.jar'), File.join(support_dir, 'runner.js')
+
+        source_files_args = @source_files.map { |sf| %{"#{sf}"} }.join(' ')
+        test_files_args = @test_files.map { |tf| %{"#{tf}"} }.join(' ')
+
+        results_file = Tempfile.new('qunited_results')
+        results_file.close
+
+        cmd = %{java -jar "#{js_jar}" -opt -1 "#{runner}" }
+        cmd << %{"#{QUnited::Driver::Base.support_dir}" "#{support_dir}" "#{results_file.path}"}
+        cmd << " #{source_files_args} -- #{test_files_args}"
+
+        # Swallow stdout but allow stderr to get blasted out to console - if there are uncaught
+        # exceptions or anything else that goes wrong with the JavaScript interpreter the user
+        # will probably want to know but we are not particularly interested in it.
+        Open3.popen3(cmd) do |stdin, stdout, stderr|
+          stdout.each {||} # Ignore; this is just here to make sure we block
+                           # while waiting for tests to finish
+          unless (err = stderr.read).strip.empty? then $stderr.puts(err) end
+        end
+
+        @results = ::QUnited::Results.from_javascript_produced_yaml(IO.read(results_file))
+      end
+    end
+  end
+end

data/lib/qunited/{js_runner/rhino/js/qunit-runner.js → driver/rhino/support/runner.js}

@@ -1,23 +1,27 @@
 // Runs QUnit tests with Envjs and outputs test results as
 // an array of data serialized in YAML format.
 //
-// The first argument should be the lib directory containing JavaScript dependencies. The second
-// argument is the file to use for test results output. The next arguments are source JavaScript
-// files to test, until "--" is encountered. After the "--" the rest of the arguments are QUnit
+// The first argument should be the lib directory containing common QUnited dependencies. The second
+// argument is the directory containing Rhino driver specific dependencies. The third argument
+// is the file to use for test results output. The next arguments are source JavaScript files to
+// test, until "--" is encountered. After the "--" the rest of the arguments are QUnit
 // test files.
 //
 // Example:
-//   java -jar js.jar -opt -1 qunit-runner.js libdir outfile.yaml source.js -- test1.js test2.js
+//   java -jar js.jar -opt -1 runner.js commonlibdir libdir outfile.yaml source.js -- test1.js test2.js
 //                                            ^ our args start here
 
 var QUnited = { sourceFiles: [], testFiles: [] };
 
 (function(args) {
-	var libDir = args.shift();
+	var commonLibDir = args.shift(),
+			libDir = args.shift();
 	QUnited.outputFile = args.shift();
 
-	['env.rhino.js', 'qunit.js', 'yaml.js'].forEach(function(lib) {
-		load(libDir + '/' + lib);
+	load(libDir + '/env.rhino.js');
+
+	['qunit.js', 'yaml.js'].forEach(function(lib) {
+		load(commonLibDir + '/' + lib);
 	});
 
 	var readingSource = true;
@@ -94,7 +98,7 @@ QUnited.testFiles.forEach(function(file) {
 	// stderr and keeps on going without letting the caller of load() know what happened!
 	//
 	// Another option is to slurp in the file, eval it, and try/catch the errors and handle them
-	// accordingly. But, I found that the slurp and eval approach introduced to many subtle
+	// accordingly. But, I found that the slurp and eval approach introduced too many subtle
 	// misbehaviors to be worth it.
 	//
 	// The thing is, if a test file crashes and the tests aren't run then the build will succeed and

data/lib/qunited/driver/support/qunited.js

@@ -0,0 +1,76 @@
+var QUnited = QUnited || {};
+
+(function() {
+
+QUnited.util = {};
+QUnited.util.dateToString = function(date) {
+	if (Object.prototype.toString.call(date) === '[object String]') { return date; }
+	function pad(n) { return n < 10 ? '0' + n : n; }
+	return date.getUTCFullYear() + '-' + pad(date.getUTCMonth() + 1)+'-' + pad(date.getUTCDate()) + 'T' +
+		pad(date.getUTCHours()) + ':' + pad(date.getUTCMinutes()) + ':' + pad(date.getUTCSeconds()) + 'Z';
+};
+
+QUnited.startCollectingTestResults = function() {
+	// Various state we'll need while running the tests
+	QUnited.modulesMap = {};
+	QUnited.currentTestFile = null; // Set when loading files, see below
+	var currentModule, currentTest;
+
+	///// Listen for QUnit events during tests
+
+	QUnit.testStart(function(data) {
+		currentTest = {
+			name: data.name,
+			assertion_data: [], // Ruby-style, since we'll be reading it with Ruby
+			start: new Date(),
+			assertions: 0,
+			file: QUnited.currentTestFile
+		};
+
+		var moduleName = data.module || "(no module)",
+				module = QUnited.modulesMap[moduleName];
+		if (!module) {
+			module = {name: moduleName, tests: []};
+			QUnited.modulesMap[moduleName] = module;
+		}
+		module.tests.push(currentTest);
+	});
+
+	QUnit.testDone(function(data) {
+		currentTest.duration = ((new Date()).getTime() - currentTest.start.getTime()) / 1000;
+		currentTest.failed = data.failed;
+		currentTest.total = data.total;
+	});
+
+	/*
+	 * Called on every assertion AND whenever we have an expect(num) fail. You cannot tell this
+	 * apart from an assertion (even though you could make a good guess) with certainty so just
+	 * don't worry about it as it will only throw assertions count off on a failing test.
+	 */
+	QUnit.log(function(data) {
+		currentTest.assertions++;
+		currentTest.assertion_data.push(data);
+	});
+};
+
+QUnited.collectedTestResultsAsYaml = function() {
+	var modules = [];
+
+	// Make a modules array for outputing results
+	Object.keys(QUnited.modulesMap).forEach(function(key) {
+		var mod = QUnited.modulesMap[key],
+				tests = mod.tests;
+		modules.push(mod);
+		tests.forEach(function(test) {
+			// YAML serializer doesn't seem to do dates; make them strings
+			test.start = QUnited.util.dateToString(test.start);
+			// Convert the duration to a string since the YAML serializer makes them all 0s otherwise
+			test.duration = "" + test.duration;
+		});
+	});
+
+	// Write all the results as YAML
+	return YAML.encode(modules);
+};
+
+})();

data/lib/qunited/driver.rb

@@ -0,0 +1,3 @@
+require 'qunited/driver/base'
+require 'qunited/driver/rhino/rhino'
+require 'qunited/driver/phantomjs/phantomjs'

data/lib/qunited/results.rb

@@ -1,3 +1,5 @@
+require 'yaml'
+
 module QUnited
 
   # Simple tests results compiler. Takes a raw results hash that was produced by a runner.
@@ -79,6 +81,10 @@ module QUnited
       end
     end
 
+    def self.from_javascript_produced_yaml(yaml)
+      self.new clean_up_results(YAML.load(yaml))
+    end
+
     def initialize(modules_results_array)
       @data = modules_results_array.freeze
       @module_results = @data.map { |module_data| ModuleResults.new module_data }
@@ -160,5 +166,28 @@ module QUnited
     def errors
       @errors ||= assertions.select { |assert| assert.error? }
     end
+
+    # The YAML serializing JavaScript library does not put things into the cleanest form
+    # for us to work with. This turns the String keys into Symbols and converts Strings
+    # representing dates and numbers into their appropriate objects.
+    def self.clean_up_results(results)
+      results.map! { |mod_results| symbolize_keys mod_results }
+      results.each do |mod_results|
+        mod_results[:tests].map! { |test| clean_up_test_results(symbolize_keys(test)) }
+      end
+    end
+
+    def self.clean_up_test_results(test_results)
+      test_results[:start] = DateTime.parse(test_results[:start])
+      test_results[:duration] = Float(test_results[:duration])
+      test_results[:assertion_data].map! { |data| symbolize_keys data }
+      test_results
+    end
+
+    def self.symbolize_keys(hash)
+      new_hash = {}
+      hash.keys.each { |key| new_hash[key.to_sym] = hash[key] }
+      new_hash
+    end
   end
 end

data/lib/qunited/runner.rb

@@ -1,23 +1,23 @@
 module QUnited
   class Runner
+
+    # The drivers in order of which to use first when not otherwise specified
+    DRIVERS = [:PhantomJs, :Rhino].map { |driver| ::QUnited::Driver.const_get(driver) }.freeze
+
     def self.run(js_source_files, js_test_files)
-      js_runner_klass = self.js_runner
-      # TODO: test that this JsRunner can run with current environment
-      runner = js_runner_klass.new(js_source_files, js_test_files)
+      driver_class = self.best_available_driver
+      runner = driver_class.new(js_source_files, js_test_files)
 
       puts "\n# Running JavaScript tests with #{runner.name}:\n\n"
 
-      results = runner.run.results
+      results = runner.run
       puts results
       results.to_i
     end
 
     # Get the runner that we will be using to run the JavaScript tests.
-    #
-    # Right now we only have one JavaScript runner, but when we have multiple we will have to
-    # determine which one we will used unless explicitly configured.
-    def self.js_runner
-      ::QUnited::JsRunner::Rhino
+    def self.best_available_driver
+      DRIVERS.find { |driver| driver.available? }
     end
   end
 end

data/lib/qunited/version.rb

@@ -1,3 +1,3 @@
 module QUnited
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/lib/qunited.rb

@@ -1,4 +1,4 @@
 require 'qunited/version'
-require 'qunited/runner'
 require 'qunited/results'
-require 'qunited/js_runner'
+require 'qunited/driver'
+require 'qunited/runner'

data/test/unit/driver_common_tests.rb

@@ -0,0 +1,70 @@
+# Common driver tests that should pass for any implementation of
+# QUnited::Driver::Base. There are also a few utility methods included.
+module QUnited::DriverCommonTests
+  def test_driver_available
+    assert driver_class.available?, 'Driver should be available - if it is not then ' +
+      'either the available? method has a bug or you do not have the proper environment ' +
+      "to run the driver; check the available? method in the #{driver_class} driver class " +
+      'to get an idea of whether you should be able to run the driver'
+  end
+
+  def test_running_basic_tests
+    results = run_for_project('basic_project')
+    assert_equal 3, results.total_tests, 'Correct number of tests run'
+    assert_equal 4, results.total_assertions, 'Correct number of assertions executed'
+    assert_equal 0, results.total_failures, 'Correct number of failures given'
+  end
+
+  # Make sure we can run tests with DOM operations
+  def test_running_dom_tests
+    results = run_for_project('dom_project')
+    assert_equal 1, results.total_tests, 'Correct number of tests run'
+    assert_equal 2, results.total_assertions, 'Correct number of assertions executed'
+    assert_equal 0, results.total_failures, 'Correct number of failures given'
+  end
+
+  def test_failures_are_recorded_correctly
+    results = run_for_project('failures_project')
+    assert_equal 4, results.total_tests, 'Correct number of tests run'
+    # QUnit calls the log callback (the same it calls for assertions) every time there
+    # is a failed expect(num). So add one to this total.
+    assert_equal 5 + 1, results.total_assertions, 'Correct number of assertions executed'
+    assert_equal 4, results.total_failures, 'Correct number of failures given'
+  end
+
+  def test_syntax_error_in_test
+    runner = driver_class.new(
+      [File.join(FIXTURES_DIR, 'errors_project/app/assets/javascripts/no_error.js')],
+      [File.join(FIXTURES_DIR, 'errors_project/test/javascripts/this_test_has_syntax_error.js'),
+        File.join(FIXTURES_DIR, 'errors_project/test/javascripts/this_test_has_no_errors_in_it.js')])
+
+    stderr = capture_stderr { runner.run }
+    assert stderr.size > 10, 'Got some stderr output to describe the crash'
+    results = runner.results
+    assert runner.results.failed?, 'Should fail if syntax error in test'
+  end
+
+  protected
+
+  def driver_class
+    raise 'Must implement driver_class and return the driver class being tested'
+  end
+
+  def run_for_project(project_name)
+    runner = runner_for_project(project_name)
+    runner.run
+  end
+
+  def runner_for_project(project_name)
+    Dir.chdir File.join(FIXTURES_DIR, project_name)
+    driver_class.new("app/assets/javascripts/*.js", "test/javascripts/*.js")
+  end
+
+  def capture_stderr
+    previous_stderr, $stderr = $stderr, StringIO.new
+    yield
+    $stderr.string
+  ensure
+    $stderr = previous_stderr
+  end
+end

data/test/unit/test_phantomjs_driver.rb

@@ -0,0 +1,15 @@
+require File.expand_path('../../test_helper', __FILE__)
+require File.expand_path('../driver_common_tests', __FILE__)
+require 'stringio'
+
+# Test running tests with the PhantomJs driver.
+class TestPhantomJsDriver < MiniTest::Unit::TestCase
+  include QUnited::DriverCommonTests
+
+  private
+
+  def driver_class
+    QUnited::Driver::PhantomJs
+  end
+
+end

data/test/unit/{test_rhino_runner.rb → test_rhino_driver.rb}

@@ -1,36 +1,13 @@
 require File.expand_path('../../test_helper', __FILE__)
+require File.expand_path('../driver_common_tests', __FILE__)
 require 'stringio'
 
-# Test running tests with the Rhino test runner. These
-# are really more integration tests than unit tests.
-class TestRhinoRunner < MiniTest::Unit::TestCase
-
-  def test_running_basic_tests
-    results = runner_for_project('basic_project').run.results
-    assert_equal 3, results.total_tests, 'Correct number of tests run'
-    assert_equal 4, results.total_assertions, 'Correct number of assertions executed'
-    assert_equal 0, results.total_failures, 'Correct number of failures given'
-  end
-
-  # Make sure we can run tests with DOM operations
-  def test_running_dom_tests
-    results = runner_for_project('dom_project').run.results
-    assert_equal 1, results.total_tests, 'Correct number of tests run'
-    assert_equal 2, results.total_assertions, 'Correct number of assertions executed'
-    assert_equal 0, results.total_failures, 'Correct number of failures given'
-  end
-
-  def test_failures_are_recorded_correctly
-    results = runner_for_project('failures_project').run.results
-    assert_equal 4, results.total_tests, 'Correct number of tests run'
-    # QUnit calls the log callback (the same it calls for assertions) every time there
-    # is a failed expect(num). So add one to this total.
-    assert_equal 5 + 1, results.total_assertions, 'Correct number of assertions executed'
-    assert_equal 4, results.total_failures, 'Correct number of failures given'
-  end
+# Test running tests with the Rhino driver.
+class TestRhinoDriver < MiniTest::Unit::TestCase
+  include QUnited::DriverCommonTests
 
   def test_undefined_error_in_source
-    runner = QUnited::JsRunner::Rhino.new(
+    runner = QUnited::Driver::Rhino.new(
       [File.join(FIXTURES_DIR, 'errors_project/app/assets/javascripts/undefined_error.js')],
       [File.join(FIXTURES_DIR, 'errors_project/test/javascripts/this_test_has_no_errors_in_it.js')])
 
@@ -44,7 +21,7 @@ class TestRhinoRunner < MiniTest::Unit::TestCase
   end
 
   def test_syntax_error_in_source
-    runner = QUnited::JsRunner::Rhino.new(
+    runner = QUnited::Driver::Rhino.new(
       [File.join(FIXTURES_DIR, 'errors_project/app/assets/javascripts/syntax_error.js')],
       [File.join(FIXTURES_DIR, 'errors_project/test/javascripts/this_test_has_no_errors_in_it.js')])
 
@@ -58,7 +35,7 @@ class TestRhinoRunner < MiniTest::Unit::TestCase
   end
 
   def test_undefined_error_in_test
-    runner = QUnited::JsRunner::Rhino.new(
+    runner = QUnited::Driver::Rhino.new(
       [File.join(FIXTURES_DIR, 'errors_project/app/assets/javascripts/no_error.js')],
       [File.join(FIXTURES_DIR, 'errors_project/test/javascripts/this_test_has_undefined_error.js')])
 
@@ -74,20 +51,8 @@ class TestRhinoRunner < MiniTest::Unit::TestCase
     assert_equal 1, results.total_errors, 'Correct number of errors given'
   end
 
-  def test_syntax_error_in_test
-    runner = QUnited::JsRunner::Rhino.new(
-      [File.join(FIXTURES_DIR, 'errors_project/app/assets/javascripts/no_error.js')],
-      [File.join(FIXTURES_DIR, 'errors_project/test/javascripts/this_test_has_syntax_error.js'),
-        File.join(FIXTURES_DIR, 'errors_project/test/javascripts/this_test_has_no_errors_in_it.js')])
-
-    stderr = capture_stderr { runner.run }
-    assert stderr.size > 10, 'Got some stderr output to describe the crash'
-    results = runner.results
-    assert runner.results.failed?, 'Should fail if syntax error in test'
-  end
-
   def test_no_tests_in_test_file_means_failure
-    runner = QUnited::JsRunner::Rhino.new(
+    runner = QUnited::Driver::Rhino.new(
       [File.join(FIXTURES_DIR, 'errors_project/app/assets/javascripts/no_error.js')],
       [File.join(FIXTURES_DIR, 'errors_project/test/javascripts/this_test_has_no_tests.js')])
     runner.run
@@ -98,17 +63,8 @@ class TestRhinoRunner < MiniTest::Unit::TestCase
 
   private
 
-  def runner_for_project(project_name)
-    Dir.chdir File.join(FIXTURES_DIR, project_name)
-    QUnited::JsRunner::Rhino.new("app/assets/javascripts/*.js", "test/javascripts/*.js")
-  end
-
-  def capture_stderr
-    previous_stderr, $stderr = $stderr, StringIO.new
-    yield
-    $stderr.string
-  ensure
-    $stderr = previous_stderr
+  def driver_class
+    QUnited::Driver::Rhino
   end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: qunited
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-30 00:00:00.000000000 Z
+date: 2012-07-06 00:00:00.000000000 Z
 dependencies: []
 description: QUnited runs headless QUnit tests as part of your normal build
 email:
@@ -21,17 +21,23 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - Gemfile
+- MIT-LICENSE
+- README.md
 - Rakefile
 - bin/qunited
 - lib/qunited.rb
-- lib/qunited/js_runner.rb
-- lib/qunited/js_runner/base.rb
-- lib/qunited/js_runner/rhino.rb
-- lib/qunited/js_runner/rhino/js/env.rhino.js
-- lib/qunited/js_runner/rhino/js/js.jar
-- lib/qunited/js_runner/rhino/js/qunit-runner.js
-- lib/qunited/js_runner/rhino/js/qunit.js
-- lib/qunited/js_runner/rhino/js/yaml.js
+- lib/qunited/driver.rb
+- lib/qunited/driver/base.rb
+- lib/qunited/driver/phantomjs/phantomjs.rb
+- lib/qunited/driver/phantomjs/support/runner.js
+- lib/qunited/driver/phantomjs/support/tests_page.html.erb
+- lib/qunited/driver/rhino/rhino.rb
+- lib/qunited/driver/rhino/support/env.rhino.js
+- lib/qunited/driver/rhino/support/js.jar
+- lib/qunited/driver/rhino/support/runner.js
+- lib/qunited/driver/support/qunit.js
+- lib/qunited/driver/support/qunited.js
+- lib/qunited/driver/support/yaml.js
 - lib/qunited/rake_task.rb
 - lib/qunited/results.rb
 - lib/qunited/runner.rb
@@ -53,8 +59,10 @@ files:
 - test/fixtures/failures_project/test/javascripts/test_basics.js
 - test/fixtures/failures_project/test/javascripts/test_math.js
 - test/test_helper.rb
+- test/unit/driver_common_tests.rb
+- test/unit/test_phantomjs_driver.rb
 - test/unit/test_results.rb
-- test/unit/test_rhino_runner.rb
+- test/unit/test_rhino_driver.rb
 homepage: https://github.com/aaronroyer/qunited
 licenses: []
 post_install_message: 
@@ -96,5 +104,7 @@ test_files:
 - test/fixtures/failures_project/test/javascripts/test_basics.js
 - test/fixtures/failures_project/test/javascripts/test_math.js
 - test/test_helper.rb
+- test/unit/driver_common_tests.rb
+- test/unit/test_phantomjs_driver.rb
 - test/unit/test_results.rb
-- test/unit/test_rhino_runner.rb
+- test/unit/test_rhino_driver.rb

data/lib/qunited/js_runner/base.rb

@@ -1,34 +0,0 @@
-module QUnited
-  module JsRunner
-    class Base
-      attr_reader :results
-
-      # Array of file names? Glob pattern?
-      def initialize(source_files, test_files)
-        @source_files = if source_files.is_a? String
-          Dir.glob(source_files)
-        elsif source_files.is_a? Array
-          source_files
-        end
-
-        @test_files = if test_files.is_a? String
-          Dir.glob(test_files)
-        elsif test_files.is_a? Array
-          test_files
-        end
-      end
-
-      def can_run?
-        false
-      end
-
-      def name
-        self.class.name.split('::')[-1]
-      end
-
-      def run
-        raise 'run not implemented'
-      end
-    end
-  end
-end

data/lib/qunited/js_runner/rhino.rb

@@ -1,65 +0,0 @@
-require 'tempfile'
-require 'fileutils'
-require 'yaml'
-require 'open3'
-
-module QUnited
-  module JsRunner
-    class Rhino < Base
-      def can_run?
-        # TODO: test that you have Java
-      end
-
-      def run
-        js_dir = File.expand_path('../rhino/js', __FILE__)
-
-        js_jar, runner = File.join(js_dir, 'js.jar'), File.join(js_dir, 'qunit-runner.js')
-
-        source_files_args = @source_files.map { |sf| %{"#{sf}"} }.join(' ')
-        test_files_args = @test_files.map { |tf| %{"#{tf}"} }.join(' ')
-
-        tmp_file = Tempfile.new('qunited_results')
-        tmp_file.close
-
-        cmd = %{java -jar "#{js_jar}" -opt -1 "#{runner}" "#{js_dir}" "#{tmp_file.path}"}
-        cmd << " #{source_files_args} -- #{test_files_args}"
-
-        # Swallow stdout but allow stderr to get blasted out to console - if there are uncaught
-        # exceptions or anything else that goes wrong with the JavaScript interpreter the user
-        # will probably want to know but we are not particularly interested in it.
-        Open3.popen3(cmd) do |stdin, stdout, stderr|
-          stdout.each {||} # Ignore; this is just here to make sure we block
-                           # while waiting for tests to finish
-          unless (err = stderr.read).strip.empty? then $stderr.puts(err) end
-        end
-
-        @raw_results = clean_up_results(YAML.load(IO.read(tmp_file)))
-
-        @results = ::QUnited::Results.new @raw_results
-        self
-      end
-
-      private
-
-      def clean_up_results(results)
-        results.map! { |mod_results| symbolize_keys mod_results }
-        results.each do |mod_results|
-          mod_results[:tests].map! { |test| clean_up_test_results(symbolize_keys(test)) }
-        end
-      end
-
-      def clean_up_test_results(test_results)
-        test_results[:start] = DateTime.parse(test_results[:start])
-        test_results[:duration] = Float(test_results[:duration])
-        test_results[:assertion_data].map! { |data| symbolize_keys data }
-        test_results
-      end
-
-      def symbolize_keys(hash)
-        new_hash = {}
-        hash.keys.each { |key| new_hash[key.to_sym] = hash[key] }
-        new_hash
-      end
-    end
-  end
-end

data/lib/qunited/js_runner.rb

@@ -1,2 +0,0 @@
-require 'qunited/js_runner/base'
-require 'qunited/js_runner/rhino'