jasmine 2.0.0 → 2.99.0

data/spec/jasmine_rails_spec.rb

@@ -1,8 +1,9 @@
 require 'spec_helper'
 require 'net/http'
 require 'yaml'
+require 'jasmine/ruby_versions'
 
-if Jasmine::Dependencies.rails_available?
+if rails_available?
   describe 'A Rails app' do
     def bundle_install
       tries_remaining = 3
@@ -21,29 +22,38 @@ if Jasmine::Dependencies.rails_available?
       temp_dir_before
       Dir::chdir @tmp
 
-      create_rails 'rails-example'
+      `rails new rails-example --skip-bundle  --skip-active-record`
       Dir::chdir File.join(@tmp, 'rails-example')
 
       base = File.absolute_path(File.join(__FILE__, '../..'))
 
+      # execjs v2.2.0 is broken in rbx, locking the version to 2.0.2 for now
+      # see https://github.com/sstephenson/execjs/issues/148
+
       open('Gemfile', 'a') { |f|
         f.puts "gem 'jasmine', :path => '#{base}'"
         f.puts "gem 'jasmine-core', :github => 'pivotal/jasmine'"
-        f.puts "gem 'rubysl', :platform => :rbx"
-        f.puts "gem 'racc', :platform => :rbx"
+        if RUBY_PLATFORM != 'java' && ENV['RAILS_VERSION'] != 'rails5'
+          f.puts "gem 'thin'"
+        end
+        f.puts "gem 'angularjs-rails'"
+        f.puts "gem 'execjs', '2.0.2'"
+        if ruby_version_less_than([2,0,0]) && ENV['RAILS_VERSION'] == 'rails3'
+          f.puts "gem 'sass', '3.4.25'"
+        end
         f.flush
       }
 
       Bundler.with_clean_env do
         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
+        expect(File.exists?('spec/javascripts/helpers/.gitkeep')).to eq true
+        expect(File.exists?('spec/javascripts/support/jasmine.yml')).to eq 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
+        expect(File.exists?('app/assets/javascripts/jasmine_examples/Player.js')).to eq true
+        expect(File.exists?('app/assets/javascripts/jasmine_examples/Song.js')).to eq true
+        expect(File.exists?('spec/javascripts/jasmine_examples/PlayerSpec.js')).to eq true
+        expect(File.exists?('spec/javascripts/helpers/jasmine_examples/SpecHelper.js')).to eq true
       end
     end
 
@@ -54,18 +64,17 @@ if Jasmine::Dependencies.rails_available?
     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')
+        expect(output).to include('jasmine ')
+        expect(output).to include('jasmine:ci')
       end
     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')
+        expect(output).to include('5 specs, 0 failures')
       end
     end
 
@@ -76,8 +85,20 @@ if Jasmine::Dependencies.rails_available?
           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')
+        expect($?).to_not be_success
+        expect(output).to include('6 specs, 1 failure')
+      end
+    end
+
+    it "rake jasmine:ci runs specs when an error occurs in the javascript" do
+      Bundler.with_clean_env do
+        FileUtils.cp(File.join(@root, 'spec', 'fixture', 'exception_test.js'), File.join('spec', 'javascripts'))
+        exception_yaml = custom_jasmine_config('exception') do |jasmine_config|
+          jasmine_config['spec_files'] << 'exception_test.js'
+        end
+        output = `bundle exec rake jasmine:ci JASMINE_CONFIG_PATH=#{exception_yaml}`
+        expect($?).to be_success
+        expect(output).to include('5 specs, 0 failures')
       end
     end
 
@@ -89,7 +110,7 @@ if Jasmine::Dependencies.rails_available?
 
       Bundler.with_clean_env do
         output = `bundle exec rake jasmine:ci JASMINE_CONFIG_PATH=#{coffee_yaml}`
-        output.should include('6 specs, 0 failures')
+        expect(output).to include('6 specs, 0 failures')
       end
     end
 
@@ -99,15 +120,80 @@ if Jasmine::Dependencies.rails_available?
         f.flush
       }
 
+      open('spec/javascripts/helpers/angular_helper.js', 'w') { |f|
+        f.puts "//= require angular-mocks"
+        f.flush
+      }
+
       css_yaml = custom_jasmine_config('css') do |jasmine_config|
-        jasmine_config['src_files'] = ['assets/application.js']
+        jasmine_config['src_files'] = %w[assets/application.js http://ajax.googleapis.com/ajax/libs/jquery/1.11.0/jquery.min.js]
         jasmine_config['stylesheets'] = ['assets/application.css']
       end
 
+      run_jasmine_server("JASMINE_CONFIG_PATH=#{css_yaml}") do
+        output = Net::HTTP.get(URI.parse('http://localhost:8888/'))
+        expect(output).to match(%r{script src.*/assets/jasmine_examples/Player\.js})
+        expect(output).to match(%r{script src=['"]http://ajax\.googleapis\.com/ajax/libs/jquery/1\.11\.0/jquery\.min\.js})
+        expect(output).to match(%r{script src.*/assets/jasmine_examples/Song\.js})
+        expect(output).to match(%r{script src.*angular_helper\.js})
+        expect(output).to match(%r{<link rel=.stylesheet.*?href=./assets/foo\.css\?.*?>})
+
+        output = Net::HTTP.get(URI.parse('http://localhost:8888/__spec__/helpers/angular_helper.js'))
+        expect(output).to match(/angular\.mock/)
+      end
+    end
+
+    it "sets assets_prefix when using sprockets" do
+      open('app/assets/stylesheets/assets_prefix.js.erb', 'w') { |f|
+        f.puts "<%= assets_prefix %>"
+        f.flush
+      }
+
+      run_jasmine_server do
+        output = Net::HTTP.get(URI.parse('http://localhost:8888/assets/assets_prefix.js'))
+        expect(output).to match("/assets")
+      end
+    end
+
+    it "should load js files outside of the assets path too" do
+      yaml = custom_jasmine_config('public-assets') do |jasmine_config|
+        jasmine_config['src_files'] << 'public/javascripts/**/*.js'
+        jasmine_config['spec_files'] = ['non_asset_pipeline_test.js']
+      end
+      FileUtils.mkdir_p(File.join('public', 'javascripts'))
+      FileUtils.cp(File.join(@root, 'spec', 'fixture', 'non_asset_pipeline.js'), File.join('public', 'javascripts'))
+      FileUtils.cp(File.join(@root, 'spec', 'fixture', 'non_asset_pipeline_test.js'), File.join('spec', 'javascripts'))
+
+      Bundler.with_clean_env do
+        output = `bundle exec rake jasmine:ci JASMINE_CONFIG_PATH=#{yaml}`
+        expect(output).to include('1 spec, 0 failures')
+      end
+    end
+
+    it "should pass custom rack options from jasmine.yml" do
+      pending "we're testing this with thin, which doesn't work in jruby" if RUBY_PLATFORM == 'java'
+      rack_yaml = custom_jasmine_config('custom_rack') do |jasmine_config|
+        jasmine_config['rack_options'] = { 'server' => 'webrick' }
+      end
+
+      Bundler.with_clean_env do
+        default_output = `bundle exec rake jasmine:ci`
+        if ENV['RAILS_VERSION'] == 'rails5' || ENV['RAILS_VERSION'].nil?
+          expect(default_output).to include('Puma starting')
+        else
+          expect(default_output).to include('Thin web server')
+        end
+
+        custom_output = `bundle exec rake jasmine:ci JASMINE_CONFIG_PATH=#{rack_yaml} 2>&1`
+        expect(custom_output).to include("WEBrick")
+      end
+    end
+
+    def run_jasmine_server(options = "")
       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)
+          pid = IO.popen("bundle exec rake jasmine #{options}").pid
+          Jasmine::wait_for_listener(8888, 'localhost', 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
@@ -116,13 +202,8 @@ if Jasmine::Dependencies.rails_available?
           `kill -0 #{pid}`
           unless $?.success?
             puts "someone else is running a server on port 8888"
-            $?.should be_success
+            expect($?).to be_success
           end
-
-          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
@@ -132,20 +213,5 @@ if Jasmine::Dependencies.rails_available?
         end
       end
     end
-
-    it "should load js files outside of the assets path too" do
-      yaml = custom_jasmine_config('public-assets') do |jasmine_config|
-        jasmine_config['src_files'] << 'public/javascripts/**/*.js'
-        jasmine_config['spec_files'] = ['non_asset_pipeline_test.js']
-      end
-      FileUtils.mkdir_p(File.join('public', 'javascripts'))
-      FileUtils.cp(File.join(@root, 'spec', 'fixture', 'non_asset_pipeline.js'), File.join('public', 'javascripts'))
-      FileUtils.cp(File.join(@root, 'spec', 'fixture', 'non_asset_pipeline_test.js'), File.join('spec', 'javascripts'))
-
-      Bundler.with_clean_env do
-        output = `bundle exec rake jasmine:ci JASMINE_CONFIG_PATH=#{yaml}`
-        output.should include('1 spec, 0 failures')
-      end
-    end
   end
 end

data/spec/lib/jasmine/formatters/console_spec.rb

@@ -3,38 +3,74 @@ require 'spec_helper'
 describe Jasmine::Formatters::Console do
 
   let(:outputter_output) { '' }
-  let(:outputter) { lambda { |str| outputter_output << str } }
-  describe '#failures' do
-    it 'shows the failure messages' do
-      results = [failing_result, failing_result]
-      Jasmine::Formatters::Console.new(outputter).format(results)
+  let(:outputter) do
+    double(:outputter).tap do |o|
+      allow(o).to receive(:print) { |str| outputter_output << str }
+      allow(o).to receive(:puts) { |str| outputter_output << "#{str}\n" }
+    end
+  end
+  let(:run_details) { { 'order' => { 'random' => false } } }
 
-      outputter_output.should match(/a suite with a failing spec/)
-      outputter_output.should match(/a failure message/)
-      outputter_output.should match(/a stack trace/)
+  describe '#format' do
+    it 'prints a dot for a successful spec' do
+      formatter = Jasmine::Formatters::Console.new(outputter)
+      formatter.format([passing_result])
+
+      expect(outputter_output).to include('.')
+    end
+
+    it 'prints a star for a pending spec' do
+      formatter = Jasmine::Formatters::Console.new(outputter)
+      formatter.format([pending_result])
+
+      expect(outputter_output).to include('*')
+    end
+
+    it 'prints an F for a failing spec' do
+      formatter = Jasmine::Formatters::Console.new(outputter)
+      formatter.format([failing_result])
+
+      expect(outputter_output).to include('F')
+    end
+
+    it 'prints a dot for a disabled spec' do
+      formatter = Jasmine::Formatters::Console.new(outputter)
+      formatter.format([disabled_result])
+
+      expect(outputter_output).to eq('')
     end
   end
 
   describe '#summary' do
+    it 'shows the failure messages' do
+      results = [failing_result, failing_result]
+      formatter = Jasmine::Formatters::Console.new(outputter)
+      formatter.format(results)
+      formatter.done(run_details)
+      expect(outputter_output).to match(/a suite with a failing spec/)
+      expect(outputter_output).to match(/a failure message/)
+      expect(outputter_output).to match(/a stack trace/)
+    end
+
     describe 'when the full suite passes' do
       it 'shows the spec counts' do
         results = [passing_result]
         console = Jasmine::Formatters::Console.new(outputter)
         console.format(results)
-        console.done
+        console.done(run_details)
 
-        outputter_output.should match(/1 spec/)
-        outputter_output.should match(/0 failures/)
+        expect(outputter_output).to match(/1 spec/)
+        expect(outputter_output).to match(/0 failures/)
       end
 
       it 'shows the spec counts (pluralized)' do
         results = [passing_result, passing_result]
         console = Jasmine::Formatters::Console.new(outputter)
         console.format(results)
-        console.done
+        console.done(run_details)
 
-        outputter_output.should match(/2 specs/)
-        outputter_output.should match(/0 failures/)
+        expect(outputter_output).to match(/2 specs/)
+        expect(outputter_output).to match(/0 failures/)
       end
     end
 
@@ -43,20 +79,29 @@ describe Jasmine::Formatters::Console do
         results = [passing_result, failing_result]
         console = Jasmine::Formatters::Console.new(outputter)
         console.format(results)
-        console.done
+        console.done(run_details)
 
-        outputter_output.should match(/2 specs/)
-        outputter_output.should match(/1 failure/)
+        expect(outputter_output).to match(/2 specs/)
+        expect(outputter_output).to match(/1 failure/)
       end
 
       it 'shows the spec counts (pluralized)' do
         results = [failing_result, failing_result]
         console = Jasmine::Formatters::Console.new(outputter)
         console.format(results)
-        console.done
+        console.done(run_details)
+
+        expect(outputter_output).to match(/2 specs/)
+        expect(outputter_output).to match(/2 failures/)
+      end
+
+      it 'shows the failure message' do
+        results = [failing_result]
+        console = Jasmine::Formatters::Console.new(outputter)
+        console.format(results)
+        console.done(run_details)
 
-        outputter_output.should match(/2 specs/)
-        outputter_output.should match(/2 failures/)
+        expect(outputter_output).to match(/a failure message/)
       end
     end
 
@@ -65,18 +110,36 @@ describe Jasmine::Formatters::Console do
         results = [passing_result, pending_result]
         console = Jasmine::Formatters::Console.new(outputter)
         console.format(results)
-        console.done
+        console.done(run_details)
 
-        outputter_output.should match(/1 pending spec/)
+        expect(outputter_output).to match(/1 pending spec/)
       end
 
       it 'shows the spec counts (pluralized)' do
         results = [pending_result, pending_result]
         console = Jasmine::Formatters::Console.new(outputter)
         console.format(results)
-        console.done
+        console.done(run_details)
+
+        expect(outputter_output).to match(/2 pending specs/)
+      end
+
+      it 'shows the pending reason' do
+        results = [pending_result]
+        console = Jasmine::Formatters::Console.new(outputter)
+        console.format(results)
+        console.done(run_details)
 
-        outputter_output.should match(/2 pending specs/)
+        expect(outputter_output).to match(/I pend because/)
+      end
+
+      it 'shows the default pending reason' do
+        results = [Jasmine::Result.new(pending_raw_result.merge('pendingReason' => ''))]
+        console = Jasmine::Formatters::Console.new(outputter)
+        console.format(results)
+        console.done(run_details)
+
+        expect(outputter_output).to match(/No reason given/)
       end
     end
 
@@ -86,11 +149,42 @@ describe Jasmine::Formatters::Console do
         results = [passing_result]
         console = Jasmine::Formatters::Console.new(outputter)
         console.format(results)
-        console.done
+        console.done(run_details)
 
-        outputter_output.should_not match(/pending spec[s]/)
+        expect(outputter_output).to_not match(/pending spec[s]/)
       end
     end
+
+    describe 'when the tests were randomized' do
+      it 'should print a message with the seed' do
+        results = [passing_result]
+        console = Jasmine::Formatters::Console.new(outputter)
+        console.format(results)
+        console.done({ 'order' => { 'random' => true, 'seed' => '4325' } })
+
+        expect(outputter_output).to match(/Randomized with seed 4325/)
+      end
+    end
+
+    describe 'with errors in a global afterAll' do
+      it 'should show the errors' do
+        console = Jasmine::Formatters::Console.new(outputter)
+        console.done({ 'failedExpectations' => [{ 'message' => 'Global Failure', 'stack' => 'more info' }] })
+
+        expect(outputter_output).to match(/Error occurred in afterAll/)
+        expect(outputter_output).to match(/Global Failure/)
+        expect(outputter_output).to match(/more info/)
+      end
+    end
+
+    it 'shows deprecation warnings' do
+      console = Jasmine::Formatters::Console.new(outputter)
+      console.format([Jasmine::Result.new(deprecation_raw_result)])
+      console.done({ 'deprecationWarnings' => [{ 'message' => 'globally deprecated', 'stack' => nil }] })
+
+      expect(outputter_output).to match(/deprecated call/)
+      expect(outputter_output).to match(/globally deprecated/)
+    end
   end
 
   def failing_result
@@ -104,4 +198,8 @@ describe Jasmine::Formatters::Console do
   def pending_result
     Jasmine::Result.new(pending_raw_result)
   end
+
+  def disabled_result
+    Jasmine::Result.new(disabled_raw_result)
+  end
 end

data/spec/lib/jasmine/formatters/exit_code_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Jasmine::Formatters::ExitCode do
+  subject(:formatter) { Jasmine::Formatters::ExitCode.new }
+
+  it 'is successful with no results' do
+    formatter.done({})
+    expect(formatter).to be_succeeded
+  end
+
+  it 'is unsuccessful with a failure' do
+    formatter.format([double(:result, failed?: true)])
+    formatter.done({})
+    expect(formatter).not_to be_succeeded
+  end
+
+  it 'finds a single failure to cause the error' do
+    formatter.format([double(failed?: false), double(failed?: false), double(failed?: true), double(failed?: false)])
+    formatter.done({})
+    expect(formatter).not_to be_succeeded
+  end
+
+  it 'is unsuccessful with a failedExpectation in done' do
+    formatter.done({
+      'failedExpectations' => [{}]
+    })
+    expect(formatter).not_to be_succeeded
+  end
+
+  it 'is still successful with empty failedExpectations in done' do
+    formatter.done({ 'failedExpectations' => [] })
+    expect(formatter).to be_succeeded
+  end
+end

data/spec/lib/jasmine/formatters/multi_spec.rb

@@ -6,12 +6,22 @@ describe Jasmine::Formatters::Multi do
     formatter2 = double(:formatter2)
     multi = Jasmine::Formatters::Multi.new([formatter1, formatter2])
 
-    formatter1.should_receive(:format)
-    formatter2.should_receive(:format)
-    multi.format(nil)
+    results1 = double(:results1)
 
-    formatter1.should_receive(:done)
-    formatter2.should_receive(:done)
-    multi.done
+    expect(formatter1).to receive(:format).with(results1)
+    expect(formatter2).to receive(:format).with(results1)
+    multi.format(results1)
+
+    results2 = double(:results1)
+
+    expect(formatter1).to receive(:format).with(results2)
+    expect(formatter2).to receive(:format).with(results2)
+    multi.format(results2)
+
+    run_details = double(:run_details)
+
+    expect(formatter1).to receive(:done).with(run_details)
+    expect(formatter2).to receive(:done).with(run_details)
+    multi.done(run_details)
   end
 end

data/spec/page_spec.rb

@@ -12,12 +12,12 @@ describe Jasmine::Page do
     let(:page) { Jasmine::Page.new(context) }
     it "should render javascript files in the correct order" do
       js_files = subject.css("script")
-      js_files.map { |file| file["src"] }.compact.should == ["file1.js", "file2.js"]
+      expect(js_files.map { |file| file["src"] }.compact).to eq ["file1.js", "file2.js"]
     end
 
     it "should render css files in the correct order" do
       css_files = subject.css("link[type='text/css']")
-      css_files.map { |file| file["href"] }.compact.should == ["file1.css", "file2.css"]
+      expect(css_files.map { |file| file["href"] }.compact).to eq ["file1.css", "file2.css"]
     end
   end
 end

data/spec/path_expander_spec.rb

@@ -19,7 +19,7 @@ describe Jasmine::PathExpander do
       dir_glob
     )
 
-    expanded_files.should == [
+    expect(expanded_files).to eq [
       File.join('some_base', 'src1.js'),
       File.join('some_base', 'src15.js'),
       File.join('some_base', 'src2.js')
@@ -44,7 +44,7 @@ describe Jasmine::PathExpander do
       dir_glob
     )
 
-    expanded_files.should == [
+    expect(expanded_files).to eq [
       File.join('some_base', 'src1.js'),
       File.join('some_base', 'src15.js'),
       File.join('some_base', 'src2.js')
@@ -69,7 +69,7 @@ describe Jasmine::PathExpander do
       dir_glob
     )
 
-    expanded_files.should == [
+    expect(expanded_files).to eq [
       File.join('some_base', 'src1.js'),
       File.join('some_base', 'src1zzz.js'),
       File.join('some_base', 'src0.js')
@@ -96,7 +96,7 @@ describe Jasmine::PathExpander do
       dir_glob
     )
 
-    expanded_files.should == [
+    expect(expanded_files).to eq [
       File.join('some_base', 'src15.js'),
       File.join('some_base', 'src2.js')
     ]
@@ -114,8 +114,25 @@ describe Jasmine::PathExpander do
       dir_glob
     )
 
-    expanded_files.should == [
+    expect(expanded_files).to eq [
       File.join('some_base', 'src2.js')
     ]
   end
+
+  it "passes through files that are not found by the globber and look like urls" do
+    #this is designed to support cdn files
+    dir_glob = lambda do |pattern|
+      []
+    end
+
+    expanded_files = Jasmine::PathExpander.expand(
+        'some_base',
+        ['http://www.google.com'],
+        dir_glob
+    )
+
+    expect(expanded_files).to eq [
+        'http://www.google.com'
+    ]
+  end
 end

data/spec/path_mapper_spec.rb

@@ -4,30 +4,35 @@ describe Jasmine::PathMapper do
   it "correctly remaps src files" do
     config = double(:config, :src_dir => '/src_dir', :src_path => '/__src__')
     mapper = Jasmine::PathMapper.new(config)
-    mapper.map_src_paths(['/src_dir/foo']).should == ['/__src__/foo']
-    mapper.map_src_paths(['foo/bar']).should == ['/__src__/foo/bar']
+    expect(mapper.map_src_paths(['/src_dir/foo'])).to eq ['/__src__/foo']
+    expect(mapper.map_src_paths(['foo/bar'])).to eq ['/__src__/foo/bar']
   end
   it "correctly remaps spec files" do
     config = double(:config, :spec_dir => '/spec_dir', :spec_path => '/__spec__')
     mapper = Jasmine::PathMapper.new(config)
-    mapper.map_spec_paths(['/spec_dir/foo']).should == ['/__spec__/foo']
-    mapper.map_spec_paths(['foo/bar']).should == ['/__spec__/foo/bar']
+    expect(mapper.map_spec_paths(['/spec_dir/foo'])).to eq ['/__spec__/foo']
+    expect(mapper.map_spec_paths(['foo/bar'])).to eq ['/__spec__/foo/bar']
   end
   it "correctly remaps jasmine files" do
     config = double(:config, :jasmine_dir => '/jasmine_dir', :jasmine_path => '/__jasmine__')
     mapper = Jasmine::PathMapper.new(config)
-    mapper.map_jasmine_paths(['/jasmine_dir/foo']).should == ['/__jasmine__/foo']
-    mapper.map_jasmine_paths(['foo/bar']).should == ['/__jasmine__/foo/bar']
+    expect(mapper.map_jasmine_paths(['/jasmine_dir/foo'])).to eq ['/__jasmine__/foo']
+    expect(mapper.map_jasmine_paths(['foo/bar'])).to eq ['/__jasmine__/foo/bar']
   end
   it "correctly remaps boot files" do
     config = double(:config, :boot_dir => '/boot_dir', :boot_path => '/__boot__')
     mapper = Jasmine::PathMapper.new(config)
-    mapper.map_boot_paths(['/boot_dir/foo']).should == ['/__boot__/foo']
-    mapper.map_boot_paths(['foo/bar']).should == ['/__boot__/foo/bar']
+    expect(mapper.map_boot_paths(['/boot_dir/foo'])).to eq ['/__boot__/foo']
+    expect(mapper.map_boot_paths(['foo/bar'])).to eq ['/__boot__/foo/bar']
   end
   it "handles edge case where dir == path" do
     config = double(:config, :src_dir => '/src_dir', :src_path => '/src_dir')
     mapper = Jasmine::PathMapper.new(config)
-    mapper.map_src_paths(['/src_dir/foo']).should == ['/src_dir/foo']
+    expect(mapper.map_src_paths(['/src_dir/foo'])).to eq ['/src_dir/foo']
+  end
+  it 'handles edge case with multiple instances of src dir' do
+    config = double(:config, :src_dir => '/app', :src_path => '/')
+    mapper = Jasmine::PathMapper.new(config)
+    expect(mapper.map_src_paths(['/app/assets/application.js'])).to eq ['/assets/application.js']
   end
 end

data/spec/performance/phantom_js_runner_performance_spec.rb

@@ -18,6 +18,6 @@ describe "Phantom JS Runner performance/integration suite", :performance => true
     FileUtils.cp(File.join(@root, 'spec', 'fixture', 'large_test_suite_spec.js'), File.join(@tmp, 'spec', 'javascripts'))
 
     ci_output = `rake --trace jasmine:ci`
-    ci_output.should =~ (/40000 specs, 20000 failures/)
+    expect(ci_output).to match (/40000 specs, 20000 failures/)
   end
 end

data/spec/phantom_js_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Jasmine::Runners::PhantomJs do
+  it 'converts a given cli options hash to a cli arguments string' do
+    options = {
+      'local-storage-quota' => 5000,
+      'local-storage-path' => 'tmp/xyz'
+    }
+
+    phantom_js = Jasmine::Runners::PhantomJs.new(nil, nil,nil,nil, nil,nil, options)
+
+    expect(phantom_js.cli_options_string).to eq('--local-storage-quota=5000 --local-storage-path=tmp/xyz')
+  end
+end