pivotal-screw-unit 0.4.3 → 0.5.0

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

@@ -1,205 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../thin_rest_spec_helper")
-
-module ThinRest
-  describe Connection do
-    describe "#process" do
-      attr_reader :result
-      before do
-        stub(connection).socket_address {'0.0.0.0'}
-
-        @result = ""
-        stub(EventMachine).send_data do |signature, data, data_length|
-          result << data
-        end
-      end
-
-      context "when the call is successful" do
-        context "when the request has Connection: close" do
-          it "sends the response to the socket with a Connection: close response header" do
-            mock(connection).close_connection_after_writing
-            connection.receive_data "GET /subresource HTTP/1.1\r\nConnection: close\r\nHost: _\r\n\r\n"
-            result.should include("GET response")
-            result.should include("Connection: close")
-          end
-
-          it "closes the connection" do
-            mock(connection).close_connection_after_writing
-            connection.receive_data "GET /subresource HTTP/1.1\r\nConnection: close\r\nHost: _\r\n\r\n"
-          end
-        end
-
-        context "when the request does not have Connection: close" do
-          it "sends the response to the socket without a Connection: close response header" do
-            connection.receive_data "GET /subresource HTTP/1.1\r\nHost: _\r\n\r\n"
-            result.should include("GET response")
-            result.should_not include("Connection: close")
-          end
-
-          it "does not close the connection" do
-            dont_allow(connection).close_connection_after_writing
-            connection.receive_data "GET /subresource HTTP/1.1\r\nHost: _\r\n\r\n"
-          end
-
-          context "when a second request is made" do
-            it "sends the response for the second request and not for the first request" do
-              connection.receive_data "GET /subresource HTTP/1.1\r\nHost: _\r\n\r\n"
-              result.should include("GET response")
-              result.should_not include("Another GET response")
-
-              connection.receive_data "GET /another_subresource HTTP/1.1\r\nHost: _\r\n\r\n"
-              result.should include("Another GET response")
-            end
-          end
-        end
-      end
-
-      context "when the call raises an error" do
-        it "responds with a 500 page and logs the error" do
-          error = nil
-          mock(connection).log_error(is_a(Exception)) do |error_arg|
-            error = error_arg
-          end
-          mock(connection).send_head(500)
-          mock(connection).send_body(Regexp.new(ErrorSubresource::ERROR_MESSAGE))
-
-          connection.receive_data "GET /error_subresource HTTP/1.1\r\nHost: _\r\n\r\n"
-          error.message.should =~ Regexp.new("/error_subresource")
-        end
-      end
-    end
-    
-    describe "#send_head" do
-      before do
-        @connection = create_connection
-        stub(EventMachine).close_connection
-      end
-
-      context "when passed no arguments" do
-        it "responds with a 200 HTTP header excluding the Content-Length" do
-          expected_header = "HTTP/1.1 200 OK\r\nServer: Thin Rest Server\r\n"
-          mock(EventMachine).send_data( connection.signature, expected_header, expected_header.length ) {expected_header.length}
-          connection.send_head
-        end
-      end
-
-      context "when passed 301" do
-        it "responds with a 301 HTTP header excluding the Content-Length" do
-          expected_header = "HTTP/1.1 301 OK\r\nServer: Thin Rest Server\r\n"
-          mock(EventMachine).send_data( connection.signature, expected_header, expected_header.length ) {expected_header.length}
-          connection.send_head(301)
-        end
-      end
-
-      context "when passed additional parameters" do
-        it "responds with the additional parameters in the header" do
-          expected_header = "HTTP/1.1 301 OK\r\nServer: Thin Rest Server\r\nLocation: http://google.com\r\n"
-          mock(EventMachine).send_data( connection.signature, expected_header, expected_header.length ) {expected_header.length}
-          connection.send_head(301, :Location => "http://google.com")
-        end
-
-        context "when not passed Content-length" do
-          it 'does not end with \r\n\r\n' do
-            expected_header = "HTTP/1.1 301 OK\r\nServer: Thin Rest Server\r\nLocation: http://google.com\r\n"
-            mock(EventMachine).send_data( connection.signature, expected_header, expected_header.length ) {expected_header.length}
-            connection.send_head(301, :Location => "http://google.com")
-          end
-        end
-
-        context "when passed Content-Length" do
-          it 'when passed a Symbol representation of Content-Length ends with \r\n\r\n' do
-            expected_header = "HTTP/1.1 301 OK\r\nServer: Thin Rest Server\r\nContent-Length: 10\r\n\r\n"
-            mock(EventMachine).send_data( connection.signature, expected_header, expected_header.length ) {expected_header.length}
-            connection.send_head(301, :'Content-Length' => 10)
-          end
-
-          it 'when passed a String representation of Content-Length ends with \r\n\r\n' do
-            expected_header = "HTTP/1.1 301 OK\r\nServer: Thin Rest Server\r\nContent-Length: 10\r\n\r\n"
-            mock(EventMachine).send_data( connection.signature, expected_header, expected_header.length ) {expected_header.length}
-            connection.send_head(301, 'Content-Length' => 10)
-          end
-        end
-      end
-    end
-
-    describe "#send_body" do
-      before do
-        @connection = create_connection
-        stub(EventMachine).close_connection
-      end
-
-      it "responds with Content-Length and the body" do
-        data = "The data"
-        header = "Content-Length: #{data.length}\r\n\r\n"
-
-        mock(EventMachine).send_data( connection.signature, header, header.length ) {header.length}
-        mock(EventMachine).send_data( connection.signature, data, data.length ) {data.length}
-
-        connection.send_body data
-      end
-    end
-
-    describe "#unbind" do
-      attr_reader :game_session
-
-      before do
-        stub_send_data
-        stub(EventMachine).close_connection
-        @connection = create_connection
-        params = "param_1=1&param_2=2"
-        body = "#{params}\r\n"
-        connection.receive_data("POST /subresource HTTP/1.1\r\nHost: _\r\n\r\n#{body}")
-      end
-
-      it "calls connection_finished on the backend to protect against memory leaks" do
-        mock(connection.backend).connection_finished(connection)
-        connection.unbind
-      end
-
-      it "does not send data or add a timer of any type" do
-        dont_allow(EventMachine).send_data
-        dont_allow(EventMachine).add_timer
-
-        connection.unbind
-      end
-    end
-
-    describe "#handle_error" do
-      before do
-        @connection = create_connection
-        Thin::Logging.silent = true
-      end
-
-      it "logs the error" do
-        error = RuntimeError.new("Unexpected Error")
-        stub(error).backtrace(caller)
-
-        stub(connection).warn
-        mock.proxy(connection).log_error(error)
-        mock.proxy(connection).log_error(anything)
-
-        connection.handle_error(error)
-      end
-    end
-
-    describe "#persistent?" do
-      before do
-        @connection = create_connection
-        stub(connection).socket_address {'0.0.0.0'}
-      end
-
-      context "when #request.persistent? is true" do
-        it "returns true" do
-          stub(connection.request).persistent? {true}
-          connection.should be_persistent
-        end
-      end
-
-      context "when #request.persistent? is false" do
-        it "returns false" do
-          stub(connection.request).persistent? {false}
-          connection.should_not be_persistent
-        end
-      end
-    end
-  end
-end

data/vendor/js-test-core/vendor/thin-rest/spec/thin_rest/resources/resource_not_found_spec.rb

@@ -1,16 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../../thin_rest_spec_helper")
-
-module ThinRest
-  module Resources
-    describe ResourceNotFound do
-      describe "GET /invalid_path" do
-        it "returns a page with a of files in the directory" do
-          mock(connection).send_head(404)
-          mock(connection).send_body(Regexp.new("File /invalid_path not found."))
-
-          connection.receive_data("GET /invalid_path HTTP/1.1\r\nHost: _\r\n\r\n")
-        end
-      end
-    end
-  end
-end

data/vendor/js-test-core/vendor/thin-rest/spec/thin_rest/resources/resource_spec.rb

@@ -1,135 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../../thin_rest_spec_helper")
-
-module ThinRest
-  module Resources
-    describe Resource do
-      attr_reader :root
-      self.thin_logging = true
-      before do
-        stub(EventMachine).close_connection
-        @root = Root.new(:connection => connection)
-      end
-
-      describe ".property" do
-        it "creates a reader that takes its value from its env property" do
-          root.env[:connection].should == connection
-          root.connection.should == root.env[:connection]
-        end
-
-        it "creates a writer that sets its passed in value to its env property" do
-          another_connection = create_connection
-          root.connection = another_connection
-          root.connection.should == another_connection
-          root.env[:connection].should == another_connection
-        end
-      end
-
-      describe "#locate" do
-        context "/subresource - route is defined using a String" do
-          it "returns an instance of Subresource" do
-            root.locate("subresource").class.should == Subresource
-          end
-        end
-
-        context "/block_subresource - route is defined using a block" do
-          it "returns an instance of BlockSubresource" do
-            root.locate("block_subresource").class.should == BlockSubresource
-          end
-
-          it "executes the block within the instance of the Resource" do
-            root.foobar.should_not be_nil
-            root.locate("block_subresource").foobar.should == root.foobar
-          end
-        end
-
-        context "/no_handler_subresource - route is not defined" do
-          it "returns a ResourceNotFound resource" do
-            root.locate("no_handler_subresource").class.should == Resources::ResourceNotFound
-          end
-        end
-
-        context "/wrong_property - passed in property not defined" do
-          it "does not set an instance variable named after the wrong property" do
-            resource = root.locate("wrong_property")
-            resource.env.should == {:connection => connection, :baz => "wrong_property"}
-            resource.instance_variable_get("@connection").should == connection
-            resource.instance_variable_get("@baz").should be_nil
-          end
-        end
-      end
-
-      describe "Delegations" do
-        describe "#request" do
-          it "delegates to #connection" do
-            root.request.should == connection.request
-          end
-        end
-
-        describe "#response" do
-          it "delegates to #connection" do
-            root.response.should == connection.response
-          end
-        end
-
-        describe "#rack_request" do
-          it "delegates to #connection" do
-            root.rack_request.should == connection.rack_request
-          end
-        end
-      end
-
-      describe "GET /subresource" do
-        it "sends the GET response for the resource" do
-          mock(connection).send_data(connection.head(200, {}))
-          expected_data = "GET response"
-          expected_content_length = "Content-Length: #{expected_data.length}\r\n\r\n"
-          mock(connection).send_data(expected_content_length) {expected_content_length.length}
-          mock(connection).send_data(expected_data) {expected_data.length}
-          connection.receive_data("GET /subresource HTTP/1.1\r\nHost: _\r\n\r\n")
-        end
-      end
-
-      describe "GET /no_handler_subresource" do
-        it "renders an error page and logs the error" do
-          stub(connection).send_data
-          mock(connection).send_data(Regexp.new("File /no_handler_subresource not found"))
-          mock(connection).log_error(is_a(ThinRest::RoutingError))
-          connection.receive_data("GET /no_handler_subresource HTTP/1.1\r\nHost: _\r\n\r\n")
-        end
-      end
-
-      describe "POST /subresource" do
-        it "sends the POST response for the resource" do
-          mock(connection).send_data(connection.head(200, {}))
-          expected_data = "POST response"
-          expected_content_length = "Content-Length: #{expected_data.length}\r\n\r\n"
-          mock(connection).send_data(expected_content_length) {expected_content_length.length}
-          mock(connection).send_data(expected_data) {expected_data.length}
-          connection.receive_data("POST /subresource HTTP/1.1\r\nHost: _\r\n\r\n")
-        end
-      end
-
-      describe "PUT /subresource" do
-        it "sends the PUT response for the resource" do
-          mock(connection).send_data(connection.head(200, {}))
-          expected_data = "PUT response"
-          expected_content_length = "Content-Length: #{expected_data.length}\r\n\r\n"
-          mock(connection).send_data(expected_content_length) {expected_content_length.length}
-          mock(connection).send_data(expected_data) {expected_data.length}
-          connection.receive_data("PUT /subresource HTTP/1.1\r\nHost: _\r\n\r\n")
-        end
-      end
-
-      describe "DELETE /subresource" do
-        it "sends the DELETE response for the resource" do
-          mock(connection).send_data(connection.head(200, {}))
-          expected_data = "DELETE response"
-          expected_content_length = "Content-Length: #{expected_data.length}\r\n\r\n"
-          mock(connection).send_data(expected_content_length) {expected_content_length.length}
-          mock(connection).send_data(expected_data) {expected_data.length}
-          connection.receive_data("DELETE /subresource HTTP/1.1\r\nHost: _\r\n\r\n")
-        end
-      end
-    end
-  end
-end

data/vendor/js-test-core/vendor/thin-rest/spec/thin_rest/resources/root_spec.rb

@@ -1,16 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../../thin_rest_spec_helper")
-
-module ThinRest
-  module Resources
-    describe ResourceNotFound do
-      describe "GET /invalid_path" do
-        it "returns a page with a of files in the directory" do
-          mock(connection).send_head(404)
-          mock(connection).send_body(Regexp.new("File /invalid_path not found."))
-
-          connection.receive_data("GET /invalid_path HTTP/1.1\r\nHost: _\r\n\r\n")
-        end
-      end
-    end
-  end
-end

data/vendor/js-test-core/vendor/thin-rest/spec/thin_rest_spec_helper.rb

@@ -1,134 +0,0 @@
-dir = File.dirname(__FILE__)
-$LOAD_PATH.unshift(File.expand_path("#{dir}/../lib"))
-require "thin_rest"
-require "spec"
-require "spec/autorun"
-require "guid"
-
-Spec::Runner.configure do |config|
-  config.mock_with :rr
-end
-
-class Spec::ExampleGroup
-  class << self
-    def thin_logging
-      if @thin_logging.nil?
-        return false
-      else
-        @thin_logging
-      end
-    end
-    attr_writer :thin_logging
-  end
-
-  attr_reader :connection
-  before do
-    @connection = create_connection
-
-    stub(EventMachine).send_data {raise "EventMachine.send_data needs to be stubbed or mocked out"}
-    stub(EventMachine).close_connection {raise "EventMachine.close_connection needs to be stubbed or mocked out"}
-    stub(EventMachine).close_connection_after_writing {raise "EventMachine.close_connection_after_writing needs to be stubbed or mocked out"}
-    stub(EventMachine).set_comm_inactivity_timeout {raise "EventMachine.set_comm_inactivity_timeout needs to be stubbed or mocked out"}
-    stub(EventMachine).report_connection_error_status {0}
-    stub(EventMachine).add_timer
-    Thin::Logging.silent = !self.class.thin_logging
-    Thin::Logging.debug = self.class.thin_logging
-  end
-
-  after(:each) do
-    Thin::Logging.silent = true
-    Thin::Logging.debug = false
-  end
-
-  def create_connection(guid = Guid.new.to_s)
-    connection = TestConnection.new(guid)
-    connection.backend = Object.new
-    stub(connection.backend).connection_finished
-    connection
-  end
-
-  def stub_send_data
-    stub(EventMachine).send_data do |signature, data, data_length|
-      data_length
-    end
-  end
-end
-
-class TestConnection < ThinRest::Connection
-  def root_resource
-    Root.new(:connection => self)
-  end
-end
-
-class Root < ThinRest::Resources::Resource
-  property :connection
-  route 'subresource', 'Subresource'
-  route 'another_subresource', 'AnotherSubresource'
-  route 'block_subresource' do |properties, name|
-    BlockSubresource.new(properties.merge(:foobar => foobar))
-  end
-  route 'error_subresource', 'ErrorSubresource'
-  route 'wrong_property' do |properties, name|
-    WrongPropertySubresource.new(properties.merge(:baz => name))
-  end
-
-
-  def foobar
-    :baz
-  end
-end
-
-class Subresource < ThinRest::Resources::Resource
-  def do_get
-    "GET response"
-  end
-
-  def do_post
-    "POST response"
-  end
-
-  def do_put
-    "PUT response"
-  end
-
-  def do_delete
-    "DELETE response"
-  end
-end
-
-class AnotherSubresource < ThinRest::Resources::Resource
-  def do_get
-    "Another GET response"
-  end
-
-  def do_post
-    "Another POST response"
-  end
-
-  def do_put
-    "Another PUT response"
-  end
-
-  def do_delete
-    "Another DELETE response"
-  end
-end
-
-class BlockSubresource < ThinRest::Resources::Resource
-  property :foobar
-end
-
-class ErrorSubresource < ThinRest::Resources::Resource
-  ERROR_MESSAGE = "An Error"
-
-  def get
-    raise ERROR_MESSAGE
-  end
-end
-
-class WrongPropertySubresource < ThinRest::Resources::Resource
-  property :foobar
-  def get
-    "Wrong Property"
-  end
-end