js_test_core 0.1.1 → 0.2.0

data/lib/js_test_core/resources/session.rb

@@ -0,0 +1,44 @@
+module JsTestCore
+  module Resources
+    class Session < ThinRest::Resource
+      class Collection < ThinRest::Resource
+        route ANY do |env, id|
+          Session.new(env.merge(:id => id))
+        end
+      end
+
+      RUNNING = 'running'
+      SUCCESSFUL_COMPLETION = 'success'
+      FAILURE_COMPLETION = 'failure'
+
+      property :id
+
+      def get
+        runner = Runner.find(id)
+        if runner
+          connection.send_head
+          if runner.running?
+            connection.send_body("status=#{RUNNING}")
+          else
+            if runner.successful?
+              connection.send_body("status=#{SUCCESSFUL_COMPLETION}")
+            else
+              connection.send_body("status=#{FAILURE_COMPLETION}&reason=#{runner.session_run_result}")
+            end
+          end
+        else
+          connection.send_head(404)
+          connection.send_body("")
+        end
+      end
+
+      route 'finish' do |env, name|
+        SessionFinish.new(env.merge(:session => self))
+      end
+
+      def associated_with_a_runner?
+        id.to_s != ""
+      end
+    end
+  end
+end

data/lib/js_test_core/resources/session_finish.rb

@@ -0,0 +1,17 @@
+module JsTestCore
+  module Resources
+    class SessionFinish < ThinRest::Resource
+      property :session
+      
+      def post
+        if session.associated_with_a_runner?
+          Runner.finalize(session.id, rack_request['text'])
+        else
+          STDOUT.puts rack_request['text']
+        end
+        connection.send_head
+        connection.send_body("")
+      end
+    end
+  end
+end

data/lib/js_test_core/resources/specs/spec_dir.rb

@@ -2,7 +2,7 @@ module JsTestCore
   module Resources
     module Specs
       class SpecDirSuperclass < ::JsTestCore::Resources::Dir
-        def get(request, response)
+        def get
           raise NotImplementedError, "#{self.class}#get needs to be implemented"
         end
       end
@@ -12,13 +12,9 @@ module JsTestCore
           glob("/**/*_spec.js")
         end
 
-        def locate(name)
-          if file = file(name)
-            file
-          elsif subdir = subdir(name)
-            subdir
-          elsif spec_file = spec_file(name)
-            spec_file
+        route ANY do |env, name|
+          if result = (file(name) || subdir(name) || spec_file(name))
+            result
           else
             base_path = "#{relative_path}/#{name}"
             raise "No file or directory found at #{base_path} or spec found at #{base_path}.js."
@@ -28,18 +24,18 @@ module JsTestCore
         protected
 
         def subdir(name)
-          absolute_dir_path, relative_dir_path = determine_child_paths(name)
-          if ::File.directory?(absolute_dir_path)
-            SpecDir.new(absolute_dir_path, relative_dir_path)
+          absolute_path, relative_path = determine_child_paths(name)
+          if ::File.directory?(absolute_path)
+            SpecDir.new(env.merge(:absolute_path => absolute_path, :relative_path => relative_path))
           else
             nil
           end
         end
 
         def spec_file(name)
-          absolute_file_path, relative_file_path = determine_child_paths("#{name}.js")
-          if ::File.exists?(absolute_file_path) && !::File.directory?(absolute_file_path)
-            SpecFile.new(absolute_file_path, relative_file_path)
+          absolute_path, relative_path = determine_child_paths("#{name}.js")
+          if ::File.exists?(absolute_path) && !::File.directory?(absolute_path)
+            SpecFile.new(env.merge(:absolute_path => absolute_path, :relative_path => relative_path))
           else
             nil
           end

data/lib/js_test_core/resources/specs/spec_file.rb

@@ -2,7 +2,7 @@ module JsTestCore
   module Resources
     module Specs
       class SpecFileSuperclass < ::JsTestCore::Resources::File
-        def get(request, response)
+        def get
           raise NotImplementedError, "#{self.class}#get needs to be implemented"
         end
       end

data/lib/js_test_core/resources/web_root.rb

@@ -1,20 +1,52 @@
 module JsTestCore
   module Resources
-    class WebRoot
-      LOCATIONS = [
-        ['core', lambda do
-          Resources::Dir.new(JsTestCore::Server.core_path, "/core")
-        end],
-        ['implementations', lambda do
-          Resources::Dir.new(JsTestCore::Server.implementation_root_path, "/implementations")
-        end],
-        ['suites', lambda do
-          Resources::Suite
-        end],
-        ['runners', lambda do
-          Resources::Runners.new
-        end]
-      ]
+    class WebRoot < ThinRest::Resource
+      route "" do |env, name|
+        self
+      end
+      route "core" do |env, name|
+        Resources::Dir.new(env.merge(
+          :absolute_path => JsTestCore::Server.core_path,
+          :relative_path => "/core"
+        ))
+      end
+      route "implementations" do |env, name|
+        Resources::Dir.new(env.merge(
+          :absolute_path => JsTestCore::Server.implementation_root_path,
+          :relative_path => "/implementations"
+        ))
+      end
+      route "sessions", "JsTestCore::Resources::Session::Collection"
+      route "session" do |env, name|
+        Session.new(env.merge(:id => rack_request.cookies["session_id"]))
+      end
+      route "runners", "JsTestCore::Resources::Runner::Collection"
+      route "specs" do |env, name|
+        if self.class.dispatch_strategy == :specs
+          Resources::Specs::SpecDir.new(env.merge(
+            :absolute_path => JsTestCore::Server.spec_root_path,
+            :relative_path => "/specs"
+          ))
+        else
+          Resources::FileNotFound.new(env.merge(:name => name))
+        end
+      end
+      route ANY do |env, name|
+        potential_file_in_public_path = "#{public_path}/#{name}"
+        if ::File.directory?(potential_file_in_public_path)
+          Resources::Dir.new(env.merge(
+            :absolute_path => potential_file_in_public_path,
+            :relative_path => "/#{name}"
+          ))
+        elsif ::File.exists?(potential_file_in_public_path)
+          Resources::File.new(env.merge(
+            :absolute_path => potential_file_in_public_path,
+            :relative_path => "/#{name}"
+          ))
+        else
+          Resources::FileNotFound.new(env.merge(:name => name))
+        end
+      end
 
       class << self
         attr_accessor :dispatch_strategy
@@ -23,31 +55,11 @@ module JsTestCore
         end
       end
 
-      attr_reader :public_path
-      def initialize(public_path)
-        @public_path = ::File.expand_path(public_path)
-      end
-
-      def locate(name)
-        if self.class.dispatch_strategy == :specs && name == 'specs'
-          return JsTestCore::Resources::Specs::SpecDir.new(JsTestCore::Server.spec_root_path, "/specs")
-        end
+      property :public_path
 
-        location, initializer = LOCATIONS.find do |location|
-          location.first == name
-        end
-        if initializer
-          initializer.call
-        else
-          potential_file_in_public_path = "#{public_path}/#{name}"
-          if ::File.directory?(potential_file_in_public_path)
-            Resources::Dir.new(potential_file_in_public_path, "/#{name}")
-          elsif ::File.exists?(potential_file_in_public_path)
-            Resources::File.new(potential_file_in_public_path, "/#{name}")
-          else
-            raise "Invalid path: #{name}"
-          end
-        end
+      def get
+        connection.send_head(200, :Location => "/#{self.class.dispatch_strategy}")
+        connection.send_body("<html><head></head><body>Welcome to the Js Test Server. Click the following link to run you <a href=/specs>spec suite</a>.</body></html>")
       end
     end
   end

data/lib/js_test_core/selenium_server_configuration.rb

@@ -0,0 +1,48 @@
+module JsTestCore
+  class SeleniumServerConfiguration
+    attr_reader :parameters
+
+    class << self
+      def query_string_from(*args, &block)
+        new(*args, &block).query_string
+      end
+    end
+
+    def initialize(parameters={})
+      @parameters = parameters
+    end
+
+
+    def query_string
+      parts = [selenium_browser_start_command, selenium_host, selenium_port]
+      parts << spec_url if url
+      parts.join('&')
+    end
+
+    private
+
+    def selenium_browser_start_command
+      "selenium_browser_start_command=#{parameter_or_default_for(:selenium_browser_start_command, '*firefox')}"
+    end
+
+    def selenium_host
+      "selenium_host=#{parameter_or_default_for(:selenium_host, 'localhost')}"
+    end
+
+    def selenium_port
+      "selenium_port=#{parameter_or_default_for(:selenium_port, 4444)}"
+    end
+
+    def spec_url
+      "spec_url=#{url}"
+    end
+
+    def url
+      parameters[:spec_url]
+    end
+
+    def parameter_or_default_for(parameter_name, default = nil)
+      CGI.escape((parameters[parameter_name] || default).to_s)
+    end
+  end
+end

data/lib/js_test_core/server.rb

@@ -14,9 +14,6 @@ module JsTestCore
       def implementation_root_path; instance.implementation_root_path; end
       def public_path; instance.public_path; end
       def core_path; instance.core_path; end
-      def test_dir_class; instance.test_dir_class; end
-      def test_file_class; instance.test_file_class; end
-      def connection; instance.connection; end
       def request; instance.request; end
       def response; instance.response; end
       def root_url; instance.root_url; end
@@ -34,37 +31,14 @@ module JsTestCore
     end
 
     def run(options)
-      server = ::Thin::Server.new(options[:Host], options[:Port], self)
+      server = ::Thin::Server.new(options[:Host], options[:Port]) do
+        use Rack::CommonLogger
+      end
       server.backend = ::Thin::Backends::JsTestCoreServer.new(options[:Host], options[:Port])
       server.backend.server = server
       server.start!
     end
 
-    def call(env)
-      self.connection = env['js_test_core.connection']
-      self.request = Rack::Request.new(env)
-      self.response = Rack::Response.new
-      method = request.request_method.downcase.to_sym
-      get_resource(request).send(method, request, response)
-      response.finish
-    ensure
-      self.connection = nil
-      self.request = nil
-      self.response = nil
-    end
-
-    def connection
-      Thread.current[:connection]
-    end
-
-    def request
-      Thread.current[:request]
-    end
-
-    def response
-      Thread.current[:response]
-    end
-
     def root_url
       "http://#{host}:#{port}"
     end
@@ -72,40 +46,5 @@ module JsTestCore
     def core_path
       JsTestCore.core_path
     end
-
-    def test_dir_class
-      JsTestCore.adapter.test_dir_class
-    end
-
-    def test_file_class
-      JsTestCore.adapter.test_file_class
-    end
-    
-    protected
-    def connection=(connection)
-      Thread.current[:connection] = connection
-    end
-
-    def request=(request)
-      Thread.current[:request] = request
-    end
-
-    def response=(response)
-      Thread.current[:response] = response
-    end
-
-    def path_parts(req)
-      request.path_info.split('/').reject { |part| part == "" }
-    end
-
-    def get_resource(request)
-      path_parts(request).inject(Resources::WebRoot.new(public_path)) do |resource, child_resource_name|
-        resource.locate(child_resource_name)
-      end
-    rescue Exception => e
-      detailed_exception = Exception.new("Error handling path #{request.path_info}\n#{e.message}")
-      detailed_exception.set_backtrace(e.backtrace)
-      raise detailed_exception
-    end
   end
 end

data/lib/js_test_core/thin/js_test_core_connection.rb

@@ -1,42 +1,8 @@
 module Thin
-  class JsTestCoreConnection < Connection
-    def process
-      # Add client info to the request env
-      @request.remote_address = remote_address
-
-      env = @request.env
-      env['js_test_core.connection'] = self
-      @response.status, @response.headers, @response.body = @app.call(env)
-      send_data @response.head
-      if !@response.body.empty? || @response.headers.to_s.include?("Content-Length: 0")
-        send_body @response.body
-      end
-    rescue Exception => e
-      handle_error e
-    end
-
-    def send_body(rack_response)
-      rack_response.each do |chunk|
-        send_data chunk
-      end
-      # If no more request on that same connection, we close it.
-      close_connection_after_writing unless persistent?
-    rescue Exception => e
-      handle_error e
-    ensure
-      @request.close  rescue nil
-      @response.close rescue nil
-
-      # Prepare the connection for another request if the client
-      # supports HTTP pipelining (persistent connection).
-      post_init if persistent?
-    end
-
-    def handle_error(error)
-      log "!! Unexpected error while processing request: #{error.message}"
-      log error.backtrace
-      log_error
-      close_connection rescue nil
+  class JsTestCoreConnection < ThinRest::Connection
+    protected
+    def root_resource
+      ::JsTestCore::Resources::WebRoot.new(:connection => self, :public_path => ::JsTestCore::Server.public_path)
     end
   end
 end

data/spec/unit/js_test_core/client_spec.rb

@@ -0,0 +1,167 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../unit_spec_helper")
+
+module JsTestCore
+  describe Client do
+    describe '.run' do
+      attr_reader :stdout, :request
+      before do
+        @stdout = StringIO.new
+        Client.const_set(:STDOUT, stdout)
+        @request = "http request"
+        mock(Net::HTTP).start(DEFAULT_HOST, DEFAULT_PORT).yields(request)
+        stub.instance_of(Client).sleep
+      end
+
+      after do
+        Client.__send__(:remove_const, :STDOUT)
+      end
+
+      it "tells the server to start a session run in Firefox and polls the status of the session until the session is complete" do
+        mock_post_to_runner("*firefox")
+        mock_polling_returns([running_status, running_status, success_status])
+        Client.run
+      end
+
+      context "when the Session run ends in 'success'" do
+        before do
+          mock_post_to_runner("*firefox")
+          mock_polling_returns([running_status, running_status, success_status])
+        end
+
+        it "reports success" do
+          Client.run
+          stdout.string.strip.should == "SUCCESS"
+        end
+
+        it "returns true" do
+          Client.run.should be_true
+        end
+      end
+
+      context "when the Session run ends in 'failure'" do
+        attr_reader :failure_reason
+        before do
+          mock_post_to_runner("*firefox")
+          @failure_reason = "I have a failed test"
+          mock_polling_returns([running_status, running_status, failure_status(failure_reason)])
+        end
+
+        it "reports failure and reason" do
+          Client.run
+          stdout.string.strip.should include("FAILURE")
+          stdout.string.strip.should include(failure_reason)
+        end
+
+        it "returns false" do
+          Client.run.should be_false
+        end
+
+        it "reports the reason for failure"
+      end
+
+      context "when the Session is not found" do
+        it "raises a SessionNotFound error" do
+          mock_post_to_runner("*firefox")
+          mock(request).get("/sessions/my_session_id") do
+            stub(session_response = Object.new).code {"404"}
+            session_response
+          end
+          lambda {Client.run}.should raise_error(Client::SessionNotFound)
+        end
+      end
+
+      context "when the Session run ends in with invalid status" do
+        it "raises an InvalidStatusResponse" do
+          mock_post_to_runner("*firefox")
+          mock_polling_returns([running_status, running_status, "status=this is an unexpected status result"])
+          lambda {Client.run}.should raise_error(Client::InvalidStatusResponse)
+        end
+      end
+
+      def mock_post_to_runner(selenium_browser_start_command)
+        mock(start_session_response = Object.new).body {"session_id=my_session_id"}
+        mock(request).post("/runners", "selenium_browser_start_command=#{CGI.escape(selenium_browser_start_command)}&selenium_host=localhost&selenium_port=4444") do
+          start_session_response
+        end
+      end
+
+      def mock_polling_returns(session_statuses=[])
+        mock(request).get("/sessions/my_session_id") do
+          stub(session_response = Object.new).body {session_statuses.shift}
+          stub(session_response).code {"200"}
+          session_response
+        end.times(session_statuses.length)
+      end
+
+      def running_status
+        "status=#{Resources::Session::RUNNING}"
+      end
+
+      def success_status
+        "status=#{Resources::Session::SUCCESSFUL_COMPLETION}"
+      end
+
+      def failure_status(reason)
+        "status=#{Resources::Session::FAILURE_COMPLETION}&reason=#{reason}"
+      end
+    end
+
+    describe ".run_argv" do
+      attr_reader :request, :response
+      before do
+        stub(Client).puts
+      end
+
+      describe "when passed in Hash contains :selenium_browser_start_command" do
+        it "passes the spec_url as a post parameter" do
+          selenium_browser_start_command = '*iexplore'
+          mock(Client).run(:selenium_browser_start_command => selenium_browser_start_command)
+          client = Client.run_argv(['--selenium_browser_start_command', selenium_browser_start_command])
+        end
+      end
+
+      describe "when passed in Hash contains :spec_url" do
+        it "passes the spec_url as a post parameter" do
+          spec_url = 'http://foobar.com/foo'
+          mock(Client).run(:spec_url => spec_url)
+          client = Client.run_argv(['--spec_url', spec_url])
+        end
+      end
+
+      describe "when passed in Hash contains :selenium_host" do
+        it "passes the selenium_host as a post parameter" do
+          selenium_host = 'test-runner'
+          mock(Client).run(:selenium_host => selenium_host)
+          client = Client.run_argv(['--selenium_host', selenium_host])
+        end
+      end
+
+      describe "when passed in Hash contains :selenium_port" do
+        it "passes the selenium_port as a post parameter" do
+          selenium_port = "5000"
+          mock(Client).run(:selenium_port => selenium_port)
+          client = Client.run_argv(['--selenium_port', selenium_port])
+        end
+      end
+    end
+
+    describe '#parts_from_query' do
+      attr_reader :client
+      before do
+        @client = Client.new(params_does_not_matter = {})
+      end
+
+      it "parses empty query into an empty hash" do
+        client.parts_from_query("").should == {}
+      end
+
+      it "parses a single key value pair into a single-element hash" do
+        client.parts_from_query("foo=bar").should == {'foo' => 'bar'}
+      end
+
+      it "parses a multiple key value pairs into a multi-element hash" do
+        client.parts_from_query("foo=bar&baz=quux").should == {'foo' => 'bar', 'baz' => 'quux'}
+      end
+    end
+  end
+end