qunit-runner 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 371f9bd6512b7892f59bf25aa5f8373fde365d6a
+  data.tar.gz: a3ec017ff0fad9af6d3404e004b970cebe3b804a
+SHA512:
+  metadata.gz: 10eece62b27f97caa3725d2dcc18b9a3103906b3987c52918ff4b5882abe2ee7c6f661b0c79fd104efbc14fcc0177290754b4e36564c7b6b48dfe6620e5960eb
+  data.tar.gz: 166c0de2e9e2ae1900cb5081ea955c938d834f22056231a668bf82167662c55ceee1448055c0d2a8a52c828f360df8d2dbf64863af6a63785a8d50dac14a7af0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in qunit-runner.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 theScore Inc.
+
+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,43 @@
+# Qunit::Runner
+
+A ruby command line runner for Qunit tests using PhantomJS
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'qunit-runner'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install qunit-runner
+
+## Usage
+
+qunit-runner \[--timeout=milleseconds\] URL
+
+This will run a test suite located at the provided URL, giving an appropriate
+exit status and displaying test run progress and status.
+
+## API Usage
+
+You can invoke the test runner from inside your application using the
+`Qunit::Runner` class. Initialize the runner with the test URL, and then run the
+engine, optionally specifying a timeout.
+
+```
+url = "http://localhost:3000"
+Qunit::Runner.new(url).run
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/qunit-runner

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+require 'qunit/runner'
+require 'thor'
+
+class QunitRunnerCLI < Thor
+
+  desc "test URL", %{Run a qunit test suite at the specified URL}
+  option :timeout, :type => :numeric, :default => 10000,
+    :description => "Milliseconds to wait before giving up on the test suite"
+
+  def test(url)
+    Qunit::Runner.new(url).run(options[:timeout])
+  end
+
+  default_task :test
+end
+
+QunitRunnerCLI.start(ARGV)

data/lib/qunit/logger.rb

@@ -0,0 +1,26 @@
+module Qunit
+  class Logger
+    @print_color = !ENV.has_key?('DISABLE_COLOR')
+    class << self
+
+      def print(message, color = nil)
+        Kernel.print apply_color(message, color)
+      end
+
+      def puts(message, color = nil)
+        Kernel.puts apply_color(message, color)
+      end
+
+      protected
+
+      def apply_color(message, color = nil)
+        if !color.nil? && @print_color
+          message.send(color.to_sym)
+        else
+          message
+        end
+      end
+
+    end
+  end
+end

data/lib/qunit/parser.rb

@@ -0,0 +1,163 @@
+require 'qunit/logger'
+
+module Qunit
+  class Parser
+
+    attr_reader :current_module
+    attr_reader :current_test
+    attr_reader :unfinished_modules
+    attr_reader :failed_assertions
+    attr_reader :total_failed
+    attr_reader :total_passed
+    attr_reader :total
+    attr_reader :duration
+    attr_reader :logger
+
+    def initialize
+      @logger = Qunit::Logger
+      @unfinished_modules = Hash.new
+      @failed_assertions = Array.new
+      @total_failed = 0
+      @total_passed = 0
+      @total = 0
+      @duration = 0
+    end
+
+    def parse(line)
+      params = JSON.parse line
+      event = params.shift
+      case event
+      when 'qunit.moduleStart'
+        module_start *params
+      when 'qunit.moduleDone'
+        module_done *params
+      when 'qunit.testStart'
+        test_start *params
+      when 'qunit.testDone'
+        test_done *params
+      when 'qunit.log'
+        qunit_log *params
+      when 'qunit.done'
+        qunit_done *params
+      when 'fail.load'
+        fail_load *params
+      when 'fail.timeout'
+        fail_timeout *params
+      when 'console'
+        console *params
+      end
+    end
+
+    def module_start(name)
+      name ||= "Unnamed Module"
+      @unfinished_modules[name.to_sym] = true
+      @current_module = name
+      # exit status
+      return false, nil
+    end
+
+    def module_done(name, *args)
+      name ||= "Unnamed Module"
+      @unfinished_modules.delete(name.to_sym)
+      # exit status
+      return false, nil
+    end
+
+    def test_start(name)
+      prefix = @current_module ? "#{@current_module} - " : ''
+      @current_test = "#{prefix}#{name}"
+      # exit status
+      return false, nil
+    end
+
+    def test_done(name, failed, *args)
+      if failed > 0
+        logger.print 'F', :red
+      else
+        logger.print '.'
+      end
+      # exit status
+      return false, nil
+    end
+
+    def qunit_log(result, actual, expected, message, source)
+      if not result
+        assertion = {
+          name: @current_test,
+          actual: actual,
+          expected: expected,
+          message: message,
+          source: source
+        }
+        @failed_assertions.push assertion
+      end
+      # exit status
+      return false, nil
+    end
+
+    def qunit_done(failed, passed, total, duration)
+      @total_failed += failed
+      @total_passed += passed
+      @total += total
+      @duration += duration
+      log_summary
+    end
+
+    def fail_load(url)
+      logger.puts "PhantomJS unable to load #{url} URI", :red
+      @total_failed += 1
+      @total += 1
+      log_summary
+    end
+
+    def fail_timeout
+      logger.puts "PhantomJS timed out.", :red
+      @total_failed += 1
+      @total += 1
+      log_summary
+    end
+
+    def console(message)
+      prefix = ''
+      if @current_test
+        prefix << "\n[%s]" % @current_test
+      elsif @current_module
+        prefix << "\n[%s]" % @current_module
+      end
+      prefix << ' CONSOLE: '
+      logger.print prefix, :magenta
+      logger.print message
+      logger.print "\n"
+    end
+
+    def log_summary
+      logger.puts ''
+      @failed_assertions.each do |assertion|
+        logger.puts assertion[:name]
+        logger.puts "Message: #{assertion[:message]}", :red
+        if assertion[:actual] != assertion[:expected]
+          logger.puts "Actual: #{assertion[:actual]}", :magenta
+          logger.puts "Expected: #{assertion[:expected]}", :yellow
+        end
+        if assertion[:source]
+          logger.puts assertion[:source], :cyan
+        end
+        logger.puts ''
+      end
+      if @total == 0
+        logger.puts "0/0 assertions ran (#{@duration/1000.0}s)", :magenta
+      else
+        logger.puts "#{@total_passed}/#{@total} assertions passed (#{@duration/1000.0}s)"
+      end
+      if @total_failed == 0 and @total > 0
+        logger.puts "OK", :green
+        # exit status
+        return true, 0
+      else
+        # exit status
+        return true, 1
+      end
+    end
+
+  end
+end

data/lib/qunit/runner.rb

@@ -0,0 +1,72 @@
+require "qunit/runner/version"
+require 'qunit/logger'
+require 'qunit/parser'
+require 'shellwords'
+require 'open3'
+require 'json'
+require 'colorize'
+
+module Qunit
+  class Runner
+    attr_reader :should_exit
+    attr_reader :exit_status
+    attr_reader :test_url
+    attr_reader :logger
+
+    def initialize(url)
+      $stdout.sync = true
+      @should_exit = false
+      @exit_status = 0
+      @test_url = url
+      @logger = Qunit::Logger
+      @parser = Qunit::Parser.new
+    end
+
+    def run(load_timeout = 10000)
+      root = File.dirname(File.dirname(__FILE__))
+      qunit_bridge = File.join root, 'vendor', 'js', 'qunit_bridge.js'
+      phantom_bridge = File.join root, 'vendor', 'js', 'phantom_bridge.js'
+      opts = {
+        timeout: load_timeout,
+        inject: qunit_bridge
+      }
+      cmd = Shellwords.join [
+        'phantomjs',
+        phantom_bridge,
+        '/dev/stdout',
+        @test_url,
+        opts.to_json
+      ]
+      print_banner
+      Open3.popen3(cmd) do |i, o, e, t|
+        i.close
+        begin
+          while line = o.gets and !@should_exit
+            @should_exit, @exit_status = @parser.parse line
+          end
+          safe_kill t.pid
+        rescue Exception
+          safe_kill t.pid
+          raise
+        end
+      end
+      exit @exit_status
+    end
+
+    def safe_kill(pid)
+      begin
+        Process.kill("KILL", pid)
+        true
+      rescue
+        false
+      end
+    end
+
+    protected
+
+    def print_banner
+      logger.puts "Starting tests at url %s" % @test_url
+    end
+
+  end
+end

data/lib/qunit/runner/version.rb

@@ -0,0 +1,6 @@
+module Qunit
+  class Runner
+    VERSION = "0.0.1"
+  end
+end
+

data/lib/vendor/js/phantom_bridge.js

@@ -0,0 +1,131 @@
+/*global phantom:true*/
+(function() {
+
+'use strict';
+
+var fs = require('fs');
+
+// The temporary file used for communications.
+var tmpfile = phantom.args[0];
+// The page .html file to load.
+var url = phantom.args[1];
+// Extra, optionally overridable stuff.
+var options = JSON.parse(phantom.args[2] || "{}");
+
+// Default options.
+if (!options.timeout) { options.timeout = 5000; }
+
+// Keep track of the last time a client message was sent.
+var last = new Date();
+
+// Messages are sent to the parent by appending them to the tempfile.
+var sendMessage = function(arg) {
+  var args = Array.isArray(arg) ? arg : [].slice.call(arguments);
+  last = new Date();
+  fs.write(tmpfile, JSON.stringify(args) + '\n', 'a');
+};
+
+// This allows grunt to abort if the PhantomJS version isn't adequate.
+sendMessage('private', 'version', phantom.version);
+
+// Abort if the page doesn't send any messages for a while.
+setInterval(function() {
+  if (new Date() - last > options.timeout) {
+    sendMessage('fail.timeout');
+    phantom.exit();
+  }
+}, 100);
+
+// Create a new page.
+var page = require('webpage').create();
+
+// Inject bridge script into client page.
+var injected;
+var inject = function() {
+  if (injected) { return; }
+  // Inject client-side helper script.
+  var scripts = Array.isArray(options.inject) ? options.inject : [options.inject];
+  sendMessage('inject', options.inject);
+  scripts.forEach(page.injectJs);
+  injected = true;
+};
+
+// Keep track if the client-side helper script already has been injected.
+page.onUrlChanged = function(newUrl) {
+  injected = false;
+  sendMessage('onUrlChanged', newUrl);
+};
+
+// The client page must send its messages via alert(jsonstring).
+page.onAlert = function(str) {
+  // The only thing that should ever alert "inject" is the custom event
+  // handler this script adds to be executed on DOMContentLoaded.
+  if (str === 'inject') {
+    inject();
+    return;
+  }
+  // Otherwise, parse the specified message string and send it back to grunt.
+  // Unless there's a parse error. Then, complain.
+  try {
+    sendMessage(JSON.parse(str));
+  } catch(err) {
+    sendMessage('error.invalidJSON', str);
+  }
+};
+
+// Relay console logging messages.
+page.onConsoleMessage = function(message) {
+  if (!message.match(/^\[✓\].+/)) {
+    sendMessage('console', message);
+  }
+};
+
+// For debugging.
+page.onResourceRequested = function(request) {
+  sendMessage('onResourceRequested', request);
+};
+
+page.onResourceReceived = function(request) {
+  if (request.stage === 'end') {
+    sendMessage('onResourceReceived', request);
+  }
+};
+
+page.onError = function(msg, trace) {
+  sendMessage('error.onError', msg, trace);
+};
+
+// Run before the page is loaded.
+page.onInitialized = function() {
+  sendMessage('onInitialized');
+  // Abort if there is no bridge to inject.
+  if (!options.inject) { return; }
+  // Tell the client that when DOMContentLoaded fires, it needs to tell this
+  // script to inject the bridge. This should ensure that the bridge gets
+  // injected before any other DOMContentLoaded or window.load event handler.
+  page.evaluate(function() {
+    /*jshint browser:true, devel:true */
+    document.addEventListener('DOMContentLoaded', function() {
+      alert('inject');
+    }, false);
+  });
+};
+
+// Run when the page has finished loading.
+page.onLoadFinished = function(status) {
+  // reset this handler to a no-op so further calls to onLoadFinished from iframes don't affect us
+  page.onLoadFinished = function() { /* no-op */}
+
+  // The window has loaded.
+  sendMessage('onLoadFinished', status);
+  if (status !== 'success') {
+    // File loading failure.
+    sendMessage('fail.load', url);
+    phantom.exit();
+  }
+};
+
+// Actually load url.
+page.open(url);
+
+}());

data/lib/vendor/js/qunit_bridge.js

@@ -0,0 +1,59 @@
+/*
+ * grunt-contrib-qunit
+ * http://gruntjs.com/
+ *
+ * Copyright (c) 2013 "Cowboy" Ben Alman, contributors
+ * Licensed under the MIT license.
+ */
+
+/*global QUnit:true, alert:true*/
+(function () {
+  'use strict';
+
+  // Don't re-order tests.
+  QUnit.config.reorder = false;
+  // Run tests serially, not in parallel.
+  QUnit.config.autorun = false;
+
+  // Send messages to the parent PhantomJS process via alert! Good times!!
+  function sendMessage() {
+    var args = [].slice.call(arguments);
+    alert(JSON.stringify(args));
+  }
+
+  // These methods connect QUnit to PhantomJS.
+  QUnit.log(function(obj) {
+    // What is this I don’t even
+    if (obj.message === '[object Object], undefined:undefined') { return; }
+    // Parse some stuff before sending it.
+    var actual = QUnit.jsDump.parse(obj.actual);
+    var expected = QUnit.jsDump.parse(obj.expected);
+    // Send it.
+    sendMessage('qunit.log', obj.result, actual, expected, obj.message, obj.source);
+  });
+
+  QUnit.testStart(function(obj) {
+    sendMessage('qunit.testStart', obj.name);
+  });
+
+  QUnit.testDone(function(obj) {
+    sendMessage('qunit.testDone', obj.name, obj.failed, obj.passed, obj.total);
+  });
+
+  QUnit.moduleStart(function(obj) {
+    sendMessage('qunit.moduleStart', obj.name);
+  });
+
+  QUnit.moduleDone(function(obj) {
+    sendMessage('qunit.moduleDone', obj.name, obj.failed, obj.passed, obj.total);
+  });
+
+  QUnit.begin(function() {
+    sendMessage('qunit.begin');
+  });
+
+  QUnit.done(function(obj) {
+    sendMessage('qunit.done', obj.failed, obj.passed, obj.total, obj.runtime);
+  });
+}());
+

data/qunit-runner.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'qunit/runner/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "qunit-runner"
+  spec.version       = Qunit::Runner::VERSION
+  spec.authors       = ["M Smart, theScore Inc."]
+  spec.email         = ["matthew.smart@thescore.com"]
+  spec.description   = %q{QUnit test runner utizing phantomjs in ruby}
+  spec.summary       = %q{QUnit test runner utizing phantomjs in ruby}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "pry"
+  spec.add_runtime_dependency "colorize"
+  spec.add_runtime_dependency "thor"
+end

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: qunit-runner
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- M Smart, theScore Inc.
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: QUnit test runner utizing phantomjs in ruby
+email:
+- matthew.smart@thescore.com
+executables:
+- qunit-runner
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/qunit-runner
+- lib/qunit/logger.rb
+- lib/qunit/parser.rb
+- lib/qunit/runner.rb
+- lib/qunit/runner/version.rb
+- lib/vendor/js/phantom_bridge.js
+- lib/vendor/js/qunit_bridge.js
+- qunit-runner.gemspec
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: QUnit test runner utizing phantomjs in ruby
+test_files: []