screw-unit-server 0.3.0 → 0.5.3

data/vendor/js-test-core/spec/unit/js_test_core/resources/spec_file_spec.rb

@@ -0,0 +1,120 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../unit_spec_helper")
+
+module JsTestCore
+  module Resources
+    describe SpecFile do
+      describe "Files" do
+        describe "GET /specs/failing_spec" do
+          it "renders a suite only for failing_spec.js as text/html" do
+            absolute_path = "#{spec_root_path}/failing_spec.js"
+
+            response = get(SpecFile.path("failing_spec"))
+            response.should be_http(
+              200,
+              {
+                "Content-Type" => "text/html",
+                "Last-Modified" => ::File.mtime(absolute_path).rfc822
+              },
+              ""
+            )
+            doc = Nokogiri::HTML(response.body)
+            js_files = doc.search("script").map {|script| script["src"]}
+            js_files.should include("/specs/failing_spec.js")
+          end
+        end
+
+        describe "GET /specs/failing_spec.js" do
+          it "renders the contents of failing_spec.js as text/javascript" do
+            absolute_path = "#{spec_root_path}/failing_spec.js"
+
+            response = get(SpecFile.path("failing_spec.js"))
+            response.should be_http(
+              200,
+              {
+                "Content-Type" => "text/javascript",
+                "Last-Modified" => ::File.mtime(absolute_path).rfc822
+              },
+              ::File.read(absolute_path)
+            )
+          end
+        end
+
+        describe "GET /specs/custom_suite" do
+          it "renders the custom_suite.html file" do
+            path = "#{spec_root_path}/custom_suite.html"
+
+            response = get(SpecFile.path("custom_suite.html"))
+            response.should be_http(
+              200,
+              {
+                "Content-Type" => "text/html",
+                "Last-Modified" => ::File.mtime(path).rfc822
+              },
+              ::File.read(path)
+            )
+          end
+        end
+      end
+
+      describe "Directories" do
+        describe "GET /specs" do
+          macro "renders a suite for all specs" do |relative_path|
+            it "renders a suite for all specs" do
+              path = "#{spec_root_path}"
+
+              response = get(relative_path)
+              response.should be_http(
+                200,
+                {
+                  "Content-Type" => "text/html",
+                  "Last-Modified" => ::File.mtime(path).rfc822
+                },
+                ""
+              )
+              doc = Nokogiri::HTML(response.body)
+              js_files = doc.search("script").map {|script| script["src"]}
+              js_files.should include("/specs/failing_spec.js")
+              js_files.should include("/specs/custom_dir_and_suite/passing_spec.js")
+              js_files.should include("/specs/foo/passing_spec.js")
+              js_files.should include("/specs/foo/failing_spec.js")
+            end
+          end
+
+          send("renders a suite for all specs", SpecFile.path)
+          send("renders a suite for all specs", SpecFile.path("/"))
+        end
+
+        describe "GET /specs/foo" do
+          it "renders a spec suite that includes all of the javascript spec files in the directory" do
+            path = "#{spec_root_path}/foo"
+
+            response = get(SpecFile.path("foo"))
+            response.should be_http(
+              200,
+              {
+                "Content-Type" => "text/html",
+                "Last-Modified" => ::File.mtime(path).rfc822
+              },
+              ""
+            )
+            doc = Nokogiri::HTML(response.body)
+            js_files = doc.search("script").map {|script| script["src"]}
+            js_files.should include("/specs/foo/passing_spec.js")
+            js_files.should include("/specs/foo/failing_spec.js")
+          end
+        end
+      end
+
+      describe "GET /specs/i_dont_exist" do
+        it "renders a 404" do
+          response = get(SpecFile.path("i_dont_exist"))
+          response.should be_http(
+            404,
+            {},
+            "/specs/i_dont_exist not found"
+          )
+        end
+      end
+    end
+  end
+end

data/vendor/js-test-core/spec/unit/js_test_core/resources/web_root_spec.rb

@@ -3,100 +3,25 @@ require File.expand_path("#{File.dirname(__FILE__)}/../../unit_spec_helper")
 module JsTestCore
   module Resources
     describe WebRoot do
-      attr_reader :web_root
-      before(:each) do
-        @web_root = WebRoot.new(public_path)
-      end
-
-      describe "#locate" do
-        describe "when passed ''" do
-          it "returns self" do
-            web_root.locate('').should == web_root
-          end
-        end
-
-        describe "when passed 'core'" do
-          it "returns a Dir representing the JsTestCore core directory" do
-            runner = web_root.locate('core')
-            runner.should == Resources::Dir.new(JsTestCore::Server.core_path, '/core')
-          end
-        end
-
-        describe "when passed 'implementations'" do
-          it "returns a Dir representing the javascript implementations directory" do
-            runner = web_root.locate('implementations')
-            runner.should == Resources::Dir.new(JsTestCore::Server.implementation_root_path, '/implementations')
-          end
-        end
-
-        describe "when passed 'results'" do
-          it "returns a Suite" do
-            runner = web_root.locate('suites')
-            runner.should == Resources::Suite
-          end
-        end
-
-        describe "when passed 'runners'" do
-          it "returns a Runner" do
-            runner = web_root.locate('runners')
-            runner.should be_instance_of(Resources::Runners)
-          end
-        end
-
-        describe "when passed a directory that is in the public_path" do
-          it "returns a Dir representing that directory" do
-            runner = web_root.locate('stylesheets')
-            runner.should == Resources::Dir.new("#{JsTestCore::Server.public_path}/stylesheets", '/stylesheets')
-          end
-        end
-
-        describe "when passed a file that is in the public_path" do
-          it "returns a File representing that file" do
-            runner = web_root.locate('robots.txt')
-            runner.should == Resources::File.new("#{JsTestCore::Server.public_path}/robots.txt", '/robots.txt')
-          end
-        end
-
-        describe "when passed an invalid option" do
-          it "returns a 404 response" do
-            resource = web_root.locate('invalid')
-            
-          end
+      macro("includes a link to the spec suite") do |relative_path|
+        it "includes a link to the spec suite" do
+          response = get(relative_path)
+          response.should be_http(
+            200,
+            {},
+            ""
+          )
+          doc = Nokogiri::HTML(response.body)
+          doc.css("a[href='/specs']").should_not be_nil
         end
       end
 
-      describe ".dispatch_specs" do
-        describe "#get" do
-          attr_reader :request, :response
-          before do
-            @request = Rack::Request.new({'rack.input' => StringIO.new("")})
-            @response = Rack::Response.new
-          end
-
-          it "redirects to /specs" do
-            WebRoot.dispatch_specs
-
-            web_root.get(request, response)
-            response.should be_redirect
-            response.headers["Location"].should == "/specs"
-          end
-        end
-
-        describe "#locate /specs" do
-          it "dispatches to a Spec::SpecDir" do
-            WebRoot.dispatch_specs
-
-            resource = web_root.locate('specs')
-            resource.should == spec_dir('')
-          end
-        end
-
+      describe "GET " do
+        send("includes a link to the spec suite", "")
       end
 
-      describe "when .dispatch_specs is not called" do
-        it "does not cause #locate to dispatch to /specs" do
-          web_root.locate('specs').should be_instance_of(FileNotFound)
-        end
+      describe "GET /" do
+        send("includes a link to the spec suite", "/")
       end
     end
   end

data/vendor/js-test-core/spec/unit/js_test_core/selenium_server_configuration_spec.rb

@@ -0,0 +1,49 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../unit_spec_helper")
+
+module JsTestCore
+  describe SeleniumServerConfiguration do
+    describe '#query_string' do
+      context "when not passed explicit options" do
+        it "defaults selenium_browser_start_command to '*firefox' and selenium_host to 'localhost' and selenium_port to 4444 and ignores spec_url" do
+          configuration = SeleniumServerConfiguration.new
+          configuration.query_string.should include("selenium_browser_start_command=#{CGI.escape("*firefox")}")
+          configuration.query_string.should include("selenium_host=localhost")
+          configuration.query_string.should include("selenium_port=4444")
+          configuration.query_string.should_not include("spec_url")
+        end
+      end
+
+      context "when passed explicit options" do
+        attr_reader :configuration, :selenium_browser_start_command, :selenium_host, :selenium_port, :spec_url
+        before do
+          @selenium_browser_start_command = "*iexplore"
+          @selenium_host = "google.com"
+          @selenium_port = "4332"
+          @spec_url = "http://foobar.com/foo"
+          @configuration = SeleniumServerConfiguration.new(
+            :selenium_browser_start_command => selenium_browser_start_command,
+            :selenium_host => selenium_host,
+            :selenium_port => selenium_port,
+            :spec_url => spec_url
+          )
+        end
+
+        it "sets the selenium_browser_start_command option" do
+          configuration.query_string.should include("selenium_browser_start_command=#{CGI.escape(selenium_browser_start_command)}")
+        end
+
+        it "sets the selenium_host option" do
+          configuration.query_string.should include("selenium_host=#{selenium_host}")
+        end
+
+        it "sets the selenium_port option" do
+          configuration.query_string.should include("selenium_port=#{selenium_port}")
+        end
+
+        it "sets the spec_url option" do
+          configuration.query_string.should include("spec_url=#{spec_url}")
+        end
+      end
+    end
+  end
+end

data/vendor/js-test-core/spec/unit/unit_spec_helper.rb

@@ -1,125 +1,28 @@
 require "rubygems"
 require "spec"
+require "spec/autorun"
+require "rack/test"
+ARGV.push("-b")
 
 dir = File.dirname(__FILE__)
-$LOAD_PATH.unshift "#{dir}/../../lib"
+LIBRARY_ROOT_DIR = File.expand_path("#{dir}/../..")
+$LOAD_PATH.unshift File.expand_path("#{LIBRARY_ROOT_DIR}/lib")
 require "js_test_core"
-require "hpricot"
+require "nokogiri"
 require "guid"
+require "#{LIBRARY_ROOT_DIR}/spec/spec_helpers/be_http"
+require "#{LIBRARY_ROOT_DIR}/spec/spec_helpers/example_group"
+require "#{LIBRARY_ROOT_DIR}/spec/spec_helpers/fake_selenium_driver"
+require "#{LIBRARY_ROOT_DIR}/spec/spec_helpers/show_test_exceptions"
 
 Spec::Runner.configure do |config|
   config.mock_with :rr
 end
 
-module Spec
-  module Matchers
-    class Exist
-      def matches?(actual)
-        @actual = actual
-        !@actual.nil?
-      end
-    end
-  end
-end
-
-class Spec::Example::ExampleGroup
-  class << self
-    def thin_logging
-      @thin_logging = true if @thin_logging.nil?
-      @thin_logging
-    end
-
-    attr_writer :thin_logging
-  end
-end
-
-class JsTestCoreTestDir < JsTestCore::Resources::Dir
-  def get(request, response)
-
-  end
-end
-
-module Spec::Example::ExampleMethods
-  attr_reader :core_path, :spec_root_path, :implementation_root_path, :public_path, :server, :connection
-  before(:all) do
-    dir = File.dirname(__FILE__)
-    @core_path = File.expand_path("#{dir}/../example_core")
-    JsTestCore.core_path = core_path
-    @spec_root_path = File.expand_path("#{dir}/../example_specs")
-    @implementation_root_path = File.expand_path("#{dir}/../example_public/javascripts")
-    @public_path = File.expand_path("#{dir}/../example_public")
-  end
-
-  before(:each) do
-    JsTestCore::Server.instance = JsTestCore::Server.new(spec_root_path, implementation_root_path, public_path)
-    stub(EventMachine).run do
-      raise "You need to mock calls to EventMachine.run or the process will hang"
-    end
-    stub(EventMachine).start_server do
-      raise "You need to mock calls to EventMachine.start_server or the process will hang"
-    end
-    stub(EventMachine).send_data do
-      raise "Calls to EventMachine.send_data must be mocked or stubbed"
-    end
-    @connection = Thin::JsTestCoreConnection.new(Guid.new)
-    stub(EventMachine).send_data {raise "EventMachine.send_data must be handled"}
-    stub(EventMachine).close_connection {raise "EventMachine.close_connection must be handled"}
-    @server = JsTestCore::Server.instance
-    Thin::Logging.silent = !self.class.thin_logging
-    Thin::Logging.debug = self.class.thin_logging
-  end
-
-  after(:each) do
-    JsTestCore::Resources::WebRoot.dispatch_strategy = nil
-    Thin::Logging.silent = true
-    Thin::Logging.debug = false
-  end
+Sinatra::Application.use ShowTestExceptions
+Sinatra::Application.set :raise_errors, true
+Sinatra::Application.set :show_exceptions, false
+JsTestCore::App.set :raise_errors, true
+JsTestCore::App.set :show_exceptions, false
 
-  def get(url, params={})
-    request(:get, url, params)
-  end
-
-  def post(url, params={})
-    request(:post, url, params)
-  end
-
-  def put(url, params={})
-    request(:put, url, params)
-  end
-
-  def delete(url, params={})
-    request(:delete, url, params)
-  end
-
-  def env_for(method, url, params)
-    Rack::MockRequest.env_for(url, params.merge({:method => method.to_s.upcase, 'js_test_core.connection' => connection}))
-  end
-
-  def create_request(method, url, params={})
-    env = env_for(method, url, params)
-    server.call(env)[2]
-  end
-  alias_method :request, :create_request
-
-  def spec_file(relative_path)
-    absolute_path = spec_root_path + relative_path
-    JsTestCore::Resources::File.new(absolute_path, "/specs#{relative_path}")
-  end
-
-  def spec_dir(relative_path="")
-    absolute_path = spec_root_path + relative_path
-    JsTestCore::Resources::Specs::SpecDir.new(absolute_path, "/specs#{relative_path}")
-  end
-
-  def contain_spec_file_with_correct_paths(path_relative_to_spec_root)
-    expected_absolute_path = spec_root_path + path_relative_to_spec_root
-    expected_relative_path = "/specs" + path_relative_to_spec_root
-
-    ::Spec::Matchers::SimpleMatcher.new(expected_relative_path) do |globbed_files|
-      file = globbed_files.find do |file|
-        file.absolute_path == expected_absolute_path
-      end
-      file && file.relative_path == expected_relative_path
-    end
-  end
-end
+Sinatra::Application.use(JsTestCore::App)

data/vendor/js-test-core/vendor/lucky-luciano/README.markdown

@@ -0,0 +1,7 @@
+Lucky Luciano, is a library that makes it easy to organize your Sinatra routes into Restful Resources.
+
+## Who was this Lucky Luciano person?
+
+Lucky Luciano was a mob boss and an alleged friend of Frank Sinatra.
+
+http://news.bbc.co.uk/2/hi/special_report/1998/05/98/sinatra/94360.stm

data/vendor/js-test-core/vendor/lucky-luciano/lib/lucky_luciano.rb

@@ -0,0 +1,4 @@
+require "sinatra/base"
+
+dir = File.dirname(__FILE__)
+require "#{dir}/lucky_luciano/resource"

data/vendor/js-test-core/vendor/lucky-luciano/lib/lucky_luciano/resource.rb

@@ -0,0 +1,135 @@
+module LuckyLuciano
+  class Resource
+    class << self
+      attr_reader :base_path_definition
+
+      def map(base_path_definition)
+        @base_path_definition = base_path_definition
+      end
+
+      def recorded_http_handlers
+        @recorded_http_handlers ||= []
+      end
+
+      def route_handler
+        create_sinatra_handler
+      end
+
+      ["get", "put", "post", "delete"].each do |http_verb|
+        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        def #{http_verb}(relative_path, opts={}, &block)
+          recorded_http_handlers << [:#{http_verb}, relative_path, opts, block]
+        end
+        RUBY
+      end
+
+      def path(*sub_paths)
+        params = sub_paths.last.is_a?(Hash) ? sub_paths.pop : {}
+
+        sub_path_definition = sub_paths.join("/")
+
+        full_path = "#{base_path(params)}/#{path_from_definition(sub_path_definition, params)}".
+          gsub("//", "/").gsub(/\/$/, "")
+
+        base_path_param_keys = param_keys_from(base_path_definition)
+        query_params = params.delete_if do |key, value|
+          base_path_param_keys.include?(key)
+        end
+
+        sub_path_param_keys = param_keys_from(sub_path_definition)
+        query_params = params.delete_if do |key, value|
+          sub_path_param_keys.include?(key)
+        end
+
+        if query_params.empty?
+          full_path
+        else
+          query = build_query(query_params)
+          "#{full_path}?#{query}"
+        end
+      end
+
+      def base_path(params={})
+        path_from_definition(base_path_definition, params)
+      end
+
+      protected
+
+      def path_from_definition(definition, params={})
+        param_keys = param_keys_from(definition)
+        if param_keys.empty?
+          definition.dup
+        else
+          param_keys.each do |base_path_param|
+            unless params.include?(base_path_param.to_sym)
+              raise ArgumentError, "Expected #{base_path_param.inspect} to have a value"
+            end
+          end
+          definition.split("/").map do |segment|
+            if param_key = segment_param_key(segment)
+              params[param_key]
+            else
+              segment
+            end
+          end.join("/")
+        end
+      end
+
+      def param_keys_from(definition)
+        definition.split("/").find_all do |segment|
+          segment_param_key(segment)
+        end.map do |param|
+          param[1..-1].to_sym
+        end
+      end
+
+      def segment_param_key(segment)
+        segment[0..0] == ':' ? segment[1..-1].to_sym : nil
+      end
+
+      def build_query(params)
+        params.to_a.inject([]) do |splatted_params, (key, value)|
+          [value].flatten.each do |value_in_param|
+            splatted_params << "#{URI.escape(key.to_s)}=#{URI.escape(value_in_param.to_s)}"
+          end
+          splatted_params
+        end.join("&")
+      end
+
+      def create_sinatra_handler
+        handlers = recorded_http_handlers
+        resource_class = self
+        Module.new do
+          (class << self; self; end).class_eval do
+            define_method(:registered) do |app|
+              handlers.each do |handler|
+                verb, relative_path, opts, block = handler
+                full_path = "#{resource_class.base_path_definition}/#{relative_path}".
+                  gsub("//", "/").gsub(%r{^.+/$}) do |match|
+                    match.gsub(%r{/$}, "")
+                  end
+                app.send(verb, full_path, opts) do
+                  resource_class.new(self).instance_eval(&block)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    attr_reader :app
+
+    def initialize(app)
+      @app = app
+    end
+
+    def method_missing(method_name, *args, &block)
+      if app.respond_to?(method_name)
+        app.send(method_name, *args, &block)
+      else
+        super
+      end
+    end
+  end
+end