screw-unit-server 0.3.0 → 0.5.3

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

@@ -0,0 +1,44 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../unit_spec_helper")
+
+module JsTestCore
+  describe Configuration do
+    attr_reader :result
+    
+    before do
+      @result = ""
+    end
+
+    describe ".spec_root" do
+      it "returns the Dir " do
+        Configuration.spec_root_path.should == spec_root_path
+      end
+    end
+
+    describe ".spec_root_path" do
+      it "returns the absolute path of the specs root directory" do
+        Configuration.spec_root_path.should == spec_root_path
+      end
+    end
+
+    describe ".public_path" do
+      it "returns the expanded path of the public path" do
+        Configuration.public_path.should == public_path
+      end
+    end
+
+    describe ".core_path" do
+      it "returns the expanded path to the JsTestCore core directory" do
+        Configuration.core_path.should == core_path
+      end
+    end
+
+    describe "#root_url" do
+      it "returns the url of the site's root" do
+        server = Configuration.new
+        server.host = "localhost"
+        server.port = 9999
+        server.root_url.should == "http://localhost:9999"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../unit_spec_helper")
+
+module JsTestCore
+  module Models
+    describe SeleniumSession do
+      attr_reader :driver, :session_id, :selenium_session
+
+      before do
+        @driver = FakeSeleniumDriver.new
+        @selenium_session = SeleniumSession.new(:spec_url => "http://localhost:8080/specs")
+        stub(selenium_session).driver {driver}
+        driver.start
+        @session_id = driver.session_id
+        SeleniumSession.register(selenium_session)
+      end
+
+      describe ".find" do
+        context "when passed an id for which there is a corresponding selenium_session" do
+          it "returns the selenium_session" do
+            SeleniumSession.find(session_id).should == selenium_session
+          end
+        end
+
+        context "when passed an id for which there is no corresponding selenium_session" do
+          it "returns nil" do
+            invalid_id = "666666666666666"
+            SeleniumSession.find(invalid_id).should be_nil
+          end
+        end
+      end
+
+      describe "#running?" do
+        context "when the driver#session_started? is true" do
+          it "returns true" do
+            driver.session_started?.should be_true
+            selenium_session.should be_running
+          end
+        end
+
+        context "when the driver#session_started? is false" do
+          it "returns false" do
+            driver.stop
+            driver.session_started?.should be_false
+            selenium_session.should_not be_running
+          end
+        end
+      end
+
+      describe "#finalize" do
+        attr_reader :selenium_session
+        
+        before do
+          mock.proxy(driver).stop
+        end
+
+        it "kills the browser and stores the #run_result" do
+          run_result = "The session run result"
+          selenium_session.finish(run_result)
+          selenium_session.run_result.should == run_result
+        end
+
+        it "sets #run_result" do
+          selenium_session.finish("the result")
+          selenium_session.run_result.should == "the result"
+        end
+
+        context "when passed an empty string" do
+          it "causes #successful? to be true" do
+            selenium_session.finish("")
+            selenium_session.should be_successful
+            selenium_session.should_not be_failed
+          end
+        end
+
+        context "when passed a non-empty string" do
+          it "causes #successful? to be false" do
+            selenium_session.finish("A bunch of error stuff")
+            selenium_session.should_not be_successful
+            selenium_session.should be_failed
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../unit_spec_helper")
+
+module JsTestCore
+  module Resources
+    describe CoreFile do
+      describe "Files" do
+        describe "GET /core/JsTestCore.js" do
+          it "renders the JsTestCore.js file, which lives in the core framework directory" do
+            absolute_path = "#{core_path}/JsTestCore.js"
+
+            response = get(CoreFile.path("JsTestCore.js"))
+            response.should be_http(
+              200,
+              {
+                "Content-Type" => "text/javascript",
+                "Last-Modified" => ::File.mtime(absolute_path).rfc822
+              },
+              ::File.read(absolute_path)
+            )
+          end
+        end
+      end
+
+      describe "Directories" do
+        macro "returns a page with the files in the root core directory" do |relative_path|
+          it "returns a page with the files in the root core directory" do
+            response = get(CoreFile.path(relative_path))
+            response.should be_http(
+              200,
+              {},
+              ""
+            )
+            doc = Nokogiri::HTML(response.body)
+            links = doc.search("a").map {|script| script["href"]}
+            links.should include("/core/JsTestCore.js")
+            links.should include("/core/JsTestCore.css")
+            links.should include("/core/subdir")
+          end
+        end
+        describe "GET /core" do
+          send("returns a page with the files in the root core directory", "")
+        end
+        describe "GET /core/" do
+          send("returns a page with the files in the root core directory", "/")
+        end
+
+        describe "GET /core/subdir" do
+          it "returns a page with the files in the directory" do
+            response = get(CoreFile.path("subdir"))
+            response.should be_http(
+              200,
+              {},
+              %r(<a href="/core/subdir/SubDirFile.js">SubDirFile.js</a>)
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,84 +3,77 @@ require File.expand_path("#{File.dirname(__FILE__)}/../../unit_spec_helper")
 module JsTestCore
   module Resources
     describe File do
-      attr_reader :request, :file
-
-      before do
-        WebRoot.dispatch_specs
-        stub(EventMachine).send_data
-        stub(EventMachine).close_connection
-        @file = Resources::File.new(absolute_path, relative_path)
-        @request = create_request('get', relative_path)
-      end
-
-      def absolute_path
-        "#{spec_root_path}/failing_spec.js"
-      end
-
-      def relative_path
-        "/specs/failing_spec.js"
-      end
-
-      describe "#absolute_path" do
-        it "returns the absolute path passed into the initializer" do
-          file.absolute_path.should == absolute_path
-        end
-      end
-
-      describe "#relative_path" do
-        it "returns the relative path passed into the initializer" do
-          file.relative_path.should == relative_path
-        end
-      end
-
-      describe "#get" do
-        attr_reader :response
-        before do
-          @response = Rack::Response.new
-        end
-
-        it "returns the contents of the file" do
-          file.get(request, response)
-          response.body.should == ::File.read(absolute_path)
+      describe "Files" do
+        describe "GET /stylesheets/example.css" do
+          it "returns the example.css file content as a css file" do
+            path = "#{public_path}/stylesheets/example.css"
+            response = get("/stylesheets/example.css")
+            response.should be_http(
+              200,
+              {
+                'Content-Length' => ::File.size(path).to_s,
+                'Content-Type' => "text/css",
+                'Last-Modified' => ::File.mtime(path).rfc822
+              },
+              ::File.read(path)
+            )
+          end
         end
 
-        describe "when File has an extension" do
-          describe '.js' do
-            it "sets Content-Type to text/javascript" do
-              file.get(request,response)
-              response.content_type.should == "text/javascript"
-            end
+        describe "GET /javascripts/foo.js" do
+          it "returns the foo.js file content as a javascript file" do
+            path = "#{public_path}/javascripts/foo.js"
+            response = get("/javascripts/foo.js")
+            response.should be_http(
+              200,
+              {
+                'Content-Length' => ::File.size(path).to_s,
+                'Content-Type' => "text/javascript",
+                'Last-Modified' => ::File.mtime(path).rfc822
+              },
+              ::File.read(path)
+            )
           end
+        end
 
-          describe '.css' do
-            it "sets Content-Type to text/css" do
-              file.get(request, response)
-              response.content_type.should == "text/css"
-            end
-
-            def absolute_path
-              "#{core_path}/JsTestCore.css"
-            end
-
-            def relative_path
-              "/core/JsTestCore.css"
-            end
+        describe "GET /javascripts/subdir/bar.js - Subdirectory" do
+          it "returns the subdir/bar.js file content as a javascript file" do
+            path = "#{public_path}/javascripts/subdir/bar.js"
+            response = get("/javascripts/subdir/bar.js")
+            response.should be_http(
+              200,
+              {
+                'Content-Length' => ::File.size(path).to_s,
+                'Content-Type' => "text/javascript",
+                'Last-Modified' => ::File.mtime(path).rfc822
+              },
+              ::File.read(path)
+            )
           end
         end
       end
 
-      describe "==" do
-        it "returns true when passed a file with the same absolute and relative paths" do
-          file.should == Resources::File.new(absolute_path, relative_path)
-        end
-
-        it "returns false when passed a file with a different absolute or relative path" do
-          file.should_not == Resources::File.new(absolute_path, "bogus")
-          file.should_not == Resources::File.new("bogus", relative_path)
+      describe "Directories" do
+        describe "GET /stylesheets - Top level directory" do
+          it "returns a page with a of files in the directory" do
+            response = get("/stylesheets")
+            response.should be_http(
+              200,
+              {},
+              %r(<a href="/stylesheets/example.css">example.css</a>)
+            )
+          end
         end
 
-        it "when passed a Dir, returns false because File is not a Dir" do
-          file.should_not == Resources::Dir.new(absolute_path, relative_path)
+        describe "GET /javascripts/subdir - Subdirectory" do
+          it "returns a page with a of files in the directory" do
+            response = get("/javascripts/subdir")
+            response.should be_http(
+              200,
+              {},
+              %r(<a href="/javascripts/subdir/bar.js">bar.js</a>)
+            )
+          end
         end
       end
     end

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

@@ -0,0 +1,18 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../unit_spec_helper")
+
+module JsTestCore
+  module Resources
+    describe ImplementationsDeprecation do
+      describe "GET /implementations/*" do
+        it "responds with a 301 to /javascripts/*" do
+          response = get(ImplementationsDeprecation.path("/subdir/bar.js"))
+          response.should be_http(
+            301,
+            {'Location' => File.path("/javascripts/subdir/bar.js")},
+            "This page has been moved to #{File.path("/javascripts/subdir/bar.js")}"
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../unit_spec_helper")
+
+module JsTestCore
+  module Resources
+    describe WebRoot do
+      describe "GET / - ResourceNotFound" do
+        it "returns a 404 error" do
+          response = get("/i_dont_exist")
+          response.should be_http(
+            404,
+            {},
+            Regexp.new("File /i_dont_exist not found")
+          )
+        end
+      end
+
+      describe "PUT / - ResourceNotFound" do
+        it "returns a 404 error" do
+          response = put("/i_dont_exist")
+          response.should be_http(
+            404,
+            {},
+            Regexp.new("File /i_dont_exist not found")
+          )
+        end
+      end
+
+      describe "POST / - ResourceNotFound" do
+        it "returns a 404 error" do
+          response = post("/i_dont_exist")
+          response.should be_http(
+            404,
+            {},
+            Regexp.new("File /i_dont_exist not found")
+          )
+        end
+      end
+
+      describe "DELETE / - ResourceNotFound" do
+        it "returns a 404 error" do
+          response = delete("/i_dont_exist")
+          response.should be_http(
+            404,
+            {},
+            Regexp.new("File /i_dont_exist not found")
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,362 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../unit_spec_helper")
+
+module JsTestCore
+  module Resources
+    describe SeleniumSession do
+      attr_reader :request, :driver, :session_id, :selenium_browser_start_command
+
+      def self.before_with_selenium_browser_start_command(selenium_browser_start_command="selenium browser start command")
+        before do
+          @driver = FakeSeleniumDriver.new
+          @session_id = FakeSeleniumDriver::SESSION_ID
+          @selenium_browser_start_command = selenium_browser_start_command
+          stub(Selenium::Client::Driver).new('localhost', 4444, selenium_browser_start_command, 'http://0.0.0.0:8080') do
+            driver
+          end
+        end
+      end
+
+      after do
+        Models::SeleniumSession.send(:instances).clear
+      end
+
+      describe "POST /selenium_sessions" do
+        before_with_selenium_browser_start_command
+        before do
+          stub(Thread).start.yields
+        end
+
+        it "responds with a 200 and the session_id" do
+          Models::SeleniumSession.find(session_id).should be_nil
+          response = post(SeleniumSession.path("/"), {:selenium_browser_start_command => selenium_browser_start_command})
+          body = "session_id=#{session_id}"
+          response.should be_http(
+            200,
+            {'Content-Length' => body.length.to_s},
+            body
+          )
+        end
+
+        it "starts the Selenium Driver, creates a SessionID cookie, and opens the spec page" do
+          mock(driver).start
+          stub(driver).session_id {session_id}
+          mock(driver).create_cookie("session_id=#{session_id}")
+          mock(driver).open("/")
+          mock(driver).open("/specs")
+
+          mock(Selenium::Client::Driver).new('localhost', 4444, selenium_browser_start_command, 'http://0.0.0.0:8080') do
+            driver
+          end
+          response = post(SeleniumSession.path("/"), {:selenium_browser_start_command => selenium_browser_start_command})
+        end
+
+        describe "when a selenium_host parameter is passed into the request" do
+          it "starts the Selenium Driver with the passed in selenium_host" do
+            mock(Selenium::Client::Driver).new('another-machine', 4444, selenium_browser_start_command, 'http://0.0.0.0:8080') do
+              driver
+            end
+            response = post(SeleniumSession.path("/"), {
+              :selenium_browser_start_command => selenium_browser_start_command,
+              :selenium_host => "another-machine"
+            })
+          end
+        end
+
+        describe "when a selenium_host parameter is not passed into the request" do
+          it "starts the Selenium Driver from localhost" do
+            mock(Selenium::Client::Driver).new('localhost', 4444, selenium_browser_start_command, 'http://0.0.0.0:8080') do
+              driver
+            end
+            response = post(SeleniumSession.path("/"), {
+              :selenium_browser_start_command => selenium_browser_start_command,
+              :selenium_host => ""
+            })
+          end
+        end
+
+        describe "when a selenium_port parameter is passed into the request" do
+          it "starts the Selenium Driver with the passed in selenium_port" do
+            mock(Selenium::Client::Driver).new('localhost', 4000, selenium_browser_start_command, 'http://0.0.0.0:8080') do
+              driver
+            end
+            response = post(SeleniumSession.path("/"), {
+              :selenium_browser_start_command => selenium_browser_start_command,
+              :selenium_port => "4000"
+            })
+          end
+        end
+
+        describe "when a selenium_port parameter is not passed into the request" do
+          it "starts the Selenium Driver from localhost" do
+            mock(Selenium::Client::Driver).new('localhost', 4444, selenium_browser_start_command, 'http://0.0.0.0:8080') do
+              driver
+            end
+            response = post(SeleniumSession.path("/"), {
+              :selenium_browser_start_command => selenium_browser_start_command,
+              :selenium_port => ""
+            })
+          end
+        end
+
+        describe "when a spec_url is passed into the request" do
+          it "runs Selenium with the passed in host and part to run the specified spec session in Firefox" do
+            mock(Selenium::Client::Driver).new('localhost', 4444, selenium_browser_start_command, 'http://another-host:8080') do
+              driver
+            end
+            mock(driver).start
+            stub(driver).create_cookie
+            mock(driver).open("/")
+            mock(driver).open("/specs/subdir")
+            mock(driver).session_id {session_id}.at_least(1)
+
+            response = post(SeleniumSession.path("/"), {
+              :selenium_browser_start_command => selenium_browser_start_command,
+              :spec_url => "http://another-host:8080/specs/subdir"
+            })
+          end
+        end
+
+        describe "when a spec_url is not passed into the request" do
+          before do
+            mock(Selenium::Client::Driver).new('localhost', 4444, selenium_browser_start_command, 'http://0.0.0.0:8080') do
+              driver
+            end
+          end
+
+          it "uses Selenium to run the entire spec session in Firefox" do
+            mock(driver).start
+            stub(driver).create_cookie
+            mock(driver).open("/")
+            mock(driver).open("/specs")
+            mock(driver).session_id {session_id}.at_least(1)
+
+            response = post(SeleniumSession.path("/"), {
+              :selenium_browser_start_command => selenium_browser_start_command,
+              :spec_url => ""
+            })
+          end
+        end
+      end
+
+      describe "POST /selenium_sessions/firefox" do
+        before_with_selenium_browser_start_command "*firefox"
+
+        it "creates a selenium_session whose #driver started with '*firefox'" do
+          Models::SeleniumSession.find(session_id).should be_nil
+          response = post(SeleniumSession.path("/firefox"))
+          body = "session_id=#{session_id}"
+          response.should be_http(
+            200,
+            {'Content-Length' => body.length.to_s},
+            body
+          )
+
+          selenium_session = Models::SeleniumSession.find(session_id)
+          selenium_session.class.should == Models::SeleniumSession
+          selenium_session.driver.should == driver
+        end
+      end
+
+      describe "POST /selenium_sessions/iexplore" do
+        before_with_selenium_browser_start_command "*iexplore"
+
+        it "creates a selenium_session whose #driver started with '*iexplore'" do
+          Models::SeleniumSession.find(session_id).should be_nil
+          response = post(SeleniumSession.path("/iexplore"))
+          body = "session_id=#{session_id}"
+          response.should be_http(
+            200,
+            {'Content-Length' => body.length.to_s},
+            body
+          )
+
+          selenium_session = Models::SeleniumSession.find(session_id)
+          selenium_session.class.should == Models::SeleniumSession
+          selenium_session.driver.should == driver
+        end
+      end
+
+      describe "GET /sessions/:session_id" do
+        context "when there is no Runner with the :session_id" do
+          it "responds with a 404" do
+            session_id = "invalid_session_id"
+            response = get(SeleniumSession.path(session_id))
+            response.body.should include("Could not find session #{session_id}")
+            response.status.should == 404
+          end
+        end
+
+        context "when there is a Runner with the :session_id" do
+          attr_reader :driver, :session_id, :session_runner
+          before do
+            @driver = FakeSeleniumDriver.new
+            @session_id = FakeSeleniumDriver::SESSION_ID
+            stub(Selenium::Client::Driver).new('localhost', 4444, '*firefox', 'http://0.0.0.0:8080') do
+              driver
+            end
+
+            post(SeleniumSession.path('firefox'))
+            @session_runner = Models::SeleniumSession.find(session_id)
+            session_runner.should be_running
+          end
+
+          context "when a Runner with the :session_id is running" do
+            it "responds with a 200 and status=running" do
+              response = get(SeleniumSession.path(session_id))
+
+              body = "status=#{SeleniumSession::RUNNING}"
+              response.should be_http(200, {'Content-Length' => body.length.to_s}, body)
+            end
+          end
+
+          context "when a Runner with the :session_id has completed" do
+            context "when the session has a status of 'success'" do
+              before do
+                session_runner.finish("")
+                session_runner.should be_successful
+              end
+
+              it "responds with a 200 and status=success" do
+                response = get(SeleniumSession.path(session_id))
+
+                body = "status=#{SeleniumSession::SUCCESSFUL_COMPLETION}"
+                response.should be_http(200, {'Content-Length' => body.length.to_s}, body)
+              end
+            end
+
+            context "when the session has a status of 'failure'" do
+              attr_reader :reason
+              before do
+                @reason = "Failure stuff"
+                session_runner.finish(reason)
+                session_runner.should be_failed
+              end
+
+              it "responds with a 200 and status=failure and reason" do
+                response = get(SeleniumSession.path(session_id))
+
+                body = "status=#{SeleniumSession::FAILURE_COMPLETION}&reason=#{reason}"
+                response.should be_http(200, {'Content-Length' => body.length.to_s}, body)
+              end
+            end
+          end
+        end
+      end
+
+      describe "finish" do
+        attr_reader :stdout
+        before do
+          @stdout = StringIO.new
+          SeleniumSession.const_set(:STDOUT, stdout)
+        end
+
+        after do
+          SeleniumSession.__send__(:remove_const, :STDOUT)
+        end
+
+        describe "POST /selenium_sessions/finish" do
+          attr_reader :selenium_session
+          context "when passed a :session_id parameter" do
+            context "when :session_id does not match a registered SeleniumSession" do
+              it "returns the text and writes the text to stdout" do
+                Models::SeleniumSession.find(1).should be_nil
+
+                text = "The text in the POST body"
+                response = post(SeleniumSession.path("/finish", :session_id => 1), :text => text)
+                response.should be_http(
+                  200,
+                  {},
+                  text
+                )
+                stdout.string.should == "#{text}\n"
+              end
+            end
+
+            context "when :session_id matches a registered SeleniumSession" do
+              before do
+                @driver = FakeSeleniumDriver.new
+                @selenium_session = Models::SeleniumSession.new(:spec_url => "http://localhost:8080/specs")
+                stub(selenium_session).driver {driver}
+                driver.start
+                @session_id = driver.session_id
+                Models::SeleniumSession.register(selenium_session)
+              end
+
+              it "finishes the SeleniumSession" do
+                text = "The text in the POST body"
+                mock.proxy(selenium_session).finish(text)
+                selenium_session.should be_running
+
+                response = post(SeleniumSession.path("/finish", :session_id => session_id), :text => text)
+                response.should be_http(
+                  200,
+                  {},
+                  text
+                )
+                selenium_session.should_not be_running
+              end
+            end
+          end
+
+          context "when the session_id cookie is set" do
+            context "when :session_id does not match a registered SeleniumSession" do
+              it "returns the text and writes the text to stdout" do
+                Models::SeleniumSession.find(1).should be_nil
+
+                text = "The text in the POST body"
+                response = post(SeleniumSession.path("/finish"), {:text => text}, {:cookie => "session_id=1"})
+                response.should be_http(
+                  200,
+                  {},
+                  text
+                )
+                stdout.string.should == "#{text}\n"
+              end
+            end
+
+            context "when :session_id matches a registered SeleniumSession" do
+              attr_reader :selenium_session
+              before do
+                @driver = FakeSeleniumDriver.new
+                @selenium_session = Models::SeleniumSession.new(:spec_url => "http://localhost:8080/specs")
+                stub(selenium_session).driver {driver}
+                driver.start
+                @session_id = driver.session_id
+                Models::SeleniumSession.register(selenium_session)
+              end
+
+              it "finishes the SeleniumSession" do
+                text = "The text in the POST body"
+                mock.proxy(selenium_session).finish(text)
+                selenium_session.should be_running
+
+                response = post(SeleniumSession.path("/finish"), {:text => text}, {:cookie => "session_id=#{session_id}"})
+                response.should be_http(
+                  200,
+                  {},
+                  text
+                )
+                selenium_session.should_not be_running
+              end
+            end
+          end
+        end
+
+        describe "POST /sessions/:session_id/finish" do
+          it "returns the text and writes the text to stdout" do
+            text = "The text in the POST body"
+
+            response = post(SeleniumSession.path("/:session_id/finish", :session_id => 1), :text => text)
+            response.should be_http(
+              200,
+              {},
+              text
+            )
+            stdout.string.should == "#{text}\n"
+          end
+        end
+
+      end
+    end
+  end
+end