btakita-screw-unit-server 0.3.0 → 0.6.0

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/server_spec.rb

@@ -2,130 +2,65 @@ require File.expand_path("#{File.dirname(__FILE__)}/../unit_spec_helper")
 
 module JsTestCore
   describe Server do
-    attr_reader :result
-    
-    before do
-      @result = ""
-      stub(EventMachine).send_data do |signature, data, data_length|
-        @result << data
-      end
-      stub(EventMachine).close_connection
-    end
-
-    describe "HTTP GET" do
-      specify "'/core/JsTestCore.js', returns the contents of the file" do
-        response = get("/core/JsTestCore.js")
-        response.body.should == ::File.read("#{Server.core_path}/JsTestCore.js")
-      end
-
-      specify "'/stylesheets/example.css', returns the contents of the file" do
-        response = get("/stylesheets/example.css")
-        response.body.should == ::File.read("#{Server.public_path}/stylesheets/example.css")
-      end
-
-      specify "'/invalid/path', shows the full invalid path in the error message" do
-        lambda do
-          get("/invalid/path")
-        end.should raise_error(Exception, Regexp.new("/invalid/path"))
-      end
-    end
-
-    describe ".run" do
-      attr_reader :server_instance
+    describe ".cli" do
+      attr_reader :server, :builder, :stdout, :rackup_path
       before do
-        @server_instance = Server.instance
-        Server.instance = nil
-      end
-
-      it "instantiates an instance of Server and starts a Rack Thin handler" do
-        host = DEFAULT_HOST
-        port = DEFAULT_PORT
+        @server = Server.new
+        @builder = "builder"
 
-        mock(EventMachine).run.yields
-        mock(EventMachine).start_server(host, port, ::Thin::JsTestCoreConnection)
+        @stdout = StringIO.new
+        Server.const_set(:STDOUT, stdout)
 
-        Server.run(spec_root_path, implementation_root_path, public_path)
+        @rackup_path = File.expand_path("#{File.dirname(__FILE__)}/../../../standalone.ru")
       end
 
-      it "when passed a custom host and port, sets the host and port to the passed in value" do
-        host = 'foobar.com'
-        port = 80
-
-        mock(EventMachine).run.yields
-        mock(EventMachine).start_server(host, port, ::Thin::JsTestCoreConnection)
-
-        Server.run(spec_root_path, implementation_root_path, public_path, {:Host => host, :Port => port})
+      after do
+        Server.__send__(:remove_const, :STDOUT)
       end
-    end
 
-    describe ".spec_root" do
-      it "returns the Dir " do
-        Server.spec_root_path.should == spec_root_path
-      end
-    end
+      
+      context "when the --framework-name and --framework-path are set" do
+        it "starts the server and sets SpecFile::suite_representation_class to be the ScrewUnit suite" do
+          project_spec_dir = File.expand_path("#{File.dirname(__FILE__)}/../..")
 
-    describe ".spec_root_path" do
-      it "returns the absolute path of the specs root directory" do
-        Server.spec_root_path.should == spec_root_path
-      end
-    end
+          mock.proxy(Thin::Runner).new(["--port", "8081", "--rackup", rackup_path, "start"]) do |runner|
+            mock(runner).run!
+          end
 
-    describe ".public_path" do
-      it "returns the expanded path of the public path" do
-        Server.public_path.should == public_path
-      end
-    end
+          stub.proxy(Rack::Builder).new do |builder|
+            mock.proxy(builder).use(JsTestCore::App)
+            stub.proxy(builder).use
+            mock(builder).run(is_a(JsTestCore::App))
+            mock(builder).run(is_a(Sinatra::Application))
+          end
 
-    describe ".core_path" do
-      it "returns the expanded path to the JsTestCore core directory" do
-        Server.core_path.should == core_path
-      end
-    end
+          server.cli(
+            "--framework-name", "screw-unit",
+            "--framework-path", "#{project_spec_dir}/example_framework",
+            "--root-path", "#{project_spec_dir}/example_root",
+            "--spec-path", "#{project_spec_dir}/example_spec",
+            "--port", "8081"
+          )
 
-    describe ".implementation_root_path" do
-      it "returns the expanded path to the JsTestCore implementations directory" do
-        dir = ::File.dirname(__FILE__)
-        Server.implementation_root_path.should == implementation_root_path
+          JsTestCore::Configuration.instance.suite_representation_class.should == JsTestCore::Representations::Suites::ScrewUnit
+        end
       end
-    end
 
-    describe "#call" do
-      describe "when there is an error" do
-        attr_reader :top_line_of_backtrace
-        before do
-          @top_line_of_backtrace = __LINE__ + 2
-          stub.instance_of(Resources::WebRoot).locate('somedir') do
-            raise "Foobar"
-          end
-        end
+      context "when the --framework-name or --framework-path are not set" do
+        it "raises an ArgumentError" do
+          lambda do
+            server.cli
+          end.should raise_error(ArgumentError)
 
-        it "shows the full request path in the error message" do
           lambda do
-            get('/somedir')
-          end.should raise_error(Exception, Regexp.new("/somedir"))
-        end
+            server.cli("--framework-name", "screw-unit")
+          end.should raise_error(ArgumentError)
 
-        it "uses the backtrace from where the original error was raised" do
-          no_error = true
-          begin
-            get('/somedir')
-          rescue Exception => e
-            no_error = false
-            top_of_backtrace = e.backtrace.first.split(":")
-            backtrace_file = ::File.expand_path(top_of_backtrace[0])
-            backtrace_line = Integer(top_of_backtrace[1])
-            backtrace_file.should == __FILE__
-            backtrace_line.should == top_line_of_backtrace
-          end
-          raise "There should have been an error" if no_error
+          lambda do
+            server.cli("--framework-path", "/path/to/framework")
+          end.should raise_error(ArgumentError)
         end
       end
     end
-
-    describe "#root_url" do
-      it "returns the url of the site's root" do
-        server.root_url.should == "http://#{server.host}:#{server.port}"
-      end
-    end
   end
 end

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

@@ -1,125 +1,30 @@
 require "rubygems"
 require "spec"
+require "spec/autorun"
+require "rack/test"
+require "rr"
+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 "thin"
+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
+  config.mock_with RR::Adapters::Rspec
 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/standalone.ru

@@ -0,0 +1 @@
+JsTestCore::Server.instance.standalone_rackup(self)

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

@@ -0,0 +1,77 @@
+Lucky Luciano, is a library that makes it easy to organize your Sinatra routes into Restful Resources.
+
+You can define Resources with a base route, and then map relative routes in the Resource.
+The base route and the relative route are simply merged to create the full route.
+
+    module Resource
+      class Users < LuckyLuciano::Resource
+        map "/users"
+        include UserAuthentication
+
+        get "/" do
+        end
+
+        get "/:user_id" do
+        end
+
+        post "/" do
+        end
+
+        put "/:user_id" do
+          require_login
+          # ...
+        end
+
+        delete "/:user_id" do
+          require_login
+          # ...
+        end
+      end
+
+      class UserComments < LuckyLuciano::Resource
+        map "/users/:user_id/comments"
+        include UserAuthentication
+
+        get "/" do
+        end
+
+        get "/:comment_id" do
+        end
+
+        post "/" do
+          require_login
+          # ...
+        end
+      end
+    end
+
+
+You can map the Resource to the Sinatra application by registering the route_handler.
+
+    class YourApp < Sinatra::Base
+      register(UsersResource.route_handler)
+      register(UserCommentsResource.route_handler)
+    end
+
+Lucky Luciano also provides a named-route scheme, which is easy to search for in the code-base.
+It is rather verbose and ideas are welcome to shorten it, while maintaining searchability and simplicity.
+
+    <a href="<%= Resource::Users.path("/:user_id", :user_id => @user.id, :additional_param => "param 1") %>">Bob</a>
+    a "Bob", :href => Resource::Users.path("/:user_id", :user_id => @user.id, :additional_param => "param 1")
+
+    <a href="<%= Resource::UserComments.path("/:comment_id", :user_id => @user.id, :comment_id => @comment.id, :additional_param => "param 1") %>">Bob's Comment</a>
+    a "Bob's Comment", :href => Resource::UserComments.path("/:comment_id", :user_id => @user.id, :comment_id => @comment.id, :additional_param => "param 1")
+
+Compare with Rails named routes
+
+    <a href="<%= user_path(:user_id => @user, :additional_param => "param 1") %>">Bob</a>
+    a "Bob", :href => user_path(:user_id => @user, :additional_param => "param 1")
+
+    <a href="<%= user_comment_path(:user_id => @user.id, :comment_id => @comment.id, :additional_param => "param 1") %>">Bob's Comment</a>
+    a "Bob's Comment", :href => user_comment_path(@user, @comment)
+
+## 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