jasmine 2.6.0 → 2.7.0

data/spec/jasmine_command_line_tool_spec.rb

@@ -14,35 +14,35 @@ describe 'Jasmine command line tool' 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\./
+        expect(output).to match /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
-        File.exists?(File.join(@tmp, 'Rakefile')).should == true
+        expect(File.exists?(File.join(@tmp, 'spec/javascripts/helpers/.gitkeep'))).to eq true
+        expect(File.exists?(File.join(@tmp, 'spec/javascripts/support/jasmine.yml'))).to eq true
+        expect(File.exists?(File.join(@tmp, 'Rakefile'))).to eq true
         ci_output = `rake --trace jasmine:ci`
-        ci_output.should =~ (/0 specs, 0 failures/)
+        expect(ci_output).to match (/0 specs, 0 failures/)
       end
 
       it 'should not have rails-like paths' do
         output = capture_stdout { Jasmine::CommandLineTool.new.process ['init'] }
-        output.should =~ /Jasmine has been installed\./
+        expect(output).to match /Jasmine has been installed\./
 
         config = YAML.load_file(File.join(@tmp, 'spec/javascripts/support/jasmine.yml'))
-        config['src_files'].should == ['public/javascripts/**/*.js']
-        config['stylesheets'].should == ['stylesheets/**/*.css']
+        expect(config['src_files']).to eq ['public/javascripts/**/*.js']
+        expect(config['stylesheets']).to eq ['stylesheets/**/*.css']
       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')
+        expect(output).to match /Jasmine has been installed\./
+        expect(File.read(File.join(@tmp, 'Rakefile'))).to include('jasmine.rake')
       end
 
       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')
+        expect(output).to match /Jasmine has been installed\./
+        expect(File.read(File.join(@tmp, 'Rakefile'))).to include('jasmine_flunk')
       end
     end
 
@@ -59,9 +59,9 @@ describe 'Jasmine command line tool' do
             Jasmine::CommandLineTool.new.process ['init']
           }.to raise_error SystemExit
         }
-        output.should =~ /attempting to run jasmine init in a Rails project/
+        expect(output).to match /attempting to run jasmine init in a Rails project/
 
-        Dir.entries(@tmp).sort.should == [".", "..", "Gemfile"]
+        expect(Dir.entries(@tmp).sort).to eq [".", "..", "Gemfile"]
       end
 
       it 'should allow the user to override the warning' do
@@ -70,10 +70,10 @@ describe 'Jasmine command line tool' do
             Jasmine::CommandLineTool.new.process ['init', '--force']
           }.not_to raise_error
         }
-        output.should =~ /Jasmine has been installed\./
+        expect(output).to match /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
+        expect(File.exists?(File.join(@tmp, 'spec/javascripts/helpers/.gitkeep'))).to eq true
+        expect(File.exists?(File.join(@tmp, 'spec/javascripts/support/jasmine.yml'))).to eq true
       end
     end
 
@@ -90,53 +90,53 @@ describe 'Jasmine command line tool' do
             Jasmine::CommandLineTool.new.process ['init']
           }.not_to raise_error
         }
-        output.should =~ /Jasmine has been installed\./
+        expect(output).to match /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
+        expect(File.exists?(File.join(@tmp, 'spec/javascripts/helpers/.gitkeep'))).to eq true
+        expect(File.exists?(File.join(@tmp, 'spec/javascripts/support/jasmine.yml'))).to eq 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
+    expect(output).to match /Jasmine has installed some examples\./
+    expect(File.exists?(File.join(@tmp, 'public/javascripts/jasmine_examples/Player.js'))).to eq true
+    expect(File.exists?(File.join(@tmp, 'public/javascripts/jasmine_examples/Song.js'))).to eq true
+    expect(File.exists?(File.join(@tmp, 'spec/javascripts/jasmine_examples/PlayerSpec.js'))).to eq true
+    expect(File.exists?(File.join(@tmp, 'spec/javascripts/helpers/jasmine_examples/SpecHelper.js'))).to eq true
 
     capture_stdout { Jasmine::CommandLineTool.new.process ['init'] }
     ci_output = `rake --trace jasmine:ci`
-    ci_output.should =~ (/[1-9]\d* specs, 0 failures/)
+    expect(ci_output).to match (/[1-9]\d* specs, 0 failures/)
   end
 
   it 'should include license info' do
     output = capture_stdout { Jasmine::CommandLineTool.new.process ['license'] }
-    output.should =~ /Copyright/
+    expect(output).to match /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/
+    expect(output).to match /Jasmine has copied an example boot.js to spec\/javascripts\/support/
 
-    File.exists?(File.join(@tmp, 'spec/javascripts/support/boot.js')).should == true
+    expect(File.exists?(File.join(@tmp, 'spec/javascripts/support/boot.js'))).to eq 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/
+    expect(output).to match /already exists/
   end
 
   it 'should show help' do
     no_arg_output = capture_stdout { Jasmine::CommandLineTool.new.process [] }
-    no_arg_output.should_not =~ /unknown command/
-    no_arg_output.should =~ /Usage:/
+    expect(no_arg_output).to_not match /unknown command/
+    expect(no_arg_output).to match /Usage:/
 
     unknown_arg_output = capture_stdout { Jasmine::CommandLineTool.new.process ['blurgh', 'blargh'] }
-    unknown_arg_output.should =~ /unknown command blurgh blargh/
-    unknown_arg_output.should =~ /Usage:/
+    expect(unknown_arg_output).to match /unknown command blurgh blargh/
+    expect(unknown_arg_output).to match /Usage:/
   end
 end

data/spec/jasmine_pojs_spec.rb

@@ -18,36 +18,36 @@ describe "POJS jasmine install" do
   end
 
   it "should find the Jasmine configuration files" do
-    File.exists?("spec/javascripts/support/jasmine.yml").should == true
+    expect(File.exists?("spec/javascripts/support/jasmine.yml")).to eq 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
+    expect(File.exists?("public/javascripts/jasmine_examples/Player.js")).to eq true
+    expect(File.exists?("public/javascripts/jasmine_examples/Song.js")).to eq 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?("spec/javascripts/jasmine_examples/PlayerSpec.js")).to eq true
+    expect(File.exists?("spec/javascripts/helpers/jasmine_examples/SpecHelper.js")).to eq true
 
-    File.exists?("spec/javascripts/support/jasmine.yml").should == true
+    expect(File.exists?("spec/javascripts/support/jasmine.yml")).to eq true
   end
 
   it "should show jasmine rake task" do
     output = `rake -T`
-    output.should include("jasmine ")
-    output.should include("jasmine:ci")
+    expect(output).to include("jasmine ")
+    expect(output).to include("jasmine:ci")
   end
 
   it "should successfully run rake jasmine:ci" do
     output = `rake jasmine:ci`
-    output.should =~ (/[1-9]\d* specs, 0 failures/)
-    output.should_not =~ /Randomized with seed/
+    expect(output).to match (/[1-9]\d* specs, 0 failures/)
+    expect(output).to_not match /Randomized with seed/
   end
 
   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}/
+    expect($?).to_not be_success
+    expect(output).to match /Unable to load jasmine config from #{config_path}/
   end
 
   it "rake jasmine:ci returns proper exit code when the runner raises" do
@@ -59,7 +59,7 @@ describe "POJS jasmine install" do
     FileUtils.cp(File.join(@root, 'spec', 'fixture', 'failing_runner.rb'), failing_runner)
 
     `rake jasmine:ci JASMINE_CONFIG_PATH=#{failing_yaml}`
-    $?.should_not be_success
+    expect($?).to_not be_success
   end
 
   context 'with a spec with a console.log' do
@@ -69,7 +69,7 @@ describe "POJS jasmine install" do
 
     it 'hides console.log by default' do
       output = `rake jasmine:ci`
-      output.should_not include("I'm in the webpage!")
+      expect(output).to_not include("I'm in the webpage!")
     end
 
     it 'can be told to show console.log' do
@@ -77,7 +77,7 @@ describe "POJS jasmine install" do
         jasmine_config['show_console_log'] = true
       end
       output = `rake jasmine:ci JASMINE_CONFIG_PATH=#{log_yaml}`
-      output.should include("I'm in the webpage!")
+      expect(output).to include("I'm in the webpage!")
     end
   end
 
@@ -90,7 +90,7 @@ describe "POJS jasmine install" do
     end
 
     output = `rake jasmine:ci JASMINE_CONFIG_PATH=#{viewport_yaml}`
-    output.should =~ /[1-9]\d* specs, 0 failures/
+    expect(output).to match /[1-9]\d* specs, 0 failures/
   end
 
   it 'should throw a useful error when the phantom customization fails' do
@@ -100,16 +100,16 @@ describe "POJS jasmine install" do
     end
 
     output = `rake jasmine:ci JASMINE_CONFIG_PATH=#{bad_phantom_yaml}`
-    $?.should_not be_success
-    output.should =~ /Failed to configure phantom/
+    expect($?).to_not be_success
+    expect(output).to match /Failed to configure phantom/
   end
 
   it 'should fail correctly with a failure in afterAll' do
     FileUtils.cp(File.join(@root, 'spec', 'fixture', 'afterall_spec.js'), File.join('spec', 'javascripts'))
 
     output = `rake jasmine:ci`
-    $?.should_not be_success
-    output.should =~ /afterAll go boom/
+    expect($?).to_not be_success
+    expect(output).to match /afterAll go boom/
   end
 
   it 'should tell jasmine to randomize the execution order' do
@@ -118,7 +118,7 @@ describe "POJS jasmine install" do
     end
 
     output = `rake jasmine:ci JASMINE_CONFIG_PATH=#{randomized_yaml}`
-    $?.should be_success
-    output.should =~ /Randomized with seed/
+    expect($?).to be_success
+    expect(output).to match /Randomized with seed/
   end
 end

data/spec/jasmine_rails_spec.rb

@@ -1,6 +1,7 @@
 require 'spec_helper'
 require 'net/http'
 require 'yaml'
+require 'jasmine/ruby_versions'
 
 if rails_available?
   describe 'A Rails app' do
@@ -37,19 +38,22 @@ if rails_available?
         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
 
@@ -62,15 +66,15 @@ if rails_available?
       #There's a workaround, but requires setting env vars & jruby opts (non-trivial when inside of a jruby process), so skip for now.
       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
 
@@ -81,8 +85,8 @@ if 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
 
@@ -93,8 +97,8 @@ if rails_available?
           jasmine_config['spec_files'] << 'exception_test.js'
         end
         output = `bundle exec rake jasmine:ci JASMINE_CONFIG_PATH=#{exception_yaml}`
-        $?.should be_success
-        output.should include('5 specs, 0 failures')
+        expect($?).to be_success
+        expect(output).to include('5 specs, 0 failures')
       end
     end
 
@@ -106,7 +110,7 @@ if 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
 
@@ -128,14 +132,14 @@ if rails_available?
 
       run_jasmine_server("JASMINE_CONFIG_PATH=#{css_yaml}") do
         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=['"]http://ajax\.googleapis\.com/ajax/libs/jquery/1\.11\.0/jquery\.min\.js})
-        output.should match(%r{script src.*/assets/jasmine_examples/Song\.js})
-        output.should match(%r{script src.*angular_helper\.js})
-        output.should match(%r{<link rel=.stylesheet.*?href=./assets/foo\.css\?.*?>})
+        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'))
-        output.should match(/angular\.mock/)
+        expect(output).to match(/angular\.mock/)
       end
     end
 
@@ -147,7 +151,7 @@ if rails_available?
 
       run_jasmine_server do
         output = Net::HTTP.get(URI.parse('http://localhost:8888/assets/assets_prefix.js'))
-        output.should match("/assets")
+        expect(output).to match("/assets")
       end
     end
 
@@ -162,7 +166,7 @@ if rails_available?
 
       Bundler.with_clean_env do
         output = `bundle exec rake jasmine:ci JASMINE_CONFIG_PATH=#{yaml}`
-        output.should include('1 spec, 0 failures')
+        expect(output).to include('1 spec, 0 failures')
       end
     end
 
@@ -175,13 +179,13 @@ if rails_available?
       Bundler.with_clean_env do
         default_output = `bundle exec rake jasmine:ci`
         if ENV['RAILS_VERSION'] == 'rails5' || ENV['RAILS_VERSION'].nil?
-          default_output.should include('Puma starting')
+          expect(default_output).to include('Puma starting')
         else
-          default_output.should include('Thin web server')
+          expect(default_output).to include('Thin web server')
         end
 
         custom_output = `bundle exec rake jasmine:ci JASMINE_CONFIG_PATH=#{rack_yaml} 2>&1`
-        custom_output.should include("WEBrick")
+        expect(custom_output).to include("WEBrick")
       end
     end
 
@@ -198,7 +202,7 @@ if 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
         ensure
           Process.kill(:SIGINT, pid)

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

@@ -5,8 +5,8 @@ describe Jasmine::Formatters::Console do
   let(:outputter_output) { '' }
   let(:outputter) do
     double(:outputter).tap do |o|
-      o.stub(:print) { |str| outputter_output << str }
-      o.stub(:puts) { |str| outputter_output << "#{str}\n" }
+      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 } } }
@@ -47,9 +47,9 @@ describe Jasmine::Formatters::Console do
       formatter = Jasmine::Formatters::Console.new(outputter)
       formatter.format(results)
       formatter.done(run_details)
-      outputter_output.should match(/a suite with a failing spec/)
-      outputter_output.should match(/a failure message/)
-      outputter_output.should match(/a stack trace/)
+      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
@@ -59,8 +59,8 @@ describe Jasmine::Formatters::Console do
         console.format(results)
         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
@@ -69,8 +69,8 @@ describe Jasmine::Formatters::Console do
         console.format(results)
         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
 
@@ -81,8 +81,8 @@ describe Jasmine::Formatters::Console do
         console.format(results)
         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
@@ -91,8 +91,8 @@ describe Jasmine::Formatters::Console do
         console.format(results)
         console.done(run_details)
 
-        outputter_output.should match(/2 specs/)
-        outputter_output.should match(/2 failures/)
+        expect(outputter_output).to match(/2 specs/)
+        expect(outputter_output).to match(/2 failures/)
       end
 
       it 'shows the failure message' do
@@ -101,7 +101,7 @@ describe Jasmine::Formatters::Console do
         console.format(results)
         console.done(run_details)
 
-        outputter_output.should match(/a failure message/)
+        expect(outputter_output).to match(/a failure message/)
       end
     end
 
@@ -112,7 +112,7 @@ describe Jasmine::Formatters::Console do
         console.format(results)
         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
@@ -121,7 +121,7 @@ describe Jasmine::Formatters::Console do
         console.format(results)
         console.done(run_details)
 
-        outputter_output.should match(/2 pending specs/)
+        expect(outputter_output).to match(/2 pending specs/)
       end
 
       it 'shows the pending reason' do
@@ -130,7 +130,7 @@ describe Jasmine::Formatters::Console do
         console.format(results)
         console.done(run_details)
 
-        outputter_output.should match(/I pend because/)
+        expect(outputter_output).to match(/I pend because/)
       end
 
       it 'shows the default pending reason' do
@@ -139,7 +139,7 @@ describe Jasmine::Formatters::Console do
         console.format(results)
         console.done(run_details)
 
-        outputter_output.should match(/No reason given/)
+        expect(outputter_output).to match(/No reason given/)
       end
     end
 
@@ -151,7 +151,7 @@ describe Jasmine::Formatters::Console do
         console.format(results)
         console.done(run_details)
 
-        outputter_output.should_not match(/pending spec[s]/)
+        expect(outputter_output).to_not match(/pending spec[s]/)
       end
     end
 
@@ -162,7 +162,7 @@ describe Jasmine::Formatters::Console do
         console.format(results)
         console.done({ 'order' => { 'random' => true, 'seed' => '4325' } })
 
-        outputter_output.should match(/Randomized with seed 4325/)
+        expect(outputter_output).to match(/Randomized with seed 4325/)
       end
     end