honkster-js-test-server 0.2.9

data/public/js_test_server/jasmine_driver.js

@@ -0,0 +1,63 @@
+JsTestServer.JasmineDriver = {};
+
+JsTestServer.JasmineDriver.init = function() {
+  JsTestServer.JasmineDriver.instance = new JsTestServer.JasmineDriver.Instance();
+  JsTestServer.JasmineDriver.instance.init();
+  JsTestServer.JasmineDriver.instance.startJasmine();
+};
+
+JsTestServer.JasmineDriver.Instance = function() {
+};
+
+(function(Instance) {
+  var jsTestServerReporter;
+
+  Instance.prototype.init = function() {
+    this.defineStatusMethod();
+  };
+
+  Instance.prototype.defineStatusMethod = function() {
+    JsTestServer.status = function() {
+      var runnerState;
+      var jasmineEnv = jasmine.getEnv();
+      jasmineEnv.reporter.log("jsTestServerReporter.finished: " + jsTestServerReporter.finished)
+
+      return JsTestServer.JSON.stringify({
+        "runner_state": jsTestServerReporter.runnerState,
+        "console": jsTestServerReporter.console
+      });
+    };
+  };
+
+  Instance.prototype.startJasmine = function() {
+    var jasmineEnv = jasmine.getEnv();
+    jsTestServerReporter = new JsTestServer.JasmineDriver.Reporter();
+    jasmineEnv.addReporter(jsTestServerReporter);
+    jasmineEnv.addReporter(new jasmine.JsApiReporter());
+    jasmine.TrivialReporter.prototype.log = function() {
+      if (window.console && window.console.log) window.console.log.apply(window.console, arguments);
+    };
+    jasmineEnv.addReporter(new jasmine.TrivialReporter());
+
+    window.onload = function() {
+      jasmineEnv.execute();
+    }
+  };
+
+  JsTestServer.JasmineDriver.Reporter = function() {
+    this.console = "";
+    this.finished = false;
+    this.runnerState = "running";
+  };
+  JsTestServer.JasmineDriver.Reporter.prototype.log = function(str) {
+    this.console += (str + "\n");
+  };
+  JsTestServer.JasmineDriver.Reporter.prototype.reportRunnerResults = function(runner) {
+    this.finished = true;
+    if (runner.results().failedCount == 0) {
+      this.runnerState = "passed";
+    } else {
+      this.runnerState = "failed";
+    }
+  }
+})(JsTestServer.JasmineDriver.Instance);

data/public/js_test_server/remote_control.js

@@ -0,0 +1,28 @@
+(function() {
+  JsTestServer.RemoteControl = function() {
+  };
+
+  JsTestServer.RemoteControl.start = function() {
+    var instance = new JsTestServer.RemoteControl();
+    instance.start();
+  };
+
+  JsTestServer.RemoteControl.prototype.start = function() {
+    this.poll();
+  };
+
+  JsTestServer.RemoteControl.prototype.poll = function() {
+    var self = this;
+    JsTestServer.xhrGet("/remote_control/commands", function(request) {
+      if(request.status == 200) {
+        var messages = eval(request.responseText);
+        for(var i=0; i < messages.length; i++) {
+          eval(messages[i].javascript);
+        }
+        setTimeout(function() {
+          self.poll();
+        }, 100);
+      };
+    });
+  };
+})();

data/public/js_test_server/screw_unit_driver.js

@@ -0,0 +1,31 @@
+(function($) {
+  var jsTestServerStatus = {"runner_state": "running", "console": ""};
+
+  JsTestServer.status = function() {
+    return JsTestServer.JSON.stringify(jsTestServerStatus);
+  };
+
+  $(Screw).bind('after', function() {
+    var error_text = $(".error").map(function(_i, error_element) {
+      var element = $(error_element);
+
+      var parent_descriptions = element.parents("li.describe");
+      var parent_description_text = [];
+
+      for(var i=parent_descriptions.length-1; i >= 0; i--) {
+        parent_description_text.push($(parent_descriptions[i]).find("h1").text());
+      }
+
+      var it_text = element.parents("li.it").find("h2").text();
+
+      return parent_description_text.join(" ") + " " + it_text + ": " + element.text();
+    }).get().join("\\n");
+
+    jsTestServerStatus["console"] = error_text;
+    if(error_text) {
+      jsTestServerStatus["runner_state"] = "failed";
+    } else {
+      jsTestServerStatus["runner_state"] = "passed";
+    }
+  });
+})(jQuery);

data/scratch.rb

@@ -0,0 +1,8 @@
+require "rubygems"
+require "uri"
+require "curb"
+
+Curl::Easy.http_post(
+  "http://localhost:8080/remote_control/commands",
+  "javascript=#{URI.encode("alert('hey you')")}"
+)

data/spec/frameworks/jasmine/cruise_config.rb

@@ -0,0 +1,21 @@
+# Project-specific configuration for CruiseControl.rb
+Project.configure do |project|
+
+  # Send email notifications about broken and fixed builds to email1@your.site, email2@your.site (default: send to nobody)
+  # project.email_notifier.emails = ['email1@your.site', 'email2@your.site']
+
+  # Set email 'from' field to john@doe.com:
+  # project.email_notifier.from = 'john@doe.com'
+
+  # Build the project by invoking rake task 'custom'
+  project.rake_task = 'jasmine:test:ci:saucelabs'
+
+  # Build the project by invoking shell script "build_my_app.sh". Keep in mind that when the script is invoked,
+  # current working directory is <em>[cruise&nbsp;data]</em>/projects/your_project/work, so if you do not keep build_my_app.sh
+  # in version control, it should be '../build_my_app.sh' instead
+  #project.build_command = 'cp ../saucelabs.yml .'
+
+  # Ping Subversion for new revisions every 5 minutes (default: 30 seconds)
+  # project.scheduler.polling_interval = 5.minutes
+
+end

data/spec/frameworks/jasmine/spec/jasmine_helper.rb

@@ -0,0 +1,44 @@
+class JasmineHelper
+  def self.jasmine_lib_dir
+    File.expand_path(File.join(jasmine_root, 'lib'))
+  end
+
+  def self.jasmine
+    ['/lib/' + File.basename(Dir.glob("#{JasmineHelper.jasmine_lib_dir}/jasmine*.js").first)] +
+      ['/lib/json2.js',
+       '/lib/TrivialReporter.js']
+  end
+
+  def self.jasmine_root
+    File.expand_path(File.join(File.dirname(__FILE__), '..'))
+  end
+
+
+  def self.jasmine_src_dir
+    File.expand_path(File.join(jasmine_root, 'src'))
+  end
+
+  def self.jasmine_lib_dir
+    File.expand_path(File.join(jasmine_root, 'lib'))
+  end
+
+  def self.jasmine_spec_dir
+    File.expand_path(File.join(jasmine_root, 'spec'))
+  end
+
+  def self.raw_spec_files
+    Dir.glob(File.join(jasmine_spec_dir, "**/*[Ss]pec.js"))
+  end
+
+  def self.specs
+    Jasmine.cachebust(raw_spec_files).collect {|f| f.sub(jasmine_spec_dir, "/spec")}
+  end
+
+  def self.dir_mappings
+    {
+      "/src" => jasmine_src_dir,
+      "/spec" => jasmine_spec_dir,
+      "/lib" => jasmine_lib_dir
+    }
+  end
+end

data/spec/frameworks/jasmine/spec/jasmine_spec.rb

@@ -0,0 +1,31 @@
+require 'rubygems'
+require File.expand_path(File.join(File.dirname(__FILE__), "jasmine_helper.rb"))
+require File.expand_path(File.join(JasmineHelper.jasmine_root, "contrib/ruby/jasmine_spec_builder"))
+
+jasmine_runner = if ENV['SAUCELABS'] == 'true'
+  require 'sauce_tunnel'
+  require 'selenium_config'
+  Jasmine::SauceLabsRunner.new(JasmineHelper.specs,
+    JasmineHelper.dir_mappings,
+    :saucelabs_config => 'saucelabs',
+    :saucelabs_config_file => File.expand_path(File.join(File.dirname(__FILE__), "saucelabs.yml")))
+else
+  require "selenium_rc"
+  Jasmine::Runner.new(SeleniumRC::Server.new('localhost').jar_path,
+    JasmineHelper.specs,
+    JasmineHelper.dir_mappings)
+end
+
+spec_builder = Jasmine::SpecBuilder.new(JasmineHelper.raw_spec_files, jasmine_runner)
+
+should_stop = false
+
+Spec::Runner.configure do |config|
+  config.after(:suite) do
+    spec_builder.stop if should_stop
+  end
+end
+
+spec_builder.start
+should_stop = true
+spec_builder.declare_suites

data/spec/functional/functional_spec_helper.rb

@@ -0,0 +1,55 @@
+require "rubygems"
+require "spec"
+require "spec/autorun"
+require "selenium_rc"
+require "thin"
+dir = File.dirname(__FILE__)
+LIBRARY_ROOT_DIR = File.expand_path("#{dir}/../..")
+require File.expand_path("#{dir}/../spec_helpers/be_http")
+require File.expand_path("#{dir}/../spec_helpers/show_test_exceptions")
+require File.expand_path("#{dir}/../spec_helpers/wait_for")
+require "#{dir}/functional_spec_server_starter"
+ARGV.push("-b")
+
+Spec::Runner.configure do |config|
+  config.mock_with :rr
+end
+
+Sinatra::Application.use ShowTestExceptions
+Sinatra::Application.set :raise_errors, true
+
+Sinatra::Application.use(JsTestServer::Server::App)
+
+class Spec::ExampleGroup
+  include WaitFor
+
+  def self.start_servers(framework_name)
+    before(:all) do
+      server = SeleniumRC::Server.new("0.0.0.0", "4444")
+      unless server.service_is_running?
+        worker = fork do
+          server.boot
+          exit!
+        end
+      end
+      trap("INT") do
+        server.stop
+      end
+      at_exit do
+        server.stop
+      end
+
+      FunctionalSpecServerStarter.new(framework_name).call
+      TCPSocket.wait_for_service :host => "0.0.0.0", :port => "4444"
+    end
+
+    after(:suite) do
+      FunctionalSpecServerStarter.new(framework_name).stop_thin_server
+    end
+  end
+
+
+  def root_url
+    "http://#{JsTestServer::Server::DEFAULTS[:host]}:#{JsTestServer::Server::DEFAULTS[:port]}"
+  end
+end

data/spec/functional/functional_spec_server_starter.rb

@@ -0,0 +1,69 @@
+require "rubygems"
+require "timeout"
+require "lsof"
+dir = File.dirname(__FILE__)
+$LOAD_PATH.unshift "#{dir}/../../lib"
+require "js_test_server"
+require "nokogiri"
+
+class FunctionalSpecServerStarter
+  include WaitFor
+
+  attr_reader :framework_name
+  def initialize(framework_name)
+    @framework_name = framework_name
+  end
+
+  def call(threaded=true)
+    return if $js_test_server_started
+
+    Lsof.kill(8080)
+    wait_for do
+      !Lsof.running?(8080)
+    end
+
+    dir = File.dirname(__FILE__)
+    Dir.chdir("#{dir}/../../") do
+      Thread.start do
+        start_thin_server
+      end
+    end
+
+    wait_for do
+      Lsof.running?(8080)
+    end
+    $js_test_server_started = true
+  end
+
+  def start_thin_server
+    system("bin/js-test-server --spec-path=#{spec_path} --root-path=#{root_path} --framework-name=#{framework_name} --framework-path=#{framework_path}")
+    at_exit do
+      stop_thin_server
+    end
+  end
+
+  def stop_thin_server
+    Lsof.kill(8080)
+  end
+
+  def framework_path
+    File.expand_path("#{dir}/../frameworks/#{framework_name}/lib")
+  end
+
+  def spec_path
+    File.expand_path("#{dir}/#{framework_name}/example_spec")
+  end
+
+  def root_path
+    File.expand_path("#{dir}/../example_root")
+  end
+
+  def dir
+    dir = File.dirname(__FILE__)
+  end
+end
+
+if $0 == __FILE__
+  FunctionalSpecServerStarter.new(ENV["FRAMEWORK_PATH"] || "jasmine").call(false)
+  sleep
+end

data/spec/functional/jasmine/jasmine_functional_spec.rb

@@ -0,0 +1,27 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../functional_spec_helper")
+
+describe JsTestServer do
+  start_servers("jasmine")
+  attr_reader :stdout, :request
+
+  before do
+    @stdout = StringIO.new
+    JsTestServer::Client.const_set(:STDOUT, stdout)
+    @request = "http request"
+  end
+
+  after do
+    JsTestServer::Client.__send__(:remove_const, :STDOUT)
+  end
+
+  it "runs a full passing Suite" do
+    JsTestServer::Client::Runner.run(:spec_url => "#{root_url}/specs/passing_spec")
+    stdout.string.strip.should include(JsTestServer::Client::PASSED_RUNNER_STATE.capitalize)
+  end
+
+  it "runs a full failing Suite" do
+    JsTestServer::Client::Runner.run(:spec_url => "#{root_url}/specs/failing_spec")
+    stdout.string.strip.should include(JsTestServer::Client::FAILED_RUNNER_STATE.capitalize)
+    stdout.string.strip.should include("A failing spec fails")
+  end
+end

data/spec/functional/screw-unit/screw_unit_functional_spec.rb

@@ -0,0 +1,27 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../functional_spec_helper")
+
+describe JsTestServer do
+  start_servers("screw-unit")
+  attr_reader :stdout, :request
+  
+  before do
+    @stdout = StringIO.new
+    JsTestServer::Client.const_set(:STDOUT, stdout)
+    @request = "http request"
+  end
+
+  after do
+    JsTestServer::Client.__send__(:remove_const, :STDOUT)
+  end
+
+  it "runs a full passing Suite" do
+    JsTestServer::Client::Runner.run(:spec_url => "#{root_url}/specs/passing_spec")
+    stdout.string.strip.should == JsTestServer::Client::PASSED_RUNNER_STATE.capitalize
+  end
+
+  it "runs a full failing Suite" do
+    JsTestServer::Client::Runner.run(:spec_url => "#{root_url}/specs/failing_spec")
+    stdout.string.strip.should include(JsTestServer::Client::FAILED_RUNNER_STATE.capitalize)
+    stdout.string.strip.should include("A failing spec fails: expected true to equal false")
+  end
+end

data/spec/functional_suite.rb

@@ -0,0 +1,16 @@
+class FunctionalSuite
+  def run(framework_name)
+    dir = File.dirname(__FILE__)
+    Dir["#{dir}/functional/#{framework_name}/**/*_spec.rb"].each do |file|
+      require file
+    end
+  end
+end
+
+["jasmine", "screw-unit"].each do |framework_name|
+  pid = fork do
+    FunctionalSuite.new.run(framework_name)
+  end
+  Process.wait(pid)
+  $?.success? || raise("#{framework_name} suite failed")
+end

data/spec/spec_helpers/be_http.rb

@@ -0,0 +1,32 @@
+module BeHttp
+  include Spec::Matchers
+  def be_http(status, headers, body)
+    SimpleMatcher.new(nil) do |given, matcher|
+      description = (<<-DESC).gsub(/^ +/, "")
+      be an http of
+      expected status: #{status.inspect}
+      actual status  : #{given.status.inspect}
+
+      expected headers containing: #{headers.inspect}
+      actual headers             : #{given.headers.inspect}
+
+      expected body containing: #{body.inspect}
+      actual body             : #{given.body.inspect}
+      DESC
+      matcher.failure_message = description
+      matcher.negative_failure_message = "not #{description}"
+
+      passed = true
+      unless given.status == status
+        passed = false
+      end
+      unless headers.all?{|k, v| given.headers[k] == headers[k]}
+        passed = false
+      end
+      unless body.is_a?(Regexp) ? given.body =~ body : given.body.include?(body)
+        passed = false
+      end
+      passed
+    end
+  end
+end