js_spec 0.3.1 → 0.3.2

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

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

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

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

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

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

@@ -0,0 +1,104 @@
+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
+
+    protected
+    def after_initialize
+    end
+  end
+end

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

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

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

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

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

@@ -0,0 +1,5 @@
+dir = File.dirname(__FILE__)
+Dir["#{dir}/**/*_spec.rb"].each do |file|
+#  puts "require '#{file}'"
+  require file
+end

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

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