js_test_core 0.1.1

data/spec/unit/js_spec/resources/suite_spec.rb

@@ -0,0 +1,44 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../unit_spec_helper")
+
+module JsTestCore
+  module Resources
+    describe Suite do
+    attr_reader :stdout
+    before do
+      @stdout = StringIO.new
+      Suite.const_set(:STDOUT, stdout)
+    end
+
+    after do
+      Suite.__send__(:remove_const, :STDOUT)
+    end
+
+    describe ".locate" do
+      it "when passed an identifier, returns an instance of Suite with the identifier" do
+        instance = Suite.locate('foobar')
+        instance.class.should == Suite
+        instance.id.should == 'foobar'
+      end
+    end
+
+    describe "#locate" do
+      attr_reader :suite
+      before do
+        @suite = Suite.new('foobar')
+      end
+
+      it "when passed 'finish', returns a SuiteFinish that has access to the suite" do
+        suite_finish = suite.locate('finish')
+        suite_finish.class.should == SuiteFinish
+        suite_finish.suite.should == suite
+      end
+
+      it "when not passed 'finish', raises ArgumentError" do
+        lambda do
+          suite.locate('invalid')
+        end.should raise_error(ArgumentError, "Invalid path: invalid")
+      end
+    end
+  end
+  end
+end

data/spec/unit/js_spec/resources/web_root_spec.rb

@@ -0,0 +1,67 @@
+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(public_path)
+      end
+
+      describe "#locate" do
+        it "when passed 'core', returns a Dir representing the JsTestCore core directory" do
+          runner = web_root.locate('core')
+          runner.should == Resources::Dir.new(JsTestCore::Server.core_path, '/core')
+        end
+
+        it "when passed 'implementations', returns a Dir representing the javascript implementations directory" do
+          runner = web_root.locate('implementations')
+          runner.should == Resources::Dir.new(JsTestCore::Server.implementation_root_path, '/implementations')
+        end
+
+        it "when passed 'results', returns a Suite" do
+          runner = web_root.locate('suites')
+          runner.should == Resources::Suite
+        end
+
+        it "when passed 'runners', returns a Runner" do
+          runner = web_root.locate('runners')
+          runner.should be_instance_of(Resources::Runners)
+        end
+
+        it "when passed a directory that is in the public_path, returns a Dir representing that directory" do
+          runner = web_root.locate('stylesheets')
+          runner.should == Resources::Dir.new("#{JsTestCore::Server.public_path}/stylesheets", '/stylesheets')
+        end
+
+        it "when passed a file that is in the public_path, returns a File representing that file" do
+          runner = web_root.locate('robots.txt')
+          runner.should == Resources::File.new("#{JsTestCore::Server.public_path}/robots.txt", '/robots.txt')
+        end
+
+        it "when not passed 'core' or 'specs', raises an error" do
+          lambda do
+            web_root.locate('invalid')
+          end.should raise_error
+        end
+      end
+
+      describe ".dispatch_specs" do
+        it "causes #locate /specs to dispatch to a Spec::SpecDir" do
+          WebRoot.dispatch_specs
+          
+          resource = web_root.locate('specs')
+          resource.should == spec_dir('')
+        end
+      end
+
+      describe "when .dispatch_specs is not called" do
+        it "does not cause #locate to dispatch to /specs" do
+          lambda do
+            web_root.locate('specs')
+          end.should raise_error
+        end
+      end
+    end
+  end
+end

data/spec/unit/js_spec/server_spec.rb

@@ -0,0 +1,131 @@
+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 "HTTP GET" do
+      specify "'/core/JsTestCore.js', returns the contents of the file" do
+        response = get("/core/JsTestCore.js")
+        response.body.should == ::File.read("#{Server.core_path}/JsTestCore.js")
+      end
+
+      specify "'/stylesheets/example.css', returns the contents of the file" do
+        response = get("/stylesheets/example.css")
+        response.body.should == ::File.read("#{Server.public_path}/stylesheets/example.css")
+      end
+
+      specify "'/invalid/path', shows the full invalid path in the error message" do
+        lambda do
+          get("/invalid/path")
+        end.should raise_error(Exception, Regexp.new("/invalid/path"))
+      end
+    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
+          lambda do
+            get('/somedir')
+          end.should raise_error(Exception, Regexp.new("/somedir"))
+        end
+
+        it "uses the backtrace from where the original error was raised" do
+          no_error = true
+          begin
+            get('/somedir')
+          rescue Exception => e
+            no_error = false
+            top_of_backtrace = e.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
+          raise "There should have been an error" if no_error
+        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/spec/unit/thin/js_test_core_connection_spec.rb

@@ -0,0 +1,92 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../unit_spec_helper")
+
+module Thin
+  describe JsTestCoreConnection do
+    describe "#process" do
+      attr_reader :connection, :result
+      before do
+        @connection = JsTestCoreConnection.new('signature')
+        stub(connection).socket_address {'0.0.0.0'}
+
+        @result = ""
+        stub(EventMachine).send_data do |signature, data, data_length|
+          result << data
+        end
+      end
+
+      describe "and the call is successful" do
+        describe "and the body is not empty" do
+          before do
+            mock(app = Object.new).call(is_a(Hash)) do
+              [200, {}, 'The Body']
+            end
+            connection.app = app
+          end
+
+          it "sends the response to the socket and closes the connection" do
+            mock(connection).close_connection_after_writing
+            connection.receive_data "GET /specs HTTP/1.1\r\nHost: _\r\n\r\n"
+            result.should include("The Body")
+          end
+        end
+
+        describe "and the body is empty" do
+          describe "and the Content-Length header is 0" do
+            before do
+              mock(app = Object.new).call(is_a(Hash)) do
+                [200, {"Content-Length" => '0'}, []]
+              end
+              connection.app = app
+            end
+
+            it "sends the response to the socket and closes the connection" do
+              mock(connection).close_connection_after_writing
+              connection.receive_data "GET /specs HTTP/1.1\r\nHost: _\r\n\r\n"
+            end
+          end
+
+          describe "and the Content-Length header is > 0" do
+            before do
+              mock(app = Object.new).call(is_a(Hash)) do
+                [200, {"Content-Length" => '55'}, []]
+              end
+              connection.app = app
+            end
+
+            it "keeps the connection open" do
+              dont_allow(connection).close_connection_after_writing
+              connection.receive_data "GET /specs HTTP/1.1\r\nHost: _\r\n\r\n"
+            end
+          end
+
+          describe "and the Content-Length header is not passed in" do
+            before do
+              mock(app = Object.new).call(is_a(Hash)) do
+                [200, {}, []]
+              end
+              connection.app = app
+            end
+
+            it "keeps the connection open" do
+              dont_allow(connection).close_connection_after_writing
+              connection.receive_data "GET /specs HTTP/1.1\r\nHost: _\r\n\r\n"
+            end
+          end
+        end
+      end
+
+      describe "and the call raises an error" do
+        it "logs the error and closes the connection" do
+          mock(app = Object.new).call(is_a(Hash)) do
+            raise "An Error"
+          end
+          connection.app = app
+          mock(connection).log(anything).at_least(1)
+          mock(connection).close_connection
+
+          connection.receive_data "GET /specs HTTP/1.1\r\nHost: _\r\n\r\n"
+        end
+      end
+    end
+  end
+end

data/spec/unit/unit_spec_helper.rb

@@ -0,0 +1,125 @@
+require "rubygems"
+require "spec"
+
+dir = File.dirname(__FILE__)
+$LOAD_PATH.unshift "#{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(request, response)
+
+  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 = Thin::JsTestCoreConnection.new(Guid.new)
+    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 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, url, params={})
+    env = env_for(method, url, params)
+    server.call(env)[2]
+  end
+  alias_method :request, :create_request
+
+  def spec_file(relative_path)
+    absolute_path = spec_root_path + relative_path
+    JsTestCore::Resources::File.new(absolute_path, "/specs#{relative_path}")
+  end
+
+  def spec_dir(relative_path="")
+    absolute_path = spec_root_path + relative_path
+    JsTestCore::Resources::Specs::SpecDir.new(absolute_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
+      file && file.relative_path == expected_relative_path
+    end
+  end
+end