jasmine 2.0.0.rc2 → 2.0.0.rc3

data/lib/jasmine/version.rb

@@ -1,3 +1,3 @@
 module Jasmine
-  VERSION = "2.0.0.rc2"
+  VERSION = "2.0.0.rc3"
 end

data/spec/configuration_spec.rb

@@ -87,7 +87,6 @@ describe Jasmine::Configuration do
       map['some/path'].should be
       map['some/path'].call.should == result
     end
-
   end
 
   describe 'rack apps' do
@@ -106,46 +105,6 @@ describe Jasmine::Configuration do
     end
   end
 
-  describe 'port' do
-    it 'returns new port and caches return value' do
-      config = Jasmine::Configuration.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
-    it 'returns port if configured' do
-      config = Jasmine::Configuration.new()
-      config.port = '5678'
-      Jasmine.stub(:find_unused_port).and_return('1234')
-      config.port.should == '5678'
-    end
-  end
-
-  describe 'browser' do
-    it 'should default to firefox' do
-      Jasmine::Configuration.new().browser.should == 'firefox'
-    end
-
-    it 'returns browser if set' do
-      config = Jasmine::Configuration.new()
-      config.browser = 'foo'
-      config.browser.should == 'foo'
-    end
-  end
-
-  describe 'result_batch_size' do
-    it 'should default to 50' do
-      Jasmine::Configuration.new().result_batch_size.should == 50
-    end
-
-    it 'returns result_batch_size if set' do
-      config = Jasmine::Configuration.new()
-      config.result_batch_size = 25
-      config.result_batch_size.should == 25
-    end
-  end
-
   describe 'host' do
     it 'should default to localhost' do
       Jasmine::Configuration.new().host.should == 'http://localhost'
@@ -158,55 +117,44 @@ describe Jasmine::Configuration do
     end
   end
 
-  describe 'selenium config' do
-    it 'returns server if set' do
-      config = Jasmine::Configuration.new()
-      config.selenium_server = 'fish'
-      config.selenium_server.should == 'fish'
-
-      config.selenium_server_port = 'turnip'
-      config.selenium_server_port.should == 'turnip'
-    end
-  end
-
-  describe 'junit xml' do
+  describe 'spec format' do
     it 'returns value if set' do
       config = Jasmine::Configuration.new()
-
-      config.junit_xml_path = 'turnip'
-      config.junit_xml_path.should == 'turnip'
+      config.spec_format = 'fish'
+      config.spec_format.should == 'fish'
     end
+  end
 
-    it 'returns defaults' do
+  describe 'jasmine ports' do
+    it 'returns new CI port and caches return value' do
       config = Jasmine::Configuration.new()
-
-      config.junit_xml_path.should == Dir.getwd
+      Jasmine.stub(:find_unused_port).and_return('1234')
+      config.port(:ci).should == '1234'
+      Jasmine.stub(:find_unused_port).and_return('4321')
+      config.port(:ci).should == '1234'
     end
-  end
 
-  describe 'spec format' do
-    it 'returns value if set' do
+    it 'returns ci port if configured' do
       config = Jasmine::Configuration.new()
-      config.spec_format = 'fish'
-      config.spec_format.should == 'fish'
+      config.ci_port = '5678'
+      Jasmine.stub(:find_unused_port).and_return('1234')
+      config.port(:ci).should == '5678'
     end
-  end
 
-  describe 'jasmine ports' do
-    it 'returns value if set' do
+    it 'returns configured server port' do
       config = Jasmine::Configuration.new()
-      config.jasmine_port = 'fish'
-      config.jasmine_port.should == 'fish'
+      config.server_port = 'fish'
+      config.port(:server).should == 'fish'
     end
 
-    it 'returns defaults' do
+    it 'returns default server port' do
       config = Jasmine::Configuration.new()
 
-      config.jasmine_port.should == 8888
+      config.port(:server).should == 8888
     end
   end
 
-  describe 'jasmine ports' do
+  describe 'jasmine formatters' do
     it 'returns value if set' do
       config = Jasmine::Configuration.new()
       config.formatters = ['pants']
@@ -219,5 +167,19 @@ describe Jasmine::Configuration do
       config.formatters.should == [Jasmine::Formatters::Console]
     end
   end
+
+  describe 'custom runner' do
+    it 'stores and returns what is passed' do
+      config = Jasmine::Configuration.new
+      foo = double(:foo)
+      config.runner = foo
+      config.runner.should == foo
+    end
+
+    it 'does nothing by default' do
+      config = Jasmine::Configuration.new
+      config.runner.call('hi')
+    end
+  end
 end
 

data/spec/fixture/coffee_spec.coffee

@@ -0,0 +1,3 @@
+describe "coffee specs", ->
+  it "should work", ->
+    expect(true).toBe true

data/spec/fixture/failing_runner.rb

@@ -0,0 +1,9 @@
+class FailingRunner
+  def run
+    raise
+  end
+end
+
+Jasmine.configure do |config|
+  config.runner = lambda { |_, _| FailingRunner.new }
+end

data/spec/fixture/failing_test.js

@@ -0,0 +1,5 @@
+describe("failing", function() {
+  it('should fail', function() {
+    expect(true).toBe(false);
+  });
+});

data/spec/fixture/large_test_suite_spec.js

@@ -0,0 +1,20 @@
+function nestedBlock(nestingDepth, index) {
+  if (nestingDepth == 0) {
+    return;
+  } else {
+    describe('Suite ' + index + ' at depth ' + nestingDepth, function() {
+      it('should be a failing test', function() {
+        expect(true).toBe(false);
+      });
+      it('should be a passing test', function() {
+        expect(true).toBe(true);
+      });
+      nestedBlock(nestingDepth - 1, index);
+    });
+  }
+}
+
+for (i=0; i<2000; i++) {
+  nestedBlock(10, i);
+}
+

data/spec/jasmine_command_line_tool_spec.rb

@@ -11,71 +11,113 @@ describe 'Jasmine command line tool' do
   end
 
   describe '.init' do
+    describe 'without a Gemfile' do
       it 'should create files on init' do
         output = capture_stdout { Jasmine::CommandLineTool.new.process ['init'] }
-        output.should =~ /Jasmine has been installed with example specs./
+        output.should =~ /Jasmine has been installed\./
 
-        my_jasmine_lib = File.expand_path(File.join(@root, 'lib'))
-        bootstrap = "$:.unshift('#{my_jasmine_lib}')"
+        File.exists?(File.join(@tmp, 'spec/javascripts/helpers/.gitkeep')).should == true
+        File.exists?(File.join(@tmp, 'spec/javascripts/support/jasmine.yml')).should == true
+        File.exists?(File.join(@tmp, 'Rakefile')).should == true
+        ci_output = `rake --trace jasmine:ci`
+        ci_output.should =~ (/0 specs, 0 failures/)
+      end
+
+      it 'should create a new Rakefile if it does not exist' do
+        output = capture_stdout { Jasmine::CommandLineTool.new.process ["init"] }
+        output.should =~ /Jasmine has been installed\./
+        File.read(File.join(@tmp, 'Rakefile')).should include('jasmine.rake')
+      end
 
-        ENV['JASMINE_GEM_PATH'] = "#{@root}/lib"
-        ci_output = `rake -E "#{bootstrap}" --trace jasmine:ci`
-        ci_output.should =~ (/[1-9][0-9]* specs, 0 failures/)
+      it "should append to an existing Rakefile" do
+        FileUtils.cp("#{@old_dir}/spec/fixture/Rakefile", @tmp)
+        output = capture_stdout { Jasmine::CommandLineTool.new.process ["init"] }
+        output.should =~ /Jasmine has been installed\./
+        File.read(File.join(@tmp, 'Rakefile')).should include('jasmine_flunk')
       end
+    end
 
-      describe 'with a Gemfile containing Rails' do
-          before :each do
-              open(File.join(@tmp, "Gemfile"), 'w') do |f|
-                  f.puts "rails"
-              end
-          end
-
-          it 'should warn the user' do
-            output = capture_stdout { 
-                expect {
-                    Jasmine::CommandLineTool.new.process ['init']
-                }.to raise_error SystemExit
-            }
-            output.should =~ /attempting to run jasmine init in a Rails project/
-
-            Dir.entries(@tmp).sort.should == [".", "..", "Gemfile"]
-          end
-          
-          it 'should allow the user to override the warning' do
-            output = capture_stdout { 
-                expect {
-                    Jasmine::CommandLineTool.new.process ['init', '--force']
-                }.not_to raise_error
-            }
-            output.should =~ /Jasmine has been installed with example specs./
-
-            Dir.entries(@tmp).sort.should == [".", "..", "Gemfile", "Rakefile", "public", "spec"]
-          end
+    describe 'with a Gemfile containing Rails' do
+      before :each do
+        open(File.join(@tmp, "Gemfile"), 'w') do |f|
+          f.puts "rails"
+        end
       end
-      
-      describe 'with a Gemfile not containing Rails' do
-          before :each do
-              open(File.join(@tmp, "Gemfile"), 'w') do |f|
-                  f.puts "sqlite3"
-              end
-          end
-
-          it 'should perform normally' do
-            output = capture_stdout { 
-                expect {
-                    Jasmine::CommandLineTool.new.process ['init']
-                }.not_to raise_error
-            }
-            output.should =~ /Jasmine has been installed with example specs./
-
-            Dir.entries(@tmp).sort.should == [".", "..", "Gemfile", "Rakefile", "public", "spec"]
-          end
+
+      it 'should warn the user' do
+        output = capture_stdout {
+          expect {
+            Jasmine::CommandLineTool.new.process ['init']
+          }.to raise_error SystemExit
+        }
+        output.should =~ /attempting to run jasmine init in a Rails project/
+
+        Dir.entries(@tmp).sort.should == [".", "..", "Gemfile"]
       end
+
+      it 'should allow the user to override the warning' do
+        output = capture_stdout {
+          expect {
+            Jasmine::CommandLineTool.new.process ['init', '--force']
+          }.not_to raise_error
+        }
+        output.should =~ /Jasmine has been installed\./
+
+        File.exists?(File.join(@tmp, 'spec/javascripts/helpers/.gitkeep')).should == true
+        File.exists?(File.join(@tmp, 'spec/javascripts/support/jasmine.yml')).should == true
+      end
+    end
+
+    describe 'with a Gemfile not containing Rails' do
+      before :each do
+        open(File.join(@tmp, "Gemfile"), 'w') do |f|
+          f.puts "sqlite3"
+        end
+      end
+
+      it 'should perform normally' do
+        output = capture_stdout {
+          expect {
+            Jasmine::CommandLineTool.new.process ['init']
+          }.not_to raise_error
+        }
+        output.should =~ /Jasmine has been installed\./
+
+        File.exists?(File.join(@tmp, 'spec/javascripts/helpers/.gitkeep')).should == true
+        File.exists?(File.join(@tmp, 'spec/javascripts/support/jasmine.yml')).should == true
+      end
+    end
   end
 
+  it 'should install the examples' do
+    output = capture_stdout { Jasmine::CommandLineTool.new.process ['examples'] }
+    output.should =~ /Jasmine has installed some examples\./
+    File.exists?(File.join(@tmp, 'public/javascripts/jasmine_examples/Player.js')).should == true
+    File.exists?(File.join(@tmp, 'public/javascripts/jasmine_examples/Song.js')).should == true
+    File.exists?(File.join(@tmp, 'spec/javascripts/jasmine_examples/PlayerSpec.js')).should == true
+    File.exists?(File.join(@tmp, 'spec/javascripts/helpers/jasmine_examples/SpecHelper.js')).should == true
+
+    capture_stdout { Jasmine::CommandLineTool.new.process ['init'] }
+    ci_output = `rake --trace jasmine:ci`
+    ci_output.should =~ (/[1-9]\d* specs, 0 failures/)
+  end
 
   it 'should include license info' do
     output = capture_stdout { Jasmine::CommandLineTool.new.process ['license'] }
     output.should =~ /Copyright/
   end
+
+  it 'should copy boot.js' do
+    output = capture_stdout { Jasmine::CommandLineTool.new.process ['copy_boot_js'] }
+    output.should =~ /Jasmine has copied an example boot.js to spec\/javascripts\/support/
+
+    File.exists?(File.join(@tmp, 'spec/javascripts/support/boot.js')).should == true
+  end
+
+  it 'should not overwrite an existing boot.js' do
+    capture_stdout { Jasmine::CommandLineTool.new.process ['copy_boot_js'] }
+    output = capture_stdout { Jasmine::CommandLineTool.new.process ['copy_boot_js'] }
+
+    output.should =~ /already exists/
+  end
 end

data/spec/jasmine_pojs_spec.rb

@@ -8,40 +8,56 @@ describe "POJS jasmine install" do
     @install_directory = 'pojs-example'
     Dir::mkdir @install_directory
     Dir::chdir @install_directory
+
+    `jasmine init`
+    `jasmine examples`
   end
 
   after :each do
     temp_dir_after
   end
 
-  context "when the Jasmine generators are available" do
-    before :each do
-      `jasmine init`
-    end
+  it "should find the Jasmine configuration files" do
+    File.exists?("spec/javascripts/support/jasmine.yml").should == true
+  end
 
-    it "should find the Jasmine configuration files" do
-      File.exists?("spec/javascripts/support/jasmine.yml").should == true
-    end
+  it "should find the Jasmine example files" do
+    File.exists?("public/javascripts/jasmine_examples/Player.js").should == true
+    File.exists?("public/javascripts/jasmine_examples/Song.js").should == true
 
-    it "should find the Jasmine example files" do
-      File.exists?("public/javascripts/Player.js").should == true
-      File.exists?("public/javascripts/Song.js").should == true
+    File.exists?("spec/javascripts/jasmine_examples/PlayerSpec.js").should == true
+    File.exists?("spec/javascripts/helpers/jasmine_examples/SpecHelper.js").should == true
 
-      File.exists?("spec/javascripts/PlayerSpec.js").should == true
-      File.exists?("spec/javascripts/helpers/SpecHelper.js").should == true
+    File.exists?("spec/javascripts/support/jasmine.yml").should == true
+  end
 
-      File.exists?("spec/javascripts/support/jasmine.yml").should == true
-    end
+  it "should show jasmine rake task" do
+    output = `rake -T`
+    output.should include("jasmine ")
+    output.should include("jasmine:ci")
+  end
 
-    it "should show jasmine rake task" do
-      output = `rake -T`
-      output.should include("jasmine ")
-      output.should include("jasmine:ci")
-    end
+  it "should successfully run rake jasmine:ci" do
+    output = `rake jasmine:ci`
+    output.should =~ (/[1-9]\d* specs, 0 failures/)
+  end
 
-    it "should successfully run rake jasmine:ci" do
-      output = `rake jasmine:ci`
+  it "should raise an error when jasmine.yml cannot be found" do
+    config_path = 'some/thing/that/doesnt/exist'
+    output = `rake jasmine:ci JASMINE_CONFIG_PATH=#{config_path}`
+    $?.should_not be_success
+    output.should =~ /Unable to load jasmine config from #{config_path}/
+  end
+
+  it "rake jasmine:ci returns proper exit code when the runner raises" do
+    failing_runner = File.join('spec', 'javascripts', 'support', 'failing_runner.rb')
+    failing_yaml = custom_jasmine_config('raises_exception') do |config|
+      config['spec_helper'] = failing_runner
     end
 
+    FileUtils.cp(File.join(@root, 'spec', 'fixture', 'failing_runner.rb'), failing_runner)
+
+    `rake jasmine:ci JASMINE_CONFIG_PATH=#{failing_yaml}`
+    $?.should_not be_success
   end
 end

data/spec/jasmine_rails_spec.rb

@@ -1,7 +1,21 @@
 require 'spec_helper'
+require 'net/http'
+require 'yaml'
 
 if Jasmine::Dependencies.rails_available?
   describe 'A Rails app' do
+    def bundle_install
+      tries_remaining = 3
+      while tries_remaining > 0
+        puts `NOKOGIRI_USE_SYSTEM_LIBRARIES=true bundle install --path vendor;`
+        if $?.success?
+          tries_remaining = 0
+        else
+          tries_remaining -= 1
+          puts "\n\nBundle failed, trying #{tries_remaining} more times\n\n"
+        end
+      end
+    end
 
     before :all do
       temp_dir_before
@@ -12,14 +26,22 @@ if Jasmine::Dependencies.rails_available?
 
       base = File.absolute_path(File.join(__FILE__, '../..'))
 
-      open('Gemfile', 'a') { |f| 
-        f.puts "gem 'jasmine', :path => '#{base}'" 
-        f.puts "gem 'jasmine-core', :github => 'pivotal/jasmine'" 
+      open('Gemfile', 'a') { |f|
+        f.puts "gem 'jasmine', :path => '#{base}'"
+        f.puts "gem 'jasmine-core', :github => 'pivotal/jasmine'"
         f.flush
       }
 
       Bundler.with_clean_env do
-        puts `NOKOGIRI_USE_SYSTEM_LIBRARIES=true bundle install --path vendor;`
+        bundle_install
+        `bundle exec rails g jasmine:install`
+        File.exists?('spec/javascripts/helpers/.gitkeep').should == true
+        File.exists?('spec/javascripts/support/jasmine.yml').should == true
+        `bundle exec rails g jasmine:examples`
+        File.exists?('app/assets/javascripts/jasmine_examples/Player.js').should == true
+        File.exists?('app/assets/javascripts/jasmine_examples/Song.js').should == true
+        File.exists?('spec/javascripts/jasmine_examples/PlayerSpec.js').should == true
+        File.exists?('spec/javascripts/helpers/jasmine_examples/SpecHelper.js').should == true
       end
     end
 
@@ -27,65 +49,83 @@ if Jasmine::Dependencies.rails_available?
       temp_dir_after
     end
 
-    context 'when Jasmine has been required' do
-      it 'should show the Jasmine generators' do
-        Bundler.with_clean_env do
-          output = `bundle exec rails g`
-          output.should include('jasmine:install')
-          output.should include('jasmine:examples')
-        end
+    it 'should have the jasmine & jasmine:ci rake task' do
+      #See https://github.com/jimweirich/rake/issues/220 and https://github.com/jruby/activerecord-jdbc-adapter/pull/467
+      #There's a workaround, but requires setting env vars & jruby opts (non-trivial when inside of a jruby process), so skip for now.
+      pending "activerecord-jdbc + rake -T doesn't work correctly under Jruby" if ENV['RAILS_VERSION'] == 'rails3' && RUBY_PLATFORM == 'java'
+      Bundler.with_clean_env do
+        output = `bundle exec rake -T`
+        output.should include('jasmine ')
+        output.should include('jasmine:ci')
       end
+    end
 
-      it 'should show jasmine:install help' do
-        Bundler.with_clean_env do
-          output = `bundle exec rails g jasmine:install --help`
-          output.should include('rails generate jasmine:install')
-        end
+    it "rake jasmine:ci runs and returns expected results" do
+      Bundler.with_clean_env do
+        output = `bundle exec rake jasmine:ci`
+        output.should include('5 specs, 0 failures')
       end
+    end
 
-      it 'should have the jasmine rake task' do
-        Bundler.with_clean_env do
-          output = `bundle exec rake -T`
-          output.should include('jasmine ')
+    it "rake jasmine:ci returns proper exit code when specs fail" do
+      Bundler.with_clean_env do
+        FileUtils.cp(File.join(@root, 'spec', 'fixture', 'failing_test.js'), File.join('spec', 'javascripts'))
+        failing_yaml = custom_jasmine_config('failing') do |jasmine_config|
+          jasmine_config['spec_files'] << 'failing_test.js'
         end
+        output = `bundle exec rake jasmine:ci JASMINE_CONFIG_PATH=#{failing_yaml}`
+        $?.should_not be_success
+        output.should include('6 specs, 1 failure')
       end
+    end
 
-      it 'should have the jasmine:ci rake task' do
-        Bundler.with_clean_env do
-          output = `bundle exec rake -T`
-          output.should include('jasmine:ci')
-        end
+    it "runs specs written in coffeescript" do
+      coffee_yaml = custom_jasmine_config('coffee') do |jasmine_config|
+        jasmine_config['spec_files'] << 'coffee_spec.coffee'
       end
+      FileUtils.cp(File.join(@root, 'spec', 'fixture', 'coffee_spec.coffee'), File.join('spec', 'javascripts'))
 
-      context 'and then installed' do
-        before :each do
-          Bundler.with_clean_env do
-            @output = `bundle exec rails g jasmine:install`
-          end
-        end
-
-        it 'should have the Jasmine config files' do
-          @output.should include('create')
-
-          File.exists?('spec/javascripts/helpers/.gitkeep').should == true
-          File.exists?('spec/javascripts/support/jasmine.yml').should == true
-        end
+      Bundler.with_clean_env do
+        output = `bundle exec rake jasmine:ci JASMINE_CONFIG_PATH=#{coffee_yaml}`
+        output.should include('6 specs, 0 failures')
       end
+    end
 
-      context 'and the jasmine examples have been installed' do
-        it 'should find the Jasmine example files' do
-          Bundler.with_clean_env do
-            output = `bundle exec rails g jasmine:examples`
-            output.should include('create')
+    it "rake jasmine runs and serves the expected webpage when using asset pipeline" do
+      open('app/assets/stylesheets/foo.css', 'w') { |f|
+        f.puts "/* hi dere */"
+        f.flush
+      }
 
-            File.exists?('app/assets/javascripts/jasmine_examples/Player.js').should == true
-            File.exists?('app/assets/javascripts/jasmine_examples/Song.js').should == true
+      css_yaml = custom_jasmine_config('css') do |jasmine_config|
+        jasmine_config['src_files'] = ['assets/application.js']
+        jasmine_config['stylesheets'] = ['assets/application.css']
+      end
 
-            File.exists?('spec/javascripts/jasmine_examples/PlayerSpec.js').should == true
-            File.exists?('spec/javascripts/helpers/SpecHelper.js').should == true
+      Bundler.with_clean_env do
+        begin
+          pid = IO.popen("bundle exec rake jasmine JASMINE_CONFIG_PATH=#{css_yaml}").pid
+          Jasmine::wait_for_listener(8888, 'jasmine server', 60)
+
+          # if the process we started is not still running, it's very likely this test
+          # will fail because another server is already running on port 8888
+          # (kill -0 will check if you can send *ANY* signal to this process)
+          # (( it does not actually kill the process, that happens below))
+          `kill -0 #{pid}`
+          unless $?.success?
+            puts "someone else is running a server on port 8888"
+            $?.should be_success
+          end
 
-            output = `bundle exec rake jasmine:ci`
-            output.should include('5 specs, 0 failures')
+          output = Net::HTTP.get(URI.parse('http://localhost:8888/'))
+          output.should match(%r{script src.*/assets/jasmine_examples/Player.js})
+          output.should match(%r{script src.*/assets/jasmine_examples/Song.js})
+          output.should match(%r{<link rel=.stylesheet.*?href=./assets/foo.css\?.*?>})
+        ensure
+          Process.kill(:SIGINT, pid)
+          begin
+            Process.waitpid pid
+          rescue Errno::ECHILD
           end
         end
       end