screw-unit 0.3.3 → 0.5.1

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

@@ -1,82 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../../unit_spec_helper")
-
-module JsTestCore
-  module Resources
-    describe Session do
-      describe "GET /sessions/:session_id" do
-        attr_reader :driver, :session_id
-
-        context "when there is no Runner with the :session_id" do
-          it "responds with a 404" do
-            session_id = "invalid_session_id"
-            Runner.find(session_id).should be_nil
-
-            mock(connection).send_head(404)
-            mock(connection).send_body("")
-
-            connection.receive_data("GET /sessions/#{session_id} HTTP/1.1\r\nHost: _\r\n\r\n")
-          end
-        end
-
-        context "when there is a Runner with the :session_id" do
-          attr_reader :session_runner
-          before do
-            @driver = FakeSeleniumDriver.new
-            @session_id = FakeSeleniumDriver::SESSION_ID
-            stub(Selenium::SeleniumDriver).new('localhost', 4444, '*firefox', 'http://0.0.0.0:8080') do
-              driver
-            end
-
-            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")
-            @session_runner = Runner.find(session_id)
-            session_runner.should be_running
-          end
-
-          context "when a Runner with the :session_id is running" do
-            it "responds with a 200 and status=running" do
-              mock(connection).send_head
-              mock(connection).send_body("status=#{Resources::Session::RUNNING}")
-
-              connection.receive_data("GET /sessions/#{session_id} HTTP/1.1\r\nHost: _\r\n\r\n")
-            end
-          end
-
-          context "when a Runner with the :session_id has completed" do
-            context "when the session has a status of 'success'" do
-              before do
-                session_runner.finalize("")
-                session_runner.should be_successful
-              end
-
-              it "responds with a 200 and status=success" do
-                mock(connection).send_head
-                mock(connection).send_body("status=#{Resources::Session::SUCCESSFUL_COMPLETION}")
-
-                connection.receive_data("GET /sessions/#{session_id} HTTP/1.1\r\nHost: _\r\n\r\n")
-              end
-            end
-
-            context "when the session has a status of 'failure'" do
-              attr_reader :reason
-              before do
-                @reason = "Failure stuff"
-                session_runner.finalize(reason)
-                session_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::Session::FAILURE_COMPLETION}&reason=#{reason}")
-
-                connection.receive_data("GET /sessions/#{session_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/specs/spec_dir_spec.rb

@@ -1,105 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../../../unit_spec_helper")
-
-module JsTestCore
-  module Resources
-    module Specs
-      describe SpecDir do
-        attr_reader :dir, :absolute_path, :relative_path
-        before do
-          @absolute_path = spec_root_path
-          @relative_path = "/specs"
-          @dir = Resources::Specs::SpecDir.new(:connection => connection, :absolute_path => absolute_path, :relative_path => relative_path)
-        end
-
-        describe "#locate" do
-          context "when passed the name with an extension" do
-            context "when file exists" do
-              it "returns a Resources::File representing it" do
-                file = dir.locate("failing_spec.js")
-                file.relative_path.should == "/specs/failing_spec.js"
-                file.absolute_path.should == "#{spec_root_path}/failing_spec.js"
-              end
-            end
-
-            context "when file does not exist" do
-              it "raises error" do
-                lambda { dir.locate("nonexistent.js") }.should raise_error
-              end
-            end
-          end
-
-          context "when passed a name without an extension" do
-            context "when name corresponds to a subdirectory" do
-              it "returns a DirectoryRunner for the directory" do
-                subdir = dir.locate("foo")
-                subdir.should == spec_dir("/foo")
-              end
-            end
-
-            context "when name corresponds to a .js file" do
-              it "returns a SpecFile for the .js file" do
-                spec_file_name = "failing_spec"
-                subdir = dir.locate(spec_file_name)
-                subdir.should == JsTestCore::Resources::Specs::SpecFile.new(
-                  :connection => connection,
-                  :absolute_path => "#{spec_root_path}/#{spec_file_name}.js",
-                  :relative_path => "/specs/#{spec_file_name}.js"
-                )
-              end
-            end
-
-            context "when name does not correspond to a .js file or directory" do
-              it "raises an error" do
-                lambda do
-                  dir.locate("nonexistent")
-                end.should raise_error
-              end
-            end
-          end
-        end
-
-        describe "#get" do
-          attr_reader :request, :response
-          before do
-            @request = Rack::Request.new( Rack::MockRequest.env_for('/core') )
-            @response = Rack::Response.new
-          end
-
-          it "raises NotImplementedError" do
-            lambda do
-              dir.get
-            end.should raise_error(NotImplementedError)
-          end
-
-          it "can be overridden from a Module without needing to redefine the #get method" do
-            spec_dir_class = Resources::Specs::SpecDir.clone
-            mod = Module.new do
-              def get
-              end
-            end
-            spec_dir_class.class_eval do
-              include mod
-            end
-            @dir = spec_dir_class.new(:connection => connection, :absolute_path => absolute_path, :relative_path => relative_path)
-
-            lambda do
-              dir.get
-            end.should_not raise_error
-          end
-        end
-
-        describe "GET /" do
-          context "when WebRoot.dispatch_specs has been invoked" do
-            it "renders a home page" do
-              WebRoot.dispatch_specs
-              mock(connection).send_head(200, :Location => '/specs')
-              mock(connection).send_body(is_a(String))
-
-              connection.receive_data("GET / HTTP/1.1\r\nHost: _\r\n\r\n")
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,42 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../../../unit_spec_helper")
-
-module JsTestCore
-  module Resources
-    module Specs
-      describe SpecFile do
-        attr_reader :file, :absolute_path, :relative_path, :request, :response
-        before do
-          @absolute_path = "#{spec_root_path}/failing_spec.js"
-          @relative_path = "/specs/failing_spec.js"
-          @file = Resources::Specs::SpecFile.new(:connection => connection, :absolute_path => absolute_path, :relative_path => relative_path)
-          @request = Rack::Request.new( Rack::MockRequest.env_for(relative_path) )
-          @response = Rack::Response.new
-        end
-
-        describe "#get" do
-          it "raises NotImplementedError" do
-            lambda do
-              file.get
-            end.should raise_error(NotImplementedError)
-          end
-
-          it "can be overridden from a Module without needing to redefine the #get method" do
-            spec_file_class = Resources::Specs::SpecFile.clone
-            mod = Module.new do
-              def get
-              end
-            end
-            spec_file_class.class_eval do
-              include mod
-            end
-            @file = spec_file_class.new(:connection => connection, :absolute_path => absolute_path, :relative_path => relative_path)
-
-            lambda do
-              file.get
-            end.should_not raise_error
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,117 +0,0 @@
-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

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

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

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

data/vendor/js-test-core/vendor/thin-rest/lib/thin_rest.rb

@@ -1,9 +0,0 @@
-require "rubygems"
-require "thin"
-
-dir = File.dirname(__FILE__)
-require "#{dir}/thin_rest/connection"
-require "#{dir}/thin_rest/resource"
-require "#{dir}/thin_rest/resource_invalid"
-require "#{dir}/thin_rest/routing_error"
-require "#{dir}/thin_rest/extensions"

data/vendor/js-test-core/vendor/thin-rest/lib/thin_rest/connection.rb

@@ -1,116 +0,0 @@
-module ThinRest
-  class Connection < Thin::Connection
-    attr_reader :resource, :rack_request
-
-    def process
-      guard_against_errors do
-        method = rack_request.request_method.downcase.to_sym
-        @resource = get_resource
-        resource.send(method)
-      end
-    end
-
-    def rack_request
-      @rack_request ||= Rack::Request.new(@request.env)
-    end
-
-    def send_head(status=200, additional_parameters={})
-      send_data(head(status, additional_parameters))
-    end
-
-    def head(status, additional_parameters)
-      parameters = {}
-      parameters['Connection'] = "close" unless request.persistent?
-      parameters.merge!(additional_parameters)
-      head_output = parameters.inject("HTTP/1.1 #{status} OK\r\nServer: Thin Rest Server\r\n") do |header, parameter|
-        header << "#{parameter[0]}: #{parameter[1]}\r\n"
-      end
-      if additional_parameters[:'Content-Length'] || additional_parameters['Content-Length']
-        head_output << "\r\n"
-      end
-      head_output
-    end
-
-    def send_body(data)
-      terminate_after_sending do
-        send_data("Content-Length: #{data.length}\r\n\r\n")
-        send_data(data)
-      end
-    end
-
-    def terminate_after_sending
-      yield
-      unless request.persistent?
-        close_connection_after_writing
-      end
-    ensure
-      terminate_request
-    end
-
-    def unbind
-      super
-      resource.unbind if resource
-    rescue Exception => e
-      handle_error e
-    end
-
-    def terminate_request
-      persistent = persistent?
-      @resource = nil
-      @rack_request = nil
-      @request.close  rescue nil
-      @response.close rescue nil
-
-      # Prepare the connection for another request if the client
-      # supports HTTP pipelining (persistent connection).
-      if persistent
-        post_init
-      end
-    end
-
-    def persistent?
-      request.persistent?
-    end
-
-    def handle_error(error)
-      log_error error
-      close_connection rescue nil
-    rescue Exception => unexpected_error
-      log_error unexpected_error
-    end
-
-    protected
-    def guard_against_errors
-      yield
-    rescue RoutingError => e
-      handle_error e
-    rescue Exception => e
-      wrapped_error = Exception.new("Error in #{rack_request.path_info} : #{e.message}")
-      wrapped_error.set_backtrace(e.backtrace)
-      handle_error wrapped_error
-    end
-
-    def get_resource
-      path_parts.inject(root_resource) do |resource, child_resource_name|
-        resource.locate(child_resource_name)
-      end
-    end
-
-    def root_resource
-      raise NotImplementedError
-    end
-
-    def path_parts
-      rack_request.path_info.split('/').reject { |part| part == "" }
-    end
-
-    def error_message(e)
-      output = "Error in Connection#receive_line\n"
-      output << "#{e.message}\n"
-      output << e.backtrace.join("\n\t")
-      output << "\n\nResource was:\n\t"
-      output << "#{resource.inspect}\n"
-      output
-    end
-  end
-end