js_spec 0.0.1 → 0.1.0

data/CHANGES

@@ -1,2 +1,6 @@
+0.1.0
+- Added RailsServer
+- Better namespacing
+
 0.0.1
-* Initial Release
+- Initial Release

data/Rakefile

@@ -26,7 +26,7 @@ def run_suite
 end
 
 PKG_NAME = "js_spec"
-PKG_VERSION = "0.0.1"
+PKG_VERSION = "0.1.0"
 PKG_FILES = FileList[
   '[A-Z]*',
   '*.rb',
@@ -39,7 +39,7 @@ PKG_FILES = FileList[
 spec = Gem::Specification.new do |s|
   s.name = PKG_NAME
   s.version = PKG_VERSION
-  s.summary = "JsSpec is a server for the JSSpec javascript framework."
+  s.summary = "The JSSpec client library (http://code.google.com/p/jsspec/) plus a convenient ruby server."
   s.test_files = "spec/spec_suite.rb"
   s.description = s.summary
 
@@ -69,4 +69,4 @@ def tag_release
   dashed_version = PKG_VERSION.gsub('.', '-')
   svn_user = "#{ENV["SVN_USER"]}@" || ""
   `svn cp svn+ssh://#{svn_user}rubyforge.org/var/svn/pivotalrb/js_spec/trunk svn+ssh://#{svn_user}rubyforge.org/var/svn/pivotalrb/js_spec/tags/REL-#{dashed_version} -m 'Version #{PKG_VERSION}'`
-end
+end

data/bin/js_spec

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+dir = File.dirname(__FILE__)
+$LOAD_PATH.unshift("#{dir}/../lib")
+require "js_spec"
+require "net/http"
+
+response = Net::HTTP.start(JsSpec::Server::DEFAULT_HOST, JsSpec::Server::DEFAULT_PORT) do |http|
+  http.post('/runners/firefox', {})
+end

data/bin/js_spec_server

@@ -6,4 +6,5 @@ require "js_spec"
 
 spec_root_path = ARGV[0] || raise("You need to pass in a spec root")
 implementation_root_path = ARGV[1] || raise("You need to pass in an implementation root")
-JsSpec::Server.run(spec_root_path, implementation_root_path)
+public_path = ARGV[2] || raise("You need to pass in a public path")
+JsSpec::Server.run(spec_root_path, implementation_root_path, public_path)

data/core/JSSpec.js

@@ -455,8 +455,9 @@ JSSpec.Logger.prototype.onRunnerStart = function() {
 	var title = document.createElement("DIV");
 	title.id = "title";
 	title.innerHTML = [
-		'<h1>JSSpec runner</h1>',
+		'<h1>JSSpec</h1>',
 		'<ul>',
+		JSSpec.options.rerun ? '<li>[<a href="?" title="rerun all specs">X</a>] ' + JSSpec.util.escapeTags(decodeURIComponent(JSSpec.options.rerun)) + '</li>' : '',
 		'	<li><span id="total_examples">' + JSSpec.runner.totalExamples + '</span> examples</li>',
 		'	<li><span id="total_failures">0</span> failures</li>',
 		'	<li><span id="total_errors">0</span> errors</li>',
@@ -645,15 +646,20 @@ JSSpec.IncludeMatcher.prototype.makeExplain = function() {
 };
 
 JSSpec.IncludeMatcher.prototype.makeExplainForNotArray = function() {
+	if(this.condition) {
+		this.match = !!this.actual[this.expected];
+	} else {
+		this.match = !this.actual[this.expected];
+	}
+	
 	var sb = [];
 	sb.push('<p>actual value:</p>');
-	sb.push('<p style="margin-left:2em;">' + JSSpec.util.inspect(this.actual) + '</p>');
+	sb.push('<p style="margin-left:2em;">' + JSSpec.util.inspect(this.actual, false, this.expected) + '</p>');
 	sb.push('<p>should ' + (this.condition ? '' : 'not') + ' include:</p>');
 	sb.push('<p style="margin-left:2em;">' + JSSpec.util.inspect(this.expected) + '</p>');
-	sb.push('<p>but since it\s not an array, include or not doesn\'t make any sense.</p>');
 	return sb.join("");
-}
-;
+};
+
 JSSpec.IncludeMatcher.prototype.makeExplainForArray = function() {
 	var matches;
 	if(this.condition) {

data/core/JSSpecExtensions.js

@@ -1,27 +1,146 @@
 var Require = {
   require: function(path_from_javascripts) {
     if(!Require.required_paths[path_from_javascripts]) {
-      var full_path = path_from_javascripts + ".js?" + Require.cache_buster;
+      var full_path = path_from_javascripts + ".js";
+      if (Require.use_cache_buster) {
+        full_path += '?' + Require.cache_buster;
+      }
       document.write("<script src='" + full_path + "' type='text/javascript'></script>");
       Require.required_paths[path_from_javascripts] = true;
     }
   },
 
   required_paths: {},
+  use_cache_buster: true, // TODO: NS/CTI - make this configurable from the UI.
   cache_buster: parseInt(new Date().getTime()/(1*1000))
 }
-
 var require = Require.require;
 
+var URL_REGEX = /^((\w+):\/\/)(([^:]+):?([^@]+)?@)?([^\/\?:]*):?(\d+)?(\/?[^\?#]+)?\??([^#]+)?#?(.+)?/;
+function parse_url(url) {
+    var fields = ['url', null, 'protocol', null, 'username', 'password', 'host', 'port', 'pathname', 'search', 'hash'];
+    var result = URL_REGEX.exec(url);
+    if (!result) {
+        throw new SeleniumError("Invalid URL: " + url);
+    }
+    var loc = new Object();
+    for (var i = 0; i < fields.length; i++) {
+        var field = fields[i];
+        if (field == null) {
+            continue;
+        }
+        loc[field] = result[i];
+    }
+    return loc;
+}
+
 JSSpec.Logger.prototype.onRunnerEndWithoutServerNotification = JSSpec.Logger.prototype.onRunnerEnd;
 JSSpec.Logger.prototype.onRunnerEndWithServerNotification = function() {
   this.onRunnerEndWithoutServerNotification();
-  $.ajax({
+  var data = {
+    'text': this.get_error_message_text()
+  };
+
+  current_location_params = parse_url(window.location.href);
+  if(current_location_params.guid) {
+    data.guid = current_location_params.guid;
+  }
+  jQuery.realAjax({
     type: 'POST',
-    url: '/results',
-    data: {
-      'text': "---------------------------------------------------------------------------------------\n\n+++++++++++++++++++++++++++++++++++++"
+    url: '/suites/1/finish',
+    data: data
+  });
+}
+JSSpec.Logger.prototype.onRunnerEnd = JSSpec.Logger.prototype.onRunnerEndWithServerNotification;
+
+JSSpec.Logger.prototype.get_error_message_text = function() {
+  var error_messages = [];
+  for(var i=0; i < JSSpec.specs.length; i++) {
+    var spec = JSSpec.specs[i];
+    if(spec.hasException()) {
+      for(var j=0; j < spec.getExamples().length; j++) {
+        var example = spec.getExamples()[j];
+        var error_message = spec.context + " " + example.name;
+        if (example.exception) {
+          error_message += "\n" + example.exception.message + "\n" + example.exception.fileName + ":" + example.exception.lineNumber;
+        }
+        error_messages.push(error_message);
+      }
+    }
+  }
+
+  var full_error_text = error_messages.join("\n");
+  full_error_text = full_error_text.replace(/<\/p>/g, "\n");
+  full_error_text = full_error_text.replace(/<(.|\n)*?>/g, "");
+  return full_error_text;
+}
+
+// Custom Matchers
+
+JSSpec.DSL.Subject.prototype.should_be_disabled = function() {
+  if (!this.target.disabled) {
+    JSSpec._assertionFailure = {message: "Element " + JSSpec.util.inspect(this.target) + " should have been disabled"};
+    throw JSSpec._assertionFailure;
+  }
+};
+
+JSSpec.DSL.Subject.prototype.should_be_enabled = function() {
+  if (this.target.disabled) {
+    JSSpec._assertionFailure = {message: "Element " + JSSpec.util.inspect(this.target) + " should have been enabled"};
+    throw JSSpec._assertionFailure;
+  }
+};
+
+JSSpec.DSL.Subject.prototype.should_raise = function(expected) {
+  if("function" != typeof(this.target)) {
+    JSSpec._assertionFailure = {message: 'should_raise expects value_of(target) to have a target that is a function'};
+    throw JSSpec._assertionFailure;
+  }
+
+  var raised = false;
+  try {
+    this.target();
+  }
+  catch(e) {
+    if (expected == null || expected == e) {
+      raised = true;
+    }
+  }
+  if(!raised) {
+    var message = "should have raised an error but didn't";
+    if(expected) {
+      message = "should have raised '" + expected + "' but didn't";
     }
-  });  
+    JSSpec._assertionFailure = {message: message};
+    throw JSSpec._assertionFailure;
+  }
 }
-JSSpec.Logger.prototype.onRunnerEnd = JSSpec.Logger.prototype.onRunnerEndWithServerNotification;
+
+JSSpec.DSL.Subject.prototype.should_not_raise = function(expected) {
+  if("function" != typeof(this.target)) {
+    JSSpec._assertionFailure = {message: 'should_not_raise expects value_of(target) to have a target that is a function'};
+    throw JSSpec._assertionFailure;
+  }
+
+  var raised = false;
+  try {
+    this.target();
+  }
+  catch(e) {
+    if (expected == null || expected == e) {
+      raised = true;
+    }
+  }
+  if(raised) {
+    var message = "should not have raised an error but did";
+    if(expected) {
+      message = "should not have raised '" + expected + "' but did";
+    }
+    JSSpec._assertionFailure = {message: message};
+    throw JSSpec._assertionFailure;
+  }
+}
+
+
+
+

data/core/demo.html

@@ -44,7 +44,10 @@ describe('"Should include"s', {
 		value_of(new Date()).should_include(4);
 	},
 	'Should not include / Non-array object': function() {
-		value_of(new Date()).should_not_include(4);
+		value_of(new Date()).should_not_include('getMonth');
+	},
+	'Should include 2': function() {
+		value_of({a:1, b:2}).should_not_include('a');
 	}
 })
 
@@ -69,6 +72,10 @@ describe('"Should have"s', {
 	},
 	'At most': function() {
 		value_of([1,2,3]).should_have_at_most(2, "items");
+	},
+	'Member': function() {
+		value_of({x: 0}).should_have_member('x'); // true
+		value_of({x: 0}).should_have_member('y'); // false
 	}
 })
 describe('"Should be empty"s', {

data/lib/js_spec/rails_server.rb

@@ -0,0 +1,22 @@
+module JsSpec
+  class RailsServer < Server
+    class << self
+      def run(rails_root, server_options = {})
+        server_options[:Host] ||= Server::DEFAULT_HOST
+        server_options[:Port] ||= Server::DEFAULT_PORT
+        Server.instance = new(rails_root, server_options[:Host], server_options[:Port])
+        Rack::Handler::Mongrel.run(Server.instance, server_options)
+      end
+    end
+
+    def initialize(rails_root, host=DEFAULT_HOST, port=DEFAULT_PORT)
+      super(
+        "#{rails_root}/spec/javascripts",
+        "#{rails_root}/public/javascripts",
+        "#{rails_root}/public",
+        host,
+        port
+      )
+    end
+  end
+end

data/lib/js_spec/{dir.rb → resources/dir.rb}

@@ -1,5 +1,6 @@
 module JsSpec
-  class Dir < File
+  module Resources
+    class Dir < File
     def locate(name)
       if file = file(name)
         file
@@ -22,8 +23,8 @@ module JsSpec
 
     protected
     def determine_child_paths(name)
-      absolute_child_path = ::File.expand_path("#{absolute_path}/#{name}")
-      relative_child_path = ::File.expand_path("#{relative_path}/#{name}")
+      absolute_child_path = "#{absolute_path}/#{name}"
+      relative_child_path = "#{relative_path}/#{name}"
       [absolute_child_path, relative_child_path]
     end
 
@@ -40,7 +41,7 @@ module JsSpec
     def file(name)
       absolute_file_path, relative_file_path = determine_child_paths(name)
       if ::File.exists?(absolute_file_path) && !::File.directory?(absolute_file_path)
-        JsSpec::File.new(absolute_file_path, relative_file_path)
+        Resources::File.new(absolute_file_path, relative_file_path)
       else
         nil
       end
@@ -49,10 +50,11 @@ module JsSpec
     def subdir(name)
       absolute_dir_path, relative_dir_path = determine_child_paths(name)
       if ::File.directory?(absolute_dir_path)
-        JsSpec::Dir.new(absolute_dir_path, relative_dir_path)
+        Resources::Dir.new(absolute_dir_path, relative_dir_path)
       else
         nil
       end
     end
   end
+  end
 end

data/lib/js_spec/{file.rb → resources/file.rb}

@@ -1,12 +1,17 @@
 module JsSpec
-  class File
+  module Resources
+    class File
     MIME_TYPES = {
       '.js' => 'text/javascript',
       '.css' => 'text/css',
+      '.png' => 'image/png',
+      '.jpg' => 'image/jpeg',
+      '.jpeg' => 'image/jpeg',
+      '.gif' => 'image/gif',
     }
 
     attr_reader :absolute_path, :relative_path
-    
+
     def initialize(absolute_path, relative_path)
       @absolute_path = absolute_path
       @relative_path = relative_path
@@ -19,8 +24,9 @@ module JsSpec
     end
 
     def ==(other)
-      return false unless other.is_a?(File)
+      return false unless other.class == self.class
       absolute_path == other.absolute_path && relative_path == other.relative_path
     end
   end
+  end
 end

data/lib/js_spec/resources/runners/firefox_runner.rb

@@ -0,0 +1,90 @@
+module JsSpec
+  module Resources
+    class Runners
+    class FirefoxRunner
+      class << self
+        def resume(guid, text)
+          responses[guid] = text
+          threads[guid].kill
+        end
+
+        def threads
+          @threads ||= {}
+        end
+
+        def response_value(guid)
+          responses[guid]
+        ensure
+          responses.delete guid
+        end
+
+        protected
+        def responses
+          @responses ||= {}
+        end
+      end
+
+      include FileUtils
+      attr_reader :profile_dir
+
+      def initialize
+        profile_base = "#{::Dir.tmpdir}/js_spec/firefox"
+        mkdir_p profile_base
+        @profile_dir = "#{profile_base}/#{Time.now.to_i}"
+      end
+
+      def post
+        copy_profile_files
+        create_profile
+        wait_for_full_profile_to_be_created
+
+        guid = UUID.new
+        start_browser guid
+        thread = Thread.start {sleep}
+        self.class.threads[guid] = thread
+        thread.join
+
+        self.class.response_value guid
+      end
+
+      protected
+      def copy_profile_files
+        dir = ::File.dirname(__FILE__)
+        firefox_profile_path = ::File.expand_path("#{dir}/../../../../resources/firefox")
+        system("cp -R #{firefox_profile_path} #{profile_dir}") || raise("Copying Firefox profile failed")
+      end
+
+      def create_profile
+        system("firefox -profile #{profile_dir} -chrome chrome://killff/content/kill.html") || raise("Initializing profile failed")
+      end
+
+      def wait_for_full_profile_to_be_created
+        Timeout.timeout(5) do
+          wait_for_file_lock_to_go_away
+        end
+      end
+
+      def start_browser(guid)
+        Thread.start do
+          system("firefox -profile #{profile_dir} http://localhost:8080/specs?guid=#{guid}") || raise("Starting Firefox failed")
+        end
+      end
+
+      def wait_for_file_lock_to_go_away
+        loop do
+          return if lock_is_gone? && lock_remains_gone?
+        end
+      end
+
+      def lock_is_gone?
+        !::File.exists?("#{profile_dir}/parent.lock")
+      end
+
+      def lock_remains_gone?
+        sleep 0.5
+        lock_is_gone?
+      end
+    end
+  end
+  end
+end

data/lib/js_spec/resources/runners.rb

@@ -0,0 +1,16 @@
+dir = File.dirname(__FILE__)
+require File.expand_path("#{dir}/runners/firefox_runner")
+
+module JsSpec
+  module Resources
+    class Runners
+    def locate(name)
+      if name == 'firefox'
+        FirefoxRunner.new
+      else
+        raise "Invalid path #{name}"
+      end
+    end
+  end
+  end
+end

data/lib/js_spec/{spec_dir_runner.rb → resources/spec_dir_runner.rb}

@@ -1,13 +1,15 @@
 module JsSpec
-  class SpecDirRunner < SpecRunner
+  module Resources
+    class SpecDirRunner < SpecRunner
     attr_reader :dir
-    
+
     def initialize(dir)
       @dir = dir
     end
-    
+
     def spec_files
       dir.glob("/**/*_spec.js")
     end
   end
+  end
 end

data/lib/js_spec/{spec_file_runner.rb → resources/spec_file_runner.rb}

@@ -1,7 +1,8 @@
 module JsSpec
-  class SpecFileRunner < SpecRunner
+  module Resources
+    class SpecFileRunner < SpecRunner
     attr_reader :file
-    
+
     def initialize(file)
       @file = file
     end
@@ -10,4 +11,5 @@ module JsSpec
       [file]
     end
   end
+  end
 end

data/lib/js_spec/{spec_runner.rb → resources/spec_runner.rb}

@@ -1,5 +1,6 @@
 module JsSpec
-  class SpecRunner
+  module Resources
+    class SpecRunner
     def get
       html = <<-HTML
         <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
@@ -24,4 +25,5 @@ module JsSpec
       html.gsub(/^        /, "")
     end
   end
+  end
 end

data/lib/js_spec/resources/suite.rb

@@ -0,0 +1,24 @@
+module JsSpec
+  module Resources
+    class Suite
+    class << self
+      def locate(id)
+        new id
+      end
+    end
+
+    attr_reader :id
+    def initialize(id)
+      @id = id
+    end
+
+    def locate(name)
+      if name == 'finish'
+        SuiteFinish.new self
+      else
+        raise ArgumentError, "Invalid path: #{name}"
+      end
+    end
+  end
+  end
+end

data/lib/js_spec/resources/suite_finish.rb

@@ -0,0 +1,20 @@
+module JsSpec
+  module Resources
+    class SuiteFinish
+    attr_reader :suite
+    def initialize(suite)
+      @suite = suite
+    end
+
+    def post
+      guid = Server.request['guid']
+      if guid
+        Runners::FirefoxRunner.resume(guid, Server.request['text'])
+      else
+        STDOUT.puts Server.request['text']
+      end
+      ""
+    end
+  end
+  end
+end

data/lib/js_spec/resources/web_root.rb

@@ -0,0 +1,34 @@
+module JsSpec
+  module Resources
+    class WebRoot
+      attr_reader :public_path
+      def initialize(public_path)
+        @public_path = ::File.expand_path(public_path)
+      end
+
+      def locate(name)
+        case name
+        when 'specs'
+          Resources::Dir.new(JsSpec::Server.spec_root_path, "/specs")
+        when 'core'
+          Resources::Dir.new(JsSpec::Server.core_path, "/core")
+        when 'implementations'
+          Resources::Dir.new(JsSpec::Server.implementation_root_path, "/implementations")
+        when 'suites'
+          Resources::Suite
+        when 'runners'
+          Resources::Runners.new
+        else
+          potential_file_in_public_path = "#{public_path}/#{name}"
+          if ::File.directory?(potential_file_in_public_path)
+            Resources::Dir.new(potential_file_in_public_path, "/#{name}")
+          elsif ::File.exists?(potential_file_in_public_path)
+            Resources::File.new(potential_file_in_public_path, "/#{name}")
+          else
+            raise "Invalid path: #{name}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/js_spec/server.rb

@@ -6,27 +6,33 @@ module JsSpec
     class << self
       attr_accessor :instance
 
-      def run(spec_root_path, implementation_root_path, server_options = {})
+      def run(spec_root_path, implementation_root_path, public_path, server_options = {})
         server_options[:Host] ||= DEFAULT_HOST
         server_options[:Port] ||= DEFAULT_PORT
-        @instance = new(spec_root_path, implementation_root_path, server_options[:Host], server_options[:Port])
+        @instance = new(spec_root_path, implementation_root_path, public_path, server_options[:Host], server_options[:Port])
         Rack::Handler::Mongrel.run(instance, server_options)
       end
 
+      def default_url
+        "http://#{DEFAULT_HOST}:#{DEFAULT_PORT}"
+      end
+
       def spec_root_path; instance.spec_root_path; end
       def implementation_root_path; instance.implementation_root_path; end
+      def public_path; instance.public_path; end
       def core_path; instance.core_path; end
       def request; instance.request; end
       def response; instance.response; end
     end
 
-    attr_reader :host, :port, :spec_root_path, :implementation_root_path, :core_path
+    attr_reader :host, :port, :spec_root_path, :implementation_root_path, :core_path, :public_path
 
-    def initialize(spec_root_path, implementation_root_path, host=DEFAULT_HOST, port=DEFAULT_PORT)
+    def initialize(spec_root_path, implementation_root_path, public_path, host=DEFAULT_HOST, port=DEFAULT_PORT)
       dir = ::File.dirname(__FILE__)
       @core_path = ::File.expand_path("#{dir}/../../core")
       @spec_root_path = ::File.expand_path(spec_root_path)
       @implementation_root_path = ::File.expand_path(implementation_root_path)
+      @public_path = ::File.expand_path(public_path)
       @host = host
       @port = port
     end
@@ -44,7 +50,7 @@ module JsSpec
     
     def run(path)
       system(%{firefox "http://#{host}:#{port}/#{path}"})
-      SuiteResult.new
+      Suite.new
     end
 
     def request
@@ -69,9 +75,13 @@ module JsSpec
     end
 
     def get_resource
-      path_parts.inject(WebRoot.new) do |resource, child_resource_name|
+      path_parts.inject(Resources::WebRoot.new(public_path)) do |resource, child_resource_name|
         resource.locate(child_resource_name)
       end
+    rescue Exception => e
+      detailed_exception = Exception.new("Error handling path #{request.path_info}\n#{e.message}")
+      detailed_exception.set_backtrace(e.backtrace)
+      raise detailed_exception
     end
   end
 end