screw-unit-server 0.3.0 → 0.5.3

data/vendor/js-test-core/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/vendor/js-test-core/spec/example_public/javascripts/large_file.js

@@ -0,0 +1,59 @@
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////
+//////////////////////////////////////////////

data/vendor/js-test-core/spec/example_public/javascripts/subdir/bar.js

@@ -0,0 +1 @@
+var bar = true;

data/vendor/js-test-core/spec/example_specs/custom_dir_and_suite/passing_spec.js

@@ -0,0 +1,6 @@
+require("/javascripts/foo");
+describe("A passing spec", {
+	'passes': function() {
+		value_of(Foo.value).should_be(true);
+	}
+})

data/vendor/js-test-core/spec/example_specs/custom_suite.html

@@ -0,0 +1,8 @@
+<html>
+<head>
+  <title>Custom Suite</title>
+</head>
+<body>
+
+</body>
+</html>

data/vendor/js-test-core/spec/example_specs/foo/failing_spec.js

@@ -1,4 +1,4 @@
-require("/implementations/foo");
+require("/javascripts/foo");
 describe("A failing spec in foo", {
 	'fails': function() {
 		value_of(Foo.value).should_be(false);

data/vendor/js-test-core/spec/example_specs/foo/passing_spec.js

@@ -1,4 +1,4 @@
-require("/implementations/foo");
+require("/javascripts/foo");
 describe("A passing spec", {
 	'passes': function() {
 		value_of(Foo.value).should_be(true);

data/vendor/js-test-core/spec/spec_helpers/be_http.rb

@@ -0,0 +1,32 @@
+module BeHttp
+  include Spec::Matchers
+  def be_http(status, headers, body)
+    SimpleMatcher.new(nil) do |given, matcher|
+      description = (<<-DESC).gsub(/^ +/, "")
+      be an http of
+      expected status: #{status.inspect}
+      actual status  : #{given.status.inspect}
+
+      expected headers containing: #{headers.inspect}
+      actual headers             : #{given.headers.inspect}
+
+      expected body containing: #{body.inspect}
+      actual body             : #{given.body.inspect}
+      DESC
+      matcher.failure_message = description
+      matcher.negative_failure_message = "not #{description}"
+
+      passed = true
+      unless given.status == status
+        passed = false
+      end
+      unless headers.all?{|k, v| given.headers[k] == headers[k]}
+        passed = false
+      end
+      unless body.is_a?(Regexp) ? given.body =~ body : given.body.include?(body)
+        passed = false
+      end
+      passed
+    end
+  end
+end

data/vendor/js-test-core/spec/spec_helpers/example_group.rb

@@ -0,0 +1,36 @@
+class Spec::ExampleGroup
+  class << self
+    def macro(name, &block)
+      eigen do
+        define_method(name, &block)
+      end
+    end
+
+    def eigen(&block)
+      eigen_class = (class << self; self; end)
+      eigen_class.class_eval(&block)
+      eigen_class
+    end
+  end
+  
+  include Rack::Test::Methods
+  include BeHttp
+  attr_reader :core_path, :spec_root_path, :public_path, :server, :connection
+  before(:all) do
+    dir = File.dirname(__FILE__)
+    @core_path = File.expand_path("#{LIBRARY_ROOT_DIR}/spec/example_core")
+    @spec_root_path = File.expand_path("#{LIBRARY_ROOT_DIR}/spec/example_specs")
+    @public_path = File.expand_path("#{LIBRARY_ROOT_DIR}/spec/example_public")
+    stub(Thread).start.yields
+  end
+
+  before(:each) do
+    JsTestCore::Configuration.instance.spec_root_path = spec_root_path
+    JsTestCore::Configuration.instance.public_path = public_path
+    JsTestCore::Configuration.instance.core_path = core_path
+  end
+
+  def app
+    Sinatra::Application
+  end
+end

data/vendor/js-test-core/spec/spec_helpers/fake_selenium_driver.rb

@@ -0,0 +1,27 @@
+class FakeSeleniumDriver
+  SESSION_ID = "DEADBEEF"
+  attr_reader :session_id
+
+  def initialize
+    @session_id = nil
+  end
+
+  def start
+    @session_id = SESSION_ID
+  end
+
+  def stop
+    @session_id = nil
+  end
+
+  def open(url)
+  end
+
+  def create_cookie(key_value, options="")
+
+  end
+
+  def session_started?
+    !!@session_id
+  end
+end

data/vendor/js-test-core/spec/spec_helpers/show_test_exceptions.rb

@@ -0,0 +1,22 @@
+class ShowTestExceptions
+  attr_reader :app
+
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    app.call(env)
+  rescue StandardError, LoadError, SyntaxError => e
+    body = [
+        e.message,
+        e.backtrace.join("\n\t")
+      ].join("\n")
+    [
+      500,
+      {"Content-Type" => "text",
+       "Content-Length" => body.size.to_s},
+      body
+    ]
+  end
+end

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

@@ -3,135 +3,190 @@ require File.expand_path("#{File.dirname(__FILE__)}/../unit_spec_helper")
 module JsTestCore
   describe Client do
     describe '.run' do
-      describe 'when successful' 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
-          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
+          mock_post_to_runner("*firefox")
+          mock_polling_returns([running_status, running_status, success_status])
         end
 
-        it "returns true" do
-          Client.run.should be_true
+        it "reports success" do
+          Client.run
+          stdout.string.strip.should == "SUCCESS"
         end
 
-        it "prints 'SUCCESS'" do
-          mock(Client).puts("SUCCESS")
-          Client.run
+        it "returns true" do
+          Client.run.should be_true
         end
       end
 
-      describe 'when unsuccessful' do
+      context "when the Session run ends in 'failure'" do
+        attr_reader :failure_reason
         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
+          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 "prints 'FAILURE' and the error message(s)" do
-          mock(Client).puts("FAILURE")
-          mock(Client).puts("the failure message")
-          Client.run
-        end
+        it "reports the reason for failure"
       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)
+      context "when the Session is not found" do
+        it "raises a SessionNotFound error" do
+          mock_post_to_runner("*firefox")
+          mock(request).get(Resources::SeleniumSession.path(":session_id", :session_id => "my_session_id")) do
+            stub(session_response = Object.new).code {"404"}
+            session_response
           end
+          lambda {Client.run}.should raise_error(Client::SessionNotFound)
         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
+      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
 
-        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
+      context "when passed-in a timeout" do
+        it "wraps a timeout around the run" do
+          mock.proxy(Timeout).timeout(5)
+          mock_post_to_runner("*firefox")
+          mock_polling_returns([running_status, running_status, success_status])
+          Client.run(:timeout => 5)
         end
       end
 
+      context "when not passed-in a timeout" do
+        it "does not wrap a timeout around the run" do
+          dont_allow(Timeout).timeout
+          mock_post_to_runner("*firefox")
+          mock_polling_returns([running_status, running_status, success_status])
+          Client.run
+        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(Resources::SeleniumSession.path, "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(Resources::SeleniumSession.path(":session_id", :session_id => "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::SeleniumSession::RUNNING}"
+      end
+
+      def success_status
+        "status=#{Resources::SeleniumSession::SUCCESSFUL_COMPLETION}"
+      end
+
+      def failure_status(reason)
+        "status=#{Resources::SeleniumSession::FAILURE_COMPLETION}&reason=#{reason}"
+      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
+        stub(Client).puts
+      end
+
+      context "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 a custom spec_url" do
+      context "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(request).post(
-            "/runners/firefox",
-            "selenium_host=localhost&selenium_port=4444&spec_url=#{CGI.escape(spec_url)}"
-          )
-          Client.run_argv(['--spec_url', spec_url])
+          mock(Client).run(:spec_url => spec_url)
+          client = Client.run_argv(['--spec_url', spec_url])
         end
       end
 
-      describe "when passed a custom selenium host" do
+      context "when passed-in Hash contains :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])
+          mock(Client).run(:selenium_host => selenium_host)
+          client = Client.run_argv(['--selenium_host', selenium_host])
         end
       end
 
-      describe "when passed a custom selenium port" do
+      context "when passed-in Hash contains :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])
+          selenium_port = "5000"
+          mock(Client).run(:selenium_port => selenium_port)
+          client = Client.run_argv(['--selenium_port', selenium_port])
         end
       end
+
+      context "when passed-in Hash contains :timeout" do
+        it "passes the timeout as a post parameter" do
+          mock(Client).run(:timeout => 5)
+          client = Client.run_argv(['--timeout', "5"])
+        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