js_test_core 0.1.1

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

@@ -0,0 +1,17 @@
+module JsTestCore
+  module Resources
+    module Specs
+      class SpecFileSuperclass < ::JsTestCore::Resources::File
+        def get(request, response)
+          raise NotImplementedError, "#{self.class}#get needs to be implemented"
+        end
+      end
+
+      class SpecFile < SpecFileSuperclass
+        def spec_files
+          [self]
+        end
+      end
+    end
+  end
+end

data/lib/js_test_core/resources/suite.rb

@@ -0,0 +1,24 @@
+module JsTestCore
+  module Resources
+    class Suite
+      class << self
+        def locate(id)
+          new id
+        end
+      end
+
+      attr_reader :id
+      def initialize(id)
+        @id = id
+      end
+
+      def locate(name)
+        if name == 'finish'
+          SuiteFinish.new self
+        else
+          raise ArgumentError, "Invalid path: #{name}"
+        end
+      end
+    end
+  end
+end

data/lib/js_test_core/resources/suite_finish.rb

@@ -0,0 +1,19 @@
+module JsTestCore
+  module Resources
+    class SuiteFinish
+      attr_reader :suite
+      def initialize(suite)
+        @suite = suite
+      end
+
+      def post(request, response)
+        if suite.id == 'user'
+          STDOUT.puts request['text']
+        else
+          Runners::FirefoxRunner.resume(suite.id, request['text'])
+        end
+        response.headers['Content-Length'] = "0"
+      end
+    end
+  end
+end

data/lib/js_test_core/resources/web_root.rb

@@ -0,0 +1,54 @@
+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 << self
+        attr_accessor :dispatch_strategy
+        def dispatch_specs
+          self.dispatch_strategy = :specs
+        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
+
+        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
+      end
+    end
+  end
+end

data/lib/js_test_core/selenium.rb

@@ -0,0 +1,2 @@
+dir = File.dirname(__FILE__)
+require "#{dir}/selenium/selenium_driver"

data/lib/js_test_core/selenium/selenium_driver.rb

@@ -0,0 +1,5 @@
+module Selenium
+  class SeleniumDriver
+    attr_reader :session_id
+  end
+end

data/lib/js_test_core/server.rb

@@ -0,0 +1,111 @@
+module JsTestCore
+  class Server
+    class << self
+      attr_accessor :instance
+
+      def run(spec_root_path, implementation_root_path, public_path, server_options = {})
+        server_options[:Host] ||= DEFAULT_HOST
+        server_options[:Port] ||= DEFAULT_PORT
+        @instance = new(spec_root_path, implementation_root_path, public_path, server_options[:Host], server_options[:Port])
+        instance.run server_options
+      end
+
+      def spec_root_path; instance.spec_root_path; end
+      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
+    end
+
+    attr_reader :host, :port, :spec_root_path, :implementation_root_path, :public_path
+
+    def initialize(spec_root_path, implementation_root_path, public_path, host=DEFAULT_HOST, port=DEFAULT_PORT)
+      dir = ::File.dirname(__FILE__)
+      @spec_root_path = ::File.expand_path(spec_root_path)
+      @implementation_root_path = ::File.expand_path(implementation_root_path)
+      @public_path = ::File.expand_path(public_path)
+      @host = host
+      @port = port
+    end
+
+    def run(options)
+      server = ::Thin::Server.new(options[:Host], options[:Port], self)
+      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
+
+    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.rb

@@ -0,0 +1,3 @@
+dir = File.dirname(__FILE__)
+require "#{dir}/thin/js_test_core_connection"
+require "#{dir}/thin/backends/js_test_core_server"

data/lib/js_test_core/thin/backends/js_test_core_server.rb

@@ -0,0 +1,9 @@
+module Thin
+  module Backends
+    class JsTestCoreServer < TcpServer
+      def connect
+        @signature = EventMachine.start_server(@host, @port, JsTestCoreConnection, &method(:initialize_connection))
+      end
+    end
+  end
+end

data/lib/js_test_core/thin/js_test_core_connection.rb

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

data/spec/spec_suite.rb

@@ -0,0 +1,2 @@
+dir = File.dirname(__FILE__)
+raise "Failure" unless system(%Q|ruby #{dir}/unit_suite.rb|)

data/spec/unit/js_spec/client_spec.rb

@@ -0,0 +1,137 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../unit_spec_helper")
+
+module JsTestCore
+  describe Client do
+    describe '.run' do
+      describe 'when successful' do
+        before do
+          request = Object.new
+          mock(request).post("/runners/firefox", "selenium_host=localhost&selenium_port=4444")
+          response = Object.new
+          mock(response).body {""}
+          mock(Net::HTTP).start(DEFAULT_HOST, DEFAULT_PORT).yields(request) {response}
+          stub(Client).puts
+        end
+
+        it "returns true" do
+          Client.run.should be_true
+        end
+
+        it "prints 'SUCCESS'" do
+          mock(Client).puts("SUCCESS")
+          Client.run
+        end
+      end
+
+      describe 'when unsuccessful' do
+        before do
+          request = Object.new
+          mock(request).post("/runners/firefox", "selenium_host=localhost&selenium_port=4444")
+          response = Object.new
+          mock(response).body {"the failure message"}
+          mock(Net::HTTP).start(DEFAULT_HOST, DEFAULT_PORT).yields(request) {response}
+          stub(Client).puts
+        end
+
+        it "returns false" do
+          Client.run.should be_false
+        end
+
+        it "prints 'FAILURE' and the error message(s)" do
+          mock(Client).puts("FAILURE")
+          mock(Client).puts("the failure message")
+          Client.run
+        end
+      end
+
+      describe "arguments" do
+        attr_reader :request, :response
+        before do
+          @request = Object.new
+          @response = Object.new
+          mock(response).body {""}
+          mock(Net::HTTP).start(DEFAULT_HOST, DEFAULT_PORT).yields(request) {response}
+          stub(Client).puts
+        end
+
+        describe "when passed a custom spec_url" do
+          it "passes the spec_url as a post parameter" do
+            spec_url = 'http://foobar.com/foo'
+            mock(request).post(
+              "/runners/firefox",
+              "selenium_host=localhost&selenium_port=4444&spec_url=#{CGI.escape(spec_url)}"
+            )
+            Client.run(:spec_url => spec_url)
+          end
+        end
+
+        describe "when passed a custom selenium host" do
+          it "passes the selenium_host as a post parameter" do
+            selenium_host = 'test-runner'
+            mock(request).post(
+              "/runners/firefox",
+              "selenium_host=test-runner&selenium_port=4444"
+            )
+            Client.run(:selenium_host => selenium_host)
+          end
+        end
+
+        describe "when passed a custom selenium port" do
+          it "passes the selenium_port as a post parameter" do
+            selenium_port = 5000
+            mock(request).post(
+              "/runners/firefox",
+              "selenium_host=localhost&selenium_port=5000"
+            )
+            Client.run(:selenium_port => selenium_port)
+          end
+        end
+      end
+
+    end
+    
+    describe ".run_argv" do
+      attr_reader :request, :response
+      before do
+          @request = Object.new
+          @response = Object.new
+          mock(response).body {""}
+          mock(Net::HTTP).start(DEFAULT_HOST, DEFAULT_PORT).yields(request) {response}
+          stub(Client).puts
+        end
+
+      describe "when passed a custom spec_url" do
+        it "passes the spec_url as a post parameter" do
+          spec_url = 'http://foobar.com/foo'
+          mock(request).post(
+            "/runners/firefox",
+            "selenium_host=localhost&selenium_port=4444&spec_url=#{CGI.escape(spec_url)}"
+          )
+          Client.run_argv(['--spec_url', spec_url])
+        end
+      end
+
+      describe "when passed a custom selenium host" do
+        it "passes the selenium_host as a post parameter" do
+          selenium_host = 'test-runner'
+          mock(request).post(
+            "/runners/firefox",
+            "selenium_host=test-runner&selenium_port=4444"
+          )
+          Client.run_argv(['--selenium_host', selenium_host])
+        end
+      end
+
+      describe "when passed a custom selenium port" do
+        it "passes the selenium_port as a post parameter" do
+          selenium_port = 5000
+          mock(request).post(
+            "/runners/firefox",
+            "selenium_host=localhost&selenium_port=5000"
+          )
+          Client.run_argv(['--selenium_port', selenium_port.to_s])
+        end
+      end
+    end
+  end
+end

data/spec/unit/js_spec/rails_server_spec.rb

@@ -0,0 +1,45 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../unit_spec_helper")
+
+module JsTestCore
+  describe RailsServer do
+    it "subclasses Server" do
+      RailsServer.superclass.should == Server
+    end
+
+    describe ".run" do
+      attr_reader :rails_root
+      before do
+        @rails_root = "/rails/root"
+        Server.instance = nil
+      end
+
+      it "initializes the RailsServer and runs the Thin Handler and sets Server.instance to the RailsServer instance" do
+        host = DEFAULT_HOST
+        port = DEFAULT_PORT
+        server_instance = nil
+        mock.proxy(RailsServer).new(
+          rails_root,
+          host,
+          port
+        ) do |new_instance|
+          server_instance = new_instance
+        end
+
+        mock(EventMachine).run.yields
+        mock(EventMachine).start_server(host, port, ::Thin::JsTestCoreConnection)
+        RailsServer.run(rails_root)
+        Server.instance.should == server_instance
+      end
+    end
+
+    describe "#initialize" do
+      it "sets the server paths based on the passed in rails root" do
+        rails_root = "/rails/root"
+        server = RailsServer.new(rails_root)
+        server.spec_root_path.should == "#{rails_root}/spec/javascripts"
+        server.implementation_root_path.should == "#{rails_root}/public/javascripts"
+        server.public_path.should == "#{rails_root}/public"
+      end
+    end
+  end
+end