jasmine 1.2.0 → 1.2.1

data/spec/dependencies_spec.rb

@@ -85,7 +85,7 @@ if Jasmine::Dependencies.rspec2?
         context "when rails 3 is present and the application pipeline is in use" do
           before do
             Gem::Specification.should_receive(:find_by_name).with("rails", ">= 3.0").and_return(true)
-            application.stub(:assets).and_return(rails_application_assets) 
+            application.stub(:assets).and_return(rails_application_assets)
           end
           let(:rails3_present) { true }
           let(:respond_to_application) { true }
@@ -95,7 +95,7 @@ if Jasmine::Dependencies.rspec2?
         context "when rails 3 is present and the application pipeline is not in use" do
           before do
             Gem::Specification.should_receive(:find_by_name).with("rails", ">= 3.0").and_return(true)
-            application.stub(:assets).and_return(rails_application_assets) 
+            application.stub(:assets).and_return(rails_application_assets)
           end
           let(:rails3_present) { true }
           let(:respond_to_application) { true }
@@ -105,7 +105,7 @@ if Jasmine::Dependencies.rspec2?
         context "when rails 3 is present but not loaded" do
           before do
             Gem::Specification.should_receive(:find_by_name).with("rails", ">= 3.0").and_return(true)
-            application.stub(:assets).and_return(rails_application_assets) 
+            application.stub(:assets).and_return(rails_application_assets)
           end
           let(:rails3_present) { true }
           let(:respond_to_application) { false }
@@ -232,5 +232,16 @@ if Jasmine::Dependencies.rspec2?
       end
     end
 
+    describe "legacy_rack?" do
+      it "should return false if Rack::Server exists" do
+        Rack.stub(:constants).and_return([:Server])
+        Jasmine::Dependencies.legacy_rack?.should be_false
+      end
+      it "should return true if Rack::Server does not exist" do
+        Rack.stub(:constants).and_return([])
+        Jasmine::Dependencies.legacy_rack?.should be_true
+      end
+    end
   end
+
 end

data/spec/jasmine_self_test_spec.rb

@@ -1,23 +1,23 @@
 require 'spec_helper'
 require 'jasmine_self_test_config'
 
-jasmine_config = JasmineSelfTestConfig.new
-spec_builder = Jasmine::SpecBuilder.new(jasmine_config)
+jasmine_runner_config = Jasmine::RunnerConfig.new(JasmineSelfTestConfig.new)
+server = Jasmine::Server.new(jasmine_runner_config.port, Jasmine::Application.app(jasmine_runner_config))
+client = Jasmine::SeleniumDriver.new(jasmine_runner_config.browser,
+                                     "#{jasmine_runner_config.jasmine_host}:#{jasmine_runner_config.port}/")
 
-should_stop = false
-
-if Jasmine::Dependencies.rspec2?
-  RSpec.configuration.after(:suite) do
-    spec_builder.stop if should_stop
-  end
-else
-  Spec::Runner.configure do |config|
-    config.after(:suite) do
-      spec_builder.stop if should_stop
-    end
+t = Thread.new do
+  begin
+    server.start
+  rescue ChildProcess::TimeoutError
   end
+  # # ignore bad exits
 end
+t.abort_on_exception = true
+Jasmine::wait_for_listener(jasmine_runner_config.port, "jasmine server")
+puts "jasmine server started."
 
-spec_builder.start
-should_stop = true
-spec_builder.declare_suites
+results_processor = Jasmine::ResultsProcessor.new(jasmine_runner_config)
+results = Jasmine::Runners::HTTP.new(client, results_processor).run
+formatter = Jasmine::RspecFormatter.new
+formatter.format_results(results)

data/spec/page_spec.rb

@@ -10,7 +10,7 @@ describe Jasmine::Page do
                      :css_files => ["file1.css", "file2.css"],
                      :jasmine_files => ["jasmine_file1.js", "jasmine_file2.js"])
     end
-    let(:context) { fake_config.instance_eval { binding } }
+    let(:context) { fake_config }
     let(:page) { Jasmine::Page.new(context) }
     it "should render javascript files in the correct order" do
       js_files = subject.css("script")

data/spec/results_processor_spec.rb

@@ -0,0 +1,3 @@
+describe Jasmine::ResultsProcessor do
+
+end

data/spec/results_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Jasmine::Results do
+  it "should be able to return suites" do
+    suites = {:some => 'suite'}
+    Jasmine::Results.new({}, suites, {}).suites.should == suites
+  end
+
+  it "should return a result for a particular spec id" do
+    result1 = {:some => 'result'}
+    result2 = {:some => 'other result'}
+    raw_results = {'1' => result1, '2' => result2 }
+    results = Jasmine::Results.new(raw_results, {}, {})
+    results.for_spec_id('1').should == result1
+    results.for_spec_id('2').should == result2
+  end
+
+  it "should return an example location for a particular string" do
+    example_location1 = {:some => 'spec location'}
+    example_location2 = {:some => 'other spec location'}
+    example_locations = {'foo bar' => example_location1, 'baz quux' => example_location2 }
+    results = Jasmine::Results.new({}, {}, example_locations)
+    results.example_location_for('foo bar').should == example_location1
+    results.example_location_for('baz quux').should == example_location2
+  end
+end
+

data/spec/rspec_formatter_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe Jasmine::RspecFormatter do
+  describe "environment variables" do
+    def stub_env_hash(hash)
+      ENV.stub!(:[]) do |arg|
+        hash[arg]
+      end
+    end
+    describe "browser configuration" do
+      it "should use firefox by default" do
+        pending
+        stub_env_hash({"JASMINE_BROWSER" => nil})
+        config = double('config')
+        formatter = Jasmine::RspecFormatter.new(config)
+        Jasmine::SeleniumDriver.should_receive(:new).
+          with("firefox", anything).
+          and_return(mock(Jasmine::SeleniumDriver, :connect => true))
+        formatter.start
+      end
+
+      it "should use ENV['JASMINE_BROWSER'] if set" do
+        pending
+        stub_env_hash({"JASMINE_BROWSER" => "mosaic"})
+
+        Jasmine::SeleniumDriver.should_receive(:new).
+          with("mosaic", anything).
+          and_return(mock(Jasmine::SeleniumDriver, :connect => true))
+        formatter.start
+      end
+    end
+
+    describe "jasmine host" do
+      it "should use http://localhost by default" do
+        pending
+        stub_env_hash({})
+        config = Jasmine::Config.new
+        config.instance_variable_set(:@jasmine_server_port, '1234')
+        config.stub!(:start_jasmine_server)
+
+        Jasmine::SeleniumDriver.should_receive(:new).
+          with(anything, "http://localhost:1234/").
+          and_return(mock(Jasmine::SeleniumDriver, :connect => true))
+        config.start
+      end
+
+      it "should use ENV['JASMINE_HOST'] if set" do
+        pending
+        stub_env_hash({"JASMINE_HOST" => "http://some_host"})
+        config = Jasmine::Config.new
+        config.instance_variable_set(:@jasmine_server_port, '1234')
+        config.stub!(:start_jasmine_server)
+
+        Jasmine::SeleniumDriver.should_receive(:new).
+          with(anything, "http://some_host:1234/").
+          and_return(mock(Jasmine::SeleniumDriver, :connect => true))
+        config.start
+      end
+
+      it "should use ENV['JASMINE_PORT'] if set" do
+        pending
+        stub_env_hash({"JASMINE_PORT" => "4321"})
+        config = Jasmine::Config.new
+        Jasmine.stub!(:wait_for_listener)
+        config.stub!(:start_server)
+        Jasmine::SeleniumDriver.should_receive(:new).
+          with(anything, "http://localhost:4321/").
+          and_return(mock(Jasmine::SeleniumDriver, :connect => true))
+        config.start
+      end
+    end
+
+    describe "external selenium server" do
+      it "should use an external selenium server if SELENIUM_SERVER is set" do
+        pending
+        stub_env_hash({"SELENIUM_SERVER" => "http://myseleniumserver.com:4441"})
+        Selenium::WebDriver.should_receive(:for).with(:remote, :url => "http://myseleniumserver.com:4441", :desired_capabilities => :firefox)
+        Jasmine::SeleniumDriver.new('firefox', 'http://localhost:8888')
+      end
+      it "should use an local selenium server with a specific port if SELENIUM_SERVER_PORT is set" do
+        pending
+        stub_env_hash({"SELENIUM_SERVER_PORT" => "4441"})
+        Selenium::WebDriver.should_receive(:for).with(:remote, :url => "http://localhost:4441/wd/hub", :desired_capabilities => :firefox)
+        Jasmine::SeleniumDriver.new('firefox', 'http://localhost:8888')
+      end
+    end
+  end
+end

data/spec/runner_config_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+require 'selenium-webdriver'
+
+describe Jasmine::RunnerConfig do
+  describe "css_files" do
+    it "should return the jasmine stylesheets and any user defined stylesheets" do
+      jasmine_stylesheets = ['some/css/file']
+      user_stylesheets = ['some/user/file']
+      user_config = double("config", :jasmine_stylesheets => jasmine_stylesheets, :user_stylesheets => user_stylesheets)
+      Jasmine::RunnerConfig.new(user_config).css_files.should == jasmine_stylesheets + user_stylesheets
+    end
+  end
+
+  describe "jasmine_files" do
+    it "should return the jasmine files from the config" do
+      jasmine_files = ['some/file']
+      user_config = double('config', :jasmine_javascripts => jasmine_files)
+      Jasmine::RunnerConfig.new(user_config).jasmine_files.should == jasmine_files
+    end
+  end
+
+  describe "js_files" do
+    it "should return the user js files from the config" do
+      js_files = ['some/file']
+      user_config = double('config', :js_files => js_files)
+      Jasmine::RunnerConfig.new(user_config).js_files.should == js_files
+    end
+  end
+
+  describe "spec_files" do
+    it "should return the user spec_files from the config" do
+      spec_files = ['some/file']
+      user_config = double('config', :spec_files => spec_files)
+      Jasmine::RunnerConfig.new(user_config).spec_files.should == spec_files
+    end
+  end
+
+  describe "spec_files_full_paths" do
+    it "should return the user spec_files_full_paths from the config" do
+      spec_files_full_paths = ['some/file_path']
+      user_config = double('config', :spec_files_full_paths => spec_files_full_paths)
+      Jasmine::RunnerConfig.new(user_config).spec_files_full_paths.should == spec_files_full_paths
+    end
+  end
+
+  describe "spec_path" do
+    it "should return the user spec_path from the config" do
+      spec_path = ['some/path']
+      user_config = double('config', :spec_path => spec_path)
+      Jasmine::RunnerConfig.new(user_config).spec_path.should == spec_path
+    end
+  end
+
+  describe "spec_dir" do
+    it "should return the user spec_dir from the config" do
+      spec_dir = ['some/dir']
+      user_config = double('config', :spec_dir => spec_dir)
+      Jasmine::RunnerConfig.new(user_config).spec_dir.should == spec_dir
+    end
+  end
+
+  describe "src_dir" do
+    it "should return the user src_dir from the config" do
+      src_dir = ['some/dir']
+      user_config = double('config', :src_dir => src_dir)
+      Jasmine::RunnerConfig.new(user_config).src_dir.should == src_dir
+    end
+  end
+
+  describe "project_root" do
+    it "should return the user project_root from the config" do
+      project_root = ['some/dir']
+      user_config = double('config', :project_root => project_root)
+      Jasmine::RunnerConfig.new(user_config).project_root.should == project_root
+    end
+  end
+
+  describe "root_path" do
+    it "should return the user root_path from the config" do
+      root_path = ['some/path']
+      user_config = double('config', :root_path => root_path)
+      Jasmine::RunnerConfig.new(user_config).root_path.should == root_path
+    end
+  end
+
+  describe "browser" do
+    it "should default to firefox" do
+      Jasmine::RunnerConfig.new.browser.should == 'firefox'
+    end
+
+    it "should use ENV['JASMINE_BROWSER'] if it exists" do
+      ENV.stub(:[], "JASMINE_BROWSER").and_return("foo")
+      Jasmine::RunnerConfig.new.browser.should == 'foo'
+    end
+  end
+
+  describe "jasmine_host" do
+    it "should default to localhost" do
+      Jasmine::RunnerConfig.new.jasmine_host.should == 'http://localhost'
+    end
+
+    it "should use ENV['JASMINE_HOST'] if it exists" do
+      ENV.stub(:[], "JASMINE_HOST").and_return("foo")
+      Jasmine::RunnerConfig.new.jasmine_host.should == 'foo'
+    end
+  end
+
+  describe "port" do
+    it "should find an unused port" do
+      Jasmine.should_receive(:find_unused_port).and_return('1234')
+      Jasmine::RunnerConfig.new.port.should == '1234'
+    end
+
+    it "should use ENV['JASMINE_PORT'] if it exists" do
+      ENV.stub(:[], "JASMINE_PORT").and_return("foo")
+      Jasmine::RunnerConfig.new.port.should == 'foo'
+    end
+
+    it "should cache port" do
+      config = Jasmine::RunnerConfig.new
+      Jasmine.stub(:find_unused_port).and_return('1234')
+      config.port.should == '1234'
+      Jasmine.stub(:find_unused_port).and_return('4321')
+      config.port.should == '1234'
+    end
+
+
+  end
+
+end
+

data/spec/server_spec.rb

@@ -1,95 +1,48 @@
 require 'spec_helper'
-require 'rack/test'
 
-describe "Jasmine.app" do
-  include Rack::Test::Methods
-
-  def app
-    config = Jasmine::Config.new
-    @root = File.join(File.dirname(__FILE__))
-    config.stub!(:project_root).and_return(@root)
-    config.stub!(:spec_dir).and_return(File.join(@root, "fixture", "spec"))
-    config.stub!(:src_dir).and_return(File.join(@root, "fixture", "src"))
-    config.stub!(:src_files).and_return(["file1.js"])
-    config.stub!(:spec_files).and_return(["file2.js"])
-    Jasmine.app(config)
-  end
-
-  it "includes no-cache headers for specs" do
-    get "/__spec__/example_spec.js"
-    last_response.headers.should have_key("Cache-Control")
-    last_response.headers["Cache-Control"].should == "max-age=0, private, must-revalidate"
-  end
-
-  it "should serve static files from spec dir under __spec__" do
-    get "/__spec__/example_spec.js"
-    last_response.status.should == 200
-    last_response.content_type.should == "application/javascript"
-    last_response.body.should == File.read(File.join(@root, "fixture/spec/example_spec.js"))
+describe Jasmine::Server do
+  describe "rack ~> 1.0" do
+    before do
+      Jasmine::Dependencies.stub(:legacy_rack?).and_return(true)
     end
 
-  it "should serve static files from root dir under __root__" do
-    get "/__root__/fixture/src/example.js"
-    last_response.status.should == 200
-    last_response.content_type.should == "application/javascript"
-    last_response.body.should == File.read(File.join(@root, "fixture/src/example.js"))
-  end
-
-  it "should serve static files from src dir under /" do
-    get "/example.js"
-    last_response.status.should == 200
-    last_response.content_type.should == "application/javascript"
-    last_response.body.should == File.read(File.join(@root, "fixture/src/example.js"))
-  end
-
-  it "should serve Jasmine static files under /__JASMINE_ROOT__/" do
-    get "/__JASMINE_ROOT__/jasmine.css"
-    last_response.status.should == 200
-    last_response.content_type.should == "text/css"
-    last_response.body.should == File.read(File.join(Jasmine::Core.path, "jasmine.css"))
-  end
-
-  it "should serve focused suites when prefixing spec files with /__suite__/" do
-    pending "Temporarily removing this feature (maybe permanent)"
-    Dir.stub!(:glob).and_return { |glob_string| [glob_string] }
-    get "/__suite__/file2.js"
-    last_response.status.should == 200
-    last_response.content_type.should == "text/html"
-    last_response.body.should include("\"/__spec__/file2.js")
-  end
-
-  it "should redirect /run.html to /" do
-    get "/run.html"
-    last_response.status.should == 302
-    last_response.location.should == "/"
+    it "should run the handler with the application" do
+      server = double(:server)
+      port = 1234
+      application = double(:application)
+      Rack::Handler.should_receive(:get).with("webrick").and_return(server)
+      server.should_receive(:run).with(application, hash_including(:Port => port))
+      Jasmine::Server.new(port, application).start
+    end
   end
 
-  it "should 404 non-existent files" do
-    get "/some-non-existent-file"
-    last_response.should be_not_found
-  end
+  describe "rack >= 1.1" do
+    before do
+      Jasmine::Dependencies.stub(:legacy_rack?).and_return(false)
+      if !Rack.constants.include?(:Server)
+        Rack::Server = double("Rack::Server")
+      end
+    end
 
-  describe "/ page" do
-    it "should load each js file in order" do
-      get "/"
-      last_response.status.should == 200
-      last_response.body.should include("\"/file1.js")
-      last_response.body.should include("\"/__spec__/file2.js")
-      last_response.body.should satisfy {|s| s.index("/file1.js") < s.index("/__spec__/file2.js") }
+    it "should create a Rack::Server with the correct port when passed" do
+      port = 1234
+      Rack::Server.should_receive(:new).with(hash_including(:Port => port)).and_return(double(:server).as_null_object)
+      Jasmine::Server.new(port).start
     end
 
-    it "should return an empty 200 for HEAD requests to /" do
-      head "/"
-      last_response.status.should == 200
-      last_response.headers['Content-Type'].should == 'text/html'
-      last_response.body.should == ''
+    it "should start the server" do
+      server = double(:server)
+      Rack::Server.should_receive(:new) { server.as_null_object }
+      server.should_receive(:start)
+      Jasmine::Server.new.start
     end
 
-    it "should tell the browser not to cache any assets" do
-      head "/"
-      ['Pragma'].each do |key|
-        last_response.headers[key].should == 'no-cache'
-      end
+    it "should set the app as the instance variable on the rack server" do
+      app = double('application')
+      server = double(:server)
+      Rack::Server.should_receive(:new) { server.as_null_object }
+      Jasmine::Server.new(1234, app).start
+      server.instance_variable_get(:@app).should == app
     end
   end
 end