qunited 0.3.1 → 0.4.0

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

@@ -1,8 +1,15 @@
+/*
+ * This contains code that may be placed, by a QUnited driver, on the same page or context where
+ * QUnit tests are run. QUnit events are listened for and test results are collected for easier
+ * retrieval by other driver code.
+ */
+
 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; }
@@ -10,6 +17,60 @@ QUnited.util.dateToString = function(date) {
 		pad(date.getUTCHours()) + ':' + pad(date.getUTCMinutes()) + ':' + pad(date.getUTCSeconds()) + 'Z';
 };
 
+/*
+ * Converts the given serializable JavaScript object to a JSON string. Uses the native JSON.stringify.
+ */
+QUnited.util.jsonStringify = function(object) {
+	var jsonString,
+			stringifiableTypes,
+			toJSONFunctions,
+			i;
+
+	// Hack to work around toJSON functions breaking JSON serialization. This most notably can happen
+	// when the Prototype library is used. As much as we'd like to just delete these we have to
+	// save them to restore them later since tests may be run after this and user code may depend on
+	// this stuff.
+	stringifiableTypes = [Object, Array, String];
+	if (typeof Hash !== 'undefined' && Hash.prototype) { stringifiableTypes.push(Hash); }
+	toJSONFunctions = [];
+
+	for (i = 0; i < stringifiableTypes.length; i++) {
+		if (stringifiableTypes[i].prototype.toJSON) {
+			toJSONFunctions[i] = stringifiableTypes[i].prototype.toJSON;
+			delete stringifiableTypes[i].prototype.toJSON;
+		} else {
+			toJSONFunctions[i] = undefined;
+		}
+	}
+
+	// The 3rd argument here adds spaces to the generated JSON string. This is necessary
+	// for YAML parsers that are not compliant with YAML 1.2 (the version where YAML became
+	// a true superset of JSON).
+	jsonString = JSON.stringify(object, null, 1);
+
+	// Restore any toJSON functions we removed earlier
+	for (i = 0; i < toJSONFunctions.length; i++) {
+		if (toJSONFunctions[i]) {
+			stringifiableTypes[i].prototype.toJSON = toJSONFunctions[i];
+		}
+	}
+
+	return jsonString;
+};
+
+
+/* Test results that should be output to be picked up by the formatter, for live result updates
+ * while tests are still running. Not all runners may be able to do live updates but keeping this
+ * up to date enables that in case they are able to.
+ */
+QUnited.testResultsPendingOutput = [];
+
+/*
+ * Flag to indicate whether all of the QUnit tests have completed. This is set to true with the
+ * QUnit.done callback.
+ */
+QUnited.testsHaveCompleted = false;
+
 QUnited.startCollectingTestResults = function() {
 	// Various state we'll need while running the tests
 	QUnited.modulesMap = {};
@@ -19,16 +80,18 @@ QUnited.startCollectingTestResults = function() {
 	///// Listen for QUnit events during tests
 
 	QUnit.testStart(function(data) {
+		var moduleName = data.module || "(no module)",
+				module = QUnited.modulesMap[moduleName];
+
 		currentTest = {
 			name: data.name,
-			assertion_data: [], // Ruby-style, since we'll be reading it with Ruby
+			module_name: moduleName,
+			assertion_data: [],
 			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;
@@ -40,6 +103,8 @@ QUnited.startCollectingTestResults = function() {
 		currentTest.duration = ((new Date()).getTime() - currentTest.start.getTime()) / 1000;
 		currentTest.failed = data.failed;
 		currentTest.total = data.total;
+
+		QUnited.testResultsPendingOutput.push(currentTest);
 	});
 
 	/*
@@ -51,6 +116,10 @@ QUnited.startCollectingTestResults = function() {
 		currentTest.assertions++;
 		currentTest.assertion_data.push(data);
 	});
+
+	QUnit.done(function() {
+		QUnited.testsHaveCompleted = true;
+	});
 };
 
 /* Results as an Array of modules */
@@ -62,20 +131,7 @@ QUnited.collectedTestResults = function() {
 
 /* Module results as a JSON string */
 QUnited.collectedTestResultsAsJson = function() {
-	// Prototype can mess up JSON.stringify and break results serialization. Get
-	// rid of the bad bits if they are present.
-	// http://stackoverflow.com/questions/710586/json-stringify-bizarreness
-	if (window.Prototype) {
-		delete Object.prototype.toJSON;
-		delete Array.prototype.toJSON;
-		delete Hash.prototype.toJSON;
-		delete String.prototype.toJSON;
-	}
-
-	// The 3rd argument here adds spaces to the generated JSON string. This is necessary
-	// for YAML parsers that are not compliant with YAML 1.2 (the version where YAML became
-	// a true superset of JSON).
-	return JSON.stringify(QUnited.collectedTestResults(), null, 1);
+	return QUnited.util.jsonStringify(QUnited.collectedTestResults());
 };
 
 })();

data/lib/qunited/driver.rb

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

data/lib/qunited/formatter/base.rb

@@ -0,0 +1,42 @@
+module QUnited
+  module Formatter
+    class Base
+      attr_reader :driver_name, :output, :test_results
+
+      def initialize(options={})
+        @driver_name = options[:driver_name]
+        @output = options[:output] || $stdout
+        @test_results = []
+      end
+
+      # Called before we start running tests
+      def start
+      end
+
+      def test_passed(result)
+        @test_results << result
+      end
+
+      def test_failed(result)
+        @test_results << result
+      end
+
+      # Send arbitrary messages to the output stream
+      def message
+        output.puts message
+      end
+
+      # Called after all tests have run, before we summarize results
+      def stop
+      end
+
+      # Called after we have stopped running tests
+      def summarize
+      end
+
+      def close
+        output.close if IO === output && output != $stdout
+      end
+    end
+  end
+end

data/lib/qunited/formatter/dots.rb

@@ -0,0 +1,90 @@
+module QUnited
+  module Formatter
+    class Dots < Base
+      def start
+        super
+        output.print "\n# Running JavaScript tests with #{driver_name}:\n\n"
+      end
+
+      def test_passed(result)
+        super result
+        output.print '.'
+      end
+
+      def test_failed(result)
+        super result
+        output.print(result.error? ? 'E' : 'F')
+      end
+
+      def summarize
+        output.print "\n\n#{times_line}\n"
+        output.print failure_output
+        output.print "\n#{bottom_line}\n"
+      end
+
+      private
+
+      def failure_output
+        return '' unless total_failures > 0
+
+        all_failure_output = ''
+        count = 1
+        failures.each do |test|
+          test.assertions.reject { |a| a.passed? }.each do |assertion|
+            file_name_output = (test.file && !test.file.strip.empty?) ? " [#{test.file}]" : ''
+            msg = "\n  " + (count ? "#{count.to_s}) " : "")
+            msg << "#{assertion.error? ? 'Error' : 'Failure'}:\n"
+            msg << "#{test.name} (#{test.module_name})#{file_name_output}\n"
+            msg << "#{assertion.message || 'Failed assertion, no message given.'}\n"
+
+            if assertion.data.key? :expected
+              msg << "Expected: #{assertion.expected.nil? ? 'null' : assertion.expected.inspect}\n"
+              msg << "  Actual: #{assertion.actual.nil? ? 'null' : assertion.actual.inspect}\n"
+            end
+            all_failure_output << msg
+            count += 1
+          end
+        end
+
+        all_failure_output
+      end
+
+      def times_line
+        total_time = test_results.inject(0) { |total, result| total += result.duration }
+
+        tests_per = (total_time > 0) ? (total_tests / total_time) : total_tests
+        assertions_per = (total_time > 0) ? (total_assertions / total_time) : total_assertions
+
+        "Finished in #{"%.6g" % total_time} seconds, #{"%.6g" % tests_per} tests/s, " +
+          "#{"%.6g" % assertions_per} assertions/s."
+      end
+
+      def bottom_line
+        "#{total_tests} tests, #{total_assertions} assertions, " +
+          "#{total_failures} failures, #{total_errors} errors"
+      end
+
+      def failures
+        test_results.select { |tr| tr.failed? }
+      end
+
+      def total_tests
+        test_results.size
+      end
+
+      # Test failures, not assertion failures
+      def total_failures
+        failures.size
+      end
+
+      # Test errors, not assertion errors
+      def total_errors
+        test_results.select { |tr| tr.error? }.size
+      end
+
+      def total_assertions
+        test_results.inject(0) { |total, result| total += result.assertions.size}
+      end
+    end
+  end
+end

data/lib/qunited/formatter.rb

@@ -0,0 +1,2 @@
+require 'qunited/formatter/base'
+require 'qunited/formatter/dots'

data/lib/qunited/qunit_test_result.rb

@@ -0,0 +1,85 @@
+module QUnited
+
+  # Contains results data from a QUnit JavaScript test. Useful for passing data
+  # to formatters.
+  class QUnitTestResult
+    class AssertionResult
+      attr_accessor :data
+
+      def initialize(assertion_data)
+        @data = assertion_data
+      end
+
+      def message
+        data[:message] || 'Failed assertion, no message given.'
+      end
+
+      def result
+        if data[:result]
+          :passed
+        else
+          data[:message] =~ /^Died on test/ ? :error : :failed
+        end
+      end
+
+      def passed?; result == :passed end
+      def failed?; result == :failed end
+      def error?;  result == :error end
+
+      [:expected, :actual].each do |prop|
+        define_method(prop) do
+          data[prop]
+        end
+      end
+    end
+
+    def self.from_json(json)
+      self.new clean_up_result(YAML.load(json))
+    end
+
+    attr_accessor :data
+
+    def initialize(test_data)
+      @data = test_data
+    end
+
+    def passed?; result == :passed end
+    def failed?; result == :failed end
+    def error?;  result == :error end
+
+    def result
+      @result ||= if assertions.find { |a| a.error? }
+        :error
+      else
+        assertions.find { |a| a.failed? } ? :failed : :passed
+      end
+    end
+
+    def assertions
+      @assertions ||= data[:assertion_data].map { |assertion_data| AssertionResult.new assertion_data }
+    end
+
+    [:name, :module_name, :duration, :file].each do |prop|
+      define_method(prop) do
+        data[prop]
+      end
+    end
+
+    private
+
+    # Turn String keys into Symbols and convert Strings representing dates
+    # and numbers into their appropriate objects.
+    def self.clean_up_result(test_result)
+      test_result = symbolize_keys(test_result)
+      test_result[:start] = DateTime.parse(test_result[:start])
+      test_result[:assertion_data].map! { |data| symbolize_keys data }
+      test_result
+    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/rake_task.rb

@@ -8,21 +8,23 @@ module QUnited
     #   :qunited
     attr_accessor :name
 
-    # Glob pattern to match JavaScript source files (and any dependencies). Note that the
-    # order will be indeterminate so if your JavaScript files must be included in a particular
-    # order you will have to use source_files=(files_array).
-    #
-    # If an array of files is set with source_files=(files_array) then this will be ignored.
-    attr_accessor :source_files_pattern
+    # <b>DEPRECATED:</b> Please use <tt>source_files=</tt>, which now takes either an array of files
+    # or a glob pattern string.
+    def source_files_pattern=(pattern)
+      warn 'source_files_pattern= is deprecated in QUnited rake task config, use source_files= with a pattern'
+      @source_files = pattern
+    end
 
     # Array of JavaScript source files (and any dependencies). These will be loaded in order
     # before loading the QUnit tests.
     attr_accessor :source_files
 
-    # Glob pattern to match QUnit test files.
-    #
-    # If an array of test files is set with test_files=(files) then this will be ignored.
-    attr_accessor :test_files_pattern
+    # <b>DEPRECATED:</b> Please use <tt>test_files=</tt>, which now takes either an array of files
+    # or a glob pattern string.
+    def test_files_pattern=(pattern)
+      warn 'test_files_pattern= is deprecated in QUnited rake task config, use test_files= with a pattern'
+      @test_files = pattern
+    end
 
     # Array of QUnit test files.
     attr_accessor :test_files
@@ -36,6 +38,12 @@ module QUnited
     #   true
     attr_accessor :verbose
 
+    # Fail rake task when tests fail.
+    #
+    # default:
+    #   true
+    attr_accessor :fail_on_test_failure
+
     # The port to use if running the server.
     #
     # default:
@@ -45,6 +53,7 @@ module QUnited
     def initialize(*args)
       @name = args.shift || :qunited
       @verbose = true
+      @fail_on_test_failure = true
       @server_port = nil
 
       yield self if block_given?
@@ -60,12 +69,19 @@ module QUnited
           elsif test_files_to_run.empty?
             puts "No QUnit test files matching #{test_files_pattern} could be found"
           else
-            begin
-              puts command if verbose
-              success = system(command)
-            rescue
+            command = test_command
+            puts command if verbose
+            success = system(command)
+
+            unless success
+              if $?.exitstatus == 10
+                # 10 is our test failure status code
+                fail 'QUnit tests failed' if @fail_on_test_failure
+              else
+                # Other status codes should mean unexpected crashes
+                fail 'Something went wrong when running tests with QUnited'
+              end
             end
-            raise "#{command} failed" unless success
           end
         end
       end
@@ -85,18 +101,23 @@ module QUnited
 
     private
 
-    def command
+    def test_command
       cmd = 'qunited'
       cmd << " --driver #{driver}" if driver
       cmd << " #{source_files_to_include.join(' ')} -- #{test_files_to_run.join(' ')}"
     end
 
     def source_files_to_include
-      source_files || pattern_to_filelist(source_files_pattern)
+      files_array source_files
     end
 
     def test_files_to_run
-      test_files || pattern_to_filelist(test_files_pattern)
+      files_array test_files
+    end
+
+    # Force convert to array of files if glob pattern
+    def files_array(files)
+      files.is_a?(Array) ? files : pattern_to_filelist(files.to_s)
     end
 
     def pattern_to_filelist(pattern)

data/lib/qunited/runner.rb

@@ -11,14 +11,13 @@ module QUnited
     end
 
     def run
-      driver_class = resolve_driver_class
+      driver_class, formatter_class = resolve_driver_class, resolve_formatter_class
       driver = driver_class.new(js_source_files, js_test_files)
-
-      puts "\n# Running JavaScript tests with #{driver.name}:\n\n"
+      driver.formatter = formatter_class.new({:driver_name => driver.name})
 
       results = driver.run
-      puts results
-      results.to_i
+
+      results.all? { |r| r.passed? }
     end
 
     def resolve_driver_class
@@ -34,7 +33,6 @@ module QUnited
         elsif !driver_class.available?
           raise UsageError, "#{driver_class} driver specified, but not available"
         end
-        driver_class
       end
 
       driver_class ||= best_available_driver
@@ -42,13 +40,32 @@ module QUnited
       driver_class
     end
 
+    def resolve_formatter_class
+      if options[:formatter]
+        begin
+          formatter_class = get_formatter(options[:formatter])
+        rescue NameError
+          raise UsageError, "#{options[:formatter].to_s} does not exist"
+        end
+
+        raise UsageError, "#{formatter_class} formatter not found" unless formatter_class
+      end
+
+      formatter_class || ::QUnited::Formatter::Dots
+    end
+
     def get_driver(klass)
       if ::QUnited::Driver.constants.reject { |d| d == :Base }.include?(klass.to_s)
         ::QUnited::Driver.const_get(klass.to_s)
       end
     end
 
-    # Get the runner that we will be using to run the JavaScript tests.
+    def get_formatter(klass)
+      if ::QUnited::Formatter.constants.reject { |d| d == :Base }.include?(klass.to_s)
+        ::QUnited::Formatter.const_get(klass.to_s)
+      end
+    end
+
     def best_available_driver
       DRIVERS_PRIORITY.map { |driver| get_driver(driver) }.find { |driver| driver.available? }
     end

data/lib/qunited/version.rb

@@ -1,3 +1,3 @@
 module QUnited
-  VERSION = '0.3.1'
+  VERSION = '0.4.0'
 end

data/lib/qunited.rb

@@ -1,7 +1,8 @@
 require 'qunited/version'
-require 'qunited/results'
+require 'qunited/qunit_test_result'
 require 'qunited/driver'
 require 'qunited/runner'
+require 'qunited/formatter'
 require 'qunited/server'
 require 'qunited/application'
 

data/test/fixtures/failures_project/test/javascripts/test_math.js

@@ -3,7 +3,7 @@ module("Math");
 test("Addition is hard", function() {
 	expect(2);
 	equal(1 + 1, 3, "This math is wrong");
-	equal(2 + 2, 5, "This math is also wrong");
+	equal(2 + 2, null, "This expected null");
 });
 
 test("This expects the wrong number of assertions", function() {

data/test/test_helper.rb

@@ -1,5 +1,6 @@
 require 'rubygems'
 require 'minitest/autorun'
+require 'mocha/setup'
 
 require File.join(File.dirname(__FILE__), *%w[.. lib qunited])