screw-unit 0.3.3 → 0.5.1

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

@@ -1,3 +0,0 @@
-Dir["#{File.dirname(__FILE__)}/extensions/*.rb"].each do |file|
-  require file
-end

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

@@ -1,21 +0,0 @@
-# From Mauricio Fernandez.
-class Object
-  module InstanceExecHelper; end
-  include InstanceExecHelper
-  def instance_exec(*args, &block)
-    begin
-      old_critical, Thread.critical = Thread.critical, true
-      n = 0
-      n += 1 while respond_to?(mname="__instance_exec#{n}")
-      InstanceExecHelper.module_eval{ define_method(mname, &block) }
-    ensure
-      Thread.critical = old_critical
-    end
-    begin
-      ret = send(mname, *args)
-    ensure
-      InstanceExecHelper.module_eval{ remove_method(mname) } rescue nil
-    end
-    ret
-  end
-end

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

@@ -1,108 +0,0 @@
-module ThinRest
-  class Resource
-    class << self
-      def property(*names)
-        names.each do |name|
-          my_properties << name.to_sym
-
-          define_method name do
-            env[name]
-          end
-
-          define_method "#{name}=" do |new_value|
-            env[name] = new_value
-          end
-        end
-      end
-
-      def properties
-        if superclass.respond_to?(:properties)
-          superclass.properties | my_properties
-        else
-          my_properties
-        end
-      end
-
-      def route(name, resource_type_name=nil, &block)
-        routes[name] = block || lambda do |env, name|
-          resource_type = resource_type_name.split('::').inject(Object) do |mod, next_mod_name|
-            mod.const_get(next_mod_name)
-          end
-          resource_type.new(env)
-        end
-      end
-
-      def routes
-        @routes ||= {}
-      end
-
-      protected
-      def my_properties
-        @my_properties ||= []
-      end
-
-      def handle_dequeue_and_process_error(command, error)
-        if command.connection
-          command.connection.handle_error error
-        else
-          super
-        end
-      end
-    end
-    ANY = Object.new
-
-    property :connection
-    attr_reader :env
-
-    def initialize(env={})
-      @env = env
-      env.each do |name, value|
-        if self.class.properties.include?(name.to_sym)
-          instance_variable_set("@#{name}", value)
-        end
-      end
-      after_initialize
-    end
-
-    def request; connection.request; end
-    def response; connection.response; end
-    def rack_request; connection.rack_request; end
-
-    def get
-      connection.send_head
-      connection.send_body(do_get || "")
-    end
-
-    def post
-      connection.send_head
-      connection.send_body(do_post || "")
-    end
-
-    def put
-      connection.send_head
-      connection.send_body(do_put || "")
-    end
-
-    def delete
-      connection.send_head
-      connection.send_body(do_delete || "")
-    end
-
-    def locate(name)
-      route_handler = self.class.routes[name] || self.class.routes[ANY]
-      raise RoutingError, "Invalid route: #{connection.rack_request.path_info} ; name: #{name}" unless route_handler
-      instance_exec(env, name, &route_handler)
-    end
-
-    def unbind
-    end
-
-    def ==(other)
-      other.class == self.class && other.env == env 
-    end
-
-    protected
-    def after_initialize
-    end
-  end
-end

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

@@ -1,4 +0,0 @@
-module ThinRest
-  class ResourceInvalid < StandardError
-  end
-end

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

@@ -1,5 +0,0 @@
-module ThinRest
-  class RoutingError < RuntimeError
-
-  end
-end

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

@@ -1,207 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../thin_rest_spec_helper")
-
-module ThinRest
-  describe Connection do
-    attr_reader :connection
-
-    describe "#process" do
-      attr_reader :result
-      before do
-        @connection = create_connection
-        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 "logs the error and closes the connection" do
-          error = nil
-          mock(connection).log_error(is_a(Exception)) do |error_arg|
-            error = error_arg
-          end
-          mock(connection).close_connection
-
-          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/resource_spec.rb

@@ -1,127 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../thin_rest_spec_helper")
-
-module ThinRest
-  describe Resource do
-    attr_reader :connection, :root
-    self.thin_logging = true
-    before do
-      @connection = create_connection
-      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 "raises a RoutingError" do
-          lambda do
-            root.locate("no_handler_subresource")
-          end.should raise_error(RoutingError)
-        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 "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