js_spec 0.3.1 → 0.3.2

data/vendor/js-test-core/spec/unit/js_test_core/resources/suite_spec.rb

@@ -0,0 +1,86 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../unit_spec_helper")
+
+module JsTestCore
+  module Resources
+    describe Suite do
+      describe "GET /suites/:suite_id" do
+        attr_reader :driver, :suite_id
+
+        context "when there is no Runner with the :suite_id" do
+          it "responds with a 404" do
+            suite_id = "invalid_suite_id"
+            Runner.find(suite_id).should be_nil
+
+            mock(connection).send_head(404)
+            mock(connection).send_body("")
+
+            connection.receive_data("GET /suites/#{suite_id} HTTP/1.1\r\nHost: _\r\n\r\n")
+          end
+        end
+
+        context "when there is a Runner with the :suite_id" do
+          attr_reader :suite_runner
+          before do
+            @driver = "Selenium Driver"
+            @suite_id = "DEADBEEF"
+            stub(Selenium::SeleniumDriver).new('localhost', 4444, '*firefox', 'http://0.0.0.0:8080') do
+              driver
+            end
+
+            stub(driver).start
+            stub(driver).session_id {suite_id}
+            connection_that_starts_firefox = create_connection
+            stub(connection_that_starts_firefox).send_head
+            stub(connection_that_starts_firefox).send_body
+            connection_that_starts_firefox.receive_data("POST /runners/firefox HTTP/1.1\r\nHost: _\r\nContent-Length: 0\r\n\r\n")
+            @suite_runner = Runner.find(suite_id)
+            suite_runner.should be_running
+          end
+
+          context "when a Runner with the :suite_id is running" do
+            it "responds with a 200 and status=running" do
+              mock(connection).send_head
+              mock(connection).send_body("status=#{Resources::Suite::RUNNING}")
+
+              connection.receive_data("GET /suites/#{suite_id} HTTP/1.1\r\nHost: _\r\n\r\n")
+            end
+          end
+
+          context "when a Runner with the :suite_id has completed" do
+            context "when the suite has a status of 'success'" do
+              before do
+                stub(driver).stop
+                suite_runner.finalize("")
+                suite_runner.should be_successful
+              end
+
+              it "responds with a 200 and status=success" do
+                mock(connection).send_head
+                mock(connection).send_body("status=#{Resources::Suite::SUCCESSFUL_COMPLETION}")
+
+                connection.receive_data("GET /suites/#{suite_id} HTTP/1.1\r\nHost: _\r\n\r\n")
+              end
+            end
+
+            context "when the suite has a status of 'failure'" do
+              attr_reader :reason
+              before do
+                stub(driver).stop
+                @reason = "Failure stuff"
+                suite_runner.finalize(reason)
+                suite_runner.should be_failed
+              end
+
+              it "responds with a 200 and status=failure and reason" do
+                mock(connection).send_head
+                mock(connection).send_body("status=#{Resources::Suite::FAILURE_COMPLETION}&reason=#{reason}")
+
+                connection.receive_data("GET /suites/#{suite_id} HTTP/1.1\r\nHost: _\r\n\r\n")
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/js-test-core/spec/unit/js_test_core/resources/web_root_spec.rb

@@ -0,0 +1,32 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../unit_spec_helper")
+
+module JsTestCore
+  module Resources
+    describe WebRoot do
+      attr_reader :web_root
+      before(:each) do
+        @web_root = WebRoot.new(:connection => connection, :public_path => public_path)
+      end
+
+      describe "GET /stylesheets" do
+        it "returns a page with a of files in the directory" do
+          mock(connection).send_head()
+          mock(connection).send_body(Regexp.new('<a href="example.css">example.css</a>'))
+
+          connection.receive_data("GET /stylesheets HTTP/1.1\r\nHost: _\r\n\r\n")
+        end
+      end
+
+      describe "GET /stylesheets/example.css" do
+        it "returns a page with a of files in the directory" do
+          path = "#{public_path}/stylesheets/example.css"
+          mock(connection).send_head(200, 'Content-Type' => "text/css", 'Content-Length' => ::File.size(path), 'Last-Modified' => ::File.mtime(path).rfc822)
+          mock(connection).send_data(::File.read(path))
+          stub(EventMachine).close_connection
+
+          connection.receive_data("GET /stylesheets/example.css HTTP/1.1\r\nHost: _\r\n\r\n")
+        end
+      end
+    end
+  end
+end

data/vendor/js-test-core/spec/unit/js_test_core/selenium_server_configuration_spec.rb

@@ -0,0 +1,49 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../unit_spec_helper")
+
+module JsTestCore
+  describe SeleniumServerConfiguration do
+    describe '#query_string' do
+      context "when not passed explicit options" do
+        it "defaults selenium_browser_start_command to '*firefox' and selenium_host to 'localhost' and selenium_port to 4444 and ignores spec_url" do
+          configuration = SeleniumServerConfiguration.new
+          configuration.query_string.should include("selenium_browser_start_command=#{CGI.escape("*firefox")}")
+          configuration.query_string.should include("selenium_host=localhost")
+          configuration.query_string.should include("selenium_port=4444")
+          configuration.query_string.should_not include("spec_url")
+        end
+      end
+
+      context "when passed explicit options" do
+        attr_reader :configuration, :selenium_browser_start_command, :selenium_host, :selenium_port, :spec_url
+        before do
+          @selenium_browser_start_command = "*iexplore"
+          @selenium_host = "google.com"
+          @selenium_port = "4332"
+          @spec_url = "http://foobar.com/foo"
+          @configuration = SeleniumServerConfiguration.new(
+            :selenium_browser_start_command => selenium_browser_start_command,
+            :selenium_host => selenium_host,
+            :selenium_port => selenium_port,
+            :spec_url => spec_url
+          )
+        end
+
+        it "sets the selenium_browser_start_command option" do
+          configuration.query_string.should include("selenium_browser_start_command=#{CGI.escape(selenium_browser_start_command)}")
+        end
+
+        it "sets the selenium_host option" do
+          configuration.query_string.should include("selenium_host=#{selenium_host}")
+        end
+
+        it "sets the selenium_port option" do
+          configuration.query_string.should include("selenium_port=#{selenium_port}")
+        end
+
+        it "sets the spec_url option" do
+          configuration.query_string.should include("spec_url=#{spec_url}")
+        end
+      end
+    end
+  end
+end

data/vendor/js-test-core/spec/unit/js_test_core/server_spec.rb

@@ -0,0 +1,117 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../unit_spec_helper")
+
+module JsTestCore
+  describe Server do
+    attr_reader :result
+    
+    before do
+      @result = ""
+      stub(EventMachine).send_data do |signature, data, data_length|
+        @result << data
+      end
+      stub(EventMachine).close_connection
+    end
+
+    describe ".run" do
+      attr_reader :server_instance
+      before do
+        @server_instance = Server.instance
+        Server.instance = nil
+      end
+
+      it "instantiates an instance of Server and starts a Rack Thin handler" do
+        host = DEFAULT_HOST
+        port = DEFAULT_PORT
+
+        mock(EventMachine).run.yields
+        mock(EventMachine).start_server(host, port, ::Thin::JsTestCoreConnection)
+
+        Server.run(spec_root_path, implementation_root_path, public_path)
+      end
+
+      it "when passed a custom host and port, sets the host and port to the passed in value" do
+        host = 'foobar.com'
+        port = 80
+
+        mock(EventMachine).run.yields
+        mock(EventMachine).start_server(host, port, ::Thin::JsTestCoreConnection)
+
+        Server.run(spec_root_path, implementation_root_path, public_path, {:Host => host, :Port => port})
+      end
+    end
+
+    describe ".spec_root" do
+      it "returns the Dir " do
+        Server.spec_root_path.should == spec_root_path
+      end
+    end
+
+    describe ".spec_root_path" do
+      it "returns the absolute path of the specs root directory" do
+        Server.spec_root_path.should == spec_root_path
+      end
+    end
+
+    describe ".public_path" do
+      it "returns the expanded path of the public path" do
+        Server.public_path.should == public_path
+      end
+    end
+
+    describe ".core_path" do
+      it "returns the expanded path to the JsTestCore core directory" do
+        Server.core_path.should == core_path
+      end
+    end
+
+    describe ".implementation_root_path" do
+      it "returns the expanded path to the JsTestCore implementations directory" do
+        dir = ::File.dirname(__FILE__)
+        Server.implementation_root_path.should == implementation_root_path
+      end
+    end
+
+    describe "#call" do
+      describe "when there is an error" do
+        attr_reader :top_line_of_backtrace
+        before do
+          @top_line_of_backtrace = __LINE__ + 2
+          stub.instance_of(Resources::WebRoot).locate('somedir') do
+            raise "Foobar"
+          end
+        end
+
+        it "shows the full request path in the error message" do
+          error = nil
+          mock(connection).log_error(is_a(Exception)) do |error_arg|
+            error = error_arg
+          end
+          
+          get('/somedir')
+          error.message.should =~ Regexp.new("/somedir")
+        end
+
+        it "uses the backtrace from where the original error was raised" do
+          error = nil
+          mock(connection).log_error(is_a(Exception)) do |error_arg|
+            error = error_arg
+          end
+
+          get('/somedir')
+          no_error = false
+          top_of_backtrace = error.backtrace.first.split(":")
+          backtrace_file = ::File.expand_path(top_of_backtrace[0])
+          backtrace_line = Integer(top_of_backtrace[1])
+          backtrace_file.should == __FILE__
+          backtrace_line.should == top_line_of_backtrace
+        end
+      end
+    end
+
+    describe "#root_url" do
+      it "returns the url of the site's root" do
+        server.root_url.should == "http://#{server.host}:#{server.port}"
+      end
+    end
+  end
+end

data/vendor/js-test-core/spec/unit/thin/js_test_core_connection_spec.rb

@@ -0,0 +1,6 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../unit_spec_helper")
+
+module Thin
+  describe JsTestCoreConnection do
+  end
+end

data/vendor/js-test-core/spec/unit/unit_spec_helper.rb

@@ -0,0 +1,134 @@
+require "rubygems"
+require "spec"
+
+dir = File.dirname(__FILE__)
+$LOAD_PATH.unshift File.expand_path("#{dir}/../../lib")
+require "js_test_core"
+require "hpricot"
+require "guid"
+
+Spec::Runner.configure do |config|
+  config.mock_with :rr
+end
+
+module Spec
+  module Matchers
+    class Exist
+      def matches?(actual)
+        @actual = actual
+        !@actual.nil?
+      end
+    end
+  end
+end
+
+class Spec::Example::ExampleGroup
+  class << self
+    def thin_logging
+      @thin_logging = true if @thin_logging.nil?
+      @thin_logging
+    end
+
+    attr_writer :thin_logging
+  end
+end
+
+class JsTestCoreTestDir < JsTestCore::Resources::Dir
+  def get
+
+  end
+end
+
+module Spec::Example::ExampleMethods
+  attr_reader :core_path, :spec_root_path, :implementation_root_path, :public_path, :server, :connection
+  before(:all) do
+    dir = File.dirname(__FILE__)
+    @core_path = File.expand_path("#{dir}/../example_core")
+    JsTestCore.core_path = core_path
+    @spec_root_path = File.expand_path("#{dir}/../example_specs")
+    @implementation_root_path = File.expand_path("#{dir}/../example_public/javascripts")
+    @public_path = File.expand_path("#{dir}/../example_public")
+  end
+
+  before(:each) do
+    JsTestCore::Server.instance = JsTestCore::Server.new(spec_root_path, implementation_root_path, public_path)
+    stub(EventMachine).run do
+      raise "You need to mock calls to EventMachine.run or the process will hang"
+    end
+    stub(EventMachine).start_server do
+      raise "You need to mock calls to EventMachine.start_server or the process will hang"
+    end
+    stub(EventMachine).send_data do
+      raise "Calls to EventMachine.send_data must be mocked or stubbed"
+    end
+    @connection = create_connection
+    stub(EventMachine).send_data {raise "EventMachine.send_data must be handled"}
+    stub(EventMachine).close_connection {raise "EventMachine.close_connection must be handled"}
+    @server = JsTestCore::Server.instance
+    Thin::Logging.silent = !self.class.thin_logging
+    Thin::Logging.debug = self.class.thin_logging
+  end
+
+  after(:each) do
+    JsTestCore::Resources::WebRoot.dispatch_strategy = nil
+    Thin::Logging.silent = true
+    Thin::Logging.debug = false
+  end
+
+  def create_connection(guid=Guid.new)
+    Thin::JsTestCoreConnection.new(Guid.new)
+  end
+
+  def get(url, params={})
+    request(:get, url, params)
+  end
+
+  def post(url, params={})
+    request(:post, url, params)
+  end
+
+  def put(url, params={})
+    request(:put, url, params)
+  end
+
+  def delete(url, params={})
+    request(:delete, url, params)
+  end
+
+  def env_for(method, url, params)
+    Rack::MockRequest.env_for(url, params.merge({:method => method.to_s.upcase, 'js_test_core.connection' => connection}))
+  end
+
+  def create_request(method, path, params={})
+    body = params.map do |key, value|
+      "#{URI.escape(key)}=#{URI.escape(value)}"
+    end.join("&")
+    connection.receive_data "#{method.to_s.upcase} #{path} HTTP/1.1\r\nHost: _\r\nContent-Length: #{body.length}\r\n\r\n#{body}"
+    connection.response
+  end
+  alias_method :request, :create_request
+
+  def spec_dir(relative_path="")
+    absolute_path = spec_root_path + relative_path
+    JsTestCore::Resources::Specs::SpecDir.new(:connection => connection, :absolute_path => absolute_path, :relative_path => "/specs#{relative_path}")
+  end
+
+  def contain_spec_file_with_correct_paths(path_relative_to_spec_root)
+    expected_absolute_path = spec_root_path + path_relative_to_spec_root
+    expected_relative_path = "/specs" + path_relative_to_spec_root
+
+    ::Spec::Matchers::SimpleMatcher.new(expected_relative_path) do |globbed_files|
+      file = globbed_files.find do |file|
+        file.absolute_path == expected_absolute_path
+      end
+      raise "Did not find file with absolute path of #{expected_absolute_path.inspect}" unless file
+      file.relative_path == expected_relative_path
+    end
+  end
+
+  def stub_send_data
+    stub(EventMachine).send_data do |signature, data, data_length|
+      data_length
+    end
+  end
+end

data/vendor/js-test-core/spec/unit_suite.rb

@@ -0,0 +1,10 @@
+class UnitSuite
+  def run
+    dir = File.dirname(__FILE__)
+    Dir["#{dir}/unit/**/*_spec.rb"].each do |file|
+      require file
+    end
+  end
+end
+
+UnitSuite.new.run

data/vendor/js-test-core/vendor/thin-rest/CHANGES

@@ -0,0 +1,2 @@
+- Resource.property creates a reader that reads directly from the env hash
+- Resource.property creates a writer that updates the env hash directly