jasmine 3.4.0 → 3.8.0

data/lib/jasmine/runners/phantom_js.rb

@@ -1,4 +1,5 @@
 require 'phantomjs'
+require 'json'
 
 module Jasmine
   module Runners

data/lib/jasmine/tasks/jasmine.rake

@@ -59,7 +59,11 @@ namespace :jasmine do
     config = Jasmine.config
     port = config.port(:server)
     server = Jasmine::Server.new(port, Jasmine::Application.app(Jasmine.config), config.rack_options)
-    puts "your server is running here: http://localhost:#{port}/"
+    if config.random
+      puts "your server is running here: http://localhost:#{port}/"
+    else
+      puts "your server is running here: http://localhost:#{port}/?random=false"
+    end
     puts "your tests are here:         #{config.spec_dir}"
     puts "your source files are here:  #{config.src_dir}"
     puts ''

data/lib/jasmine/version.rb

@@ -1,3 +1,3 @@
 module Jasmine
-  VERSION = "3.4.0"
+  VERSION = "3.8.0"
 end

data/release_notes/3.5.0.md

@@ -0,0 +1,16 @@
+# Jasmine Gem 3.5 Release Notes
+
+## Summary
+
+This release updates the jasmine-core dependency to 3.5.0. See the
+[jasmine-core release notes](https://github.com/jasmine/jasmine/blob/master/release_notes/3.5.0.md)
+for more information
+
+## Changes
+
+* Add docs for how to use the new Chrome Headless runner
+  - Fixes [#308](https://github.com/jasmine/jasmine-gem/issues/308)
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

data/release_notes/3.5.1.md

@@ -0,0 +1,18 @@
+# Jasmine Gem 3.5.1 Release Notes
+
+## Summary
+
+This update allows the gem to continue working with Sprockets in Rails 6
+
+## Changes
+
+* Various readme improvements
+  - Merges [#312](https://github.com/jasmine/jasmine-gem/issues/312) from @cprodhomme
+
+* Allow Jasmine to continue to work with Rails 6
+  - Merges [#310](https://github.com/jasmine/jasmine-gem/issues/310) from @cbaines
+  - Fixes [#311](https://github.com/jasmine/jasmine-gem/issues/311)
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

data/release_notes/3.6.0.md

@@ -0,0 +1,31 @@
+# Jasmine Gem 3.6 Release Notes
+
+## Summary
+
+This release updates the jasmine-core dependency to 3.6.0. See the
+[jasmine-core release notes](https://github.com/jasmine/jasmine/blob/main/release_notes/3.6.0.md)
+for more information
+
+
+## Changes
+
+* Change jasmine:server url depending on random flag
+    * Merges #317 from @vimalloc
+    * Fixes #307
+
+* Fix Action View deprecation warnings in Rails 6
+    * Merges #318 from @pixeltrix
+
+* Prevent race condition with Chrome Remote startup
+    * Merges #316 from @stoivo
+
+* Add API to enable/disable coloring text
+    * Merges #313 from @soutaro
+
+* Add support for chrome from yaourt
+    * Merges #315 from @TheBlackArroVV
+    * Fixes #314
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

data/release_notes/3.7.0.md

@@ -0,0 +1,7 @@
+# Jasmine Gem 3.7 Release Notes
+
+## Summary
+
+This release updates the jasmine-core dependency to 3.7.0. See the
+[jasmine-core release notes](https://github.com/jasmine/jasmine/blob/main/release_notes/3.7.0.md)
+for more information

data/release_notes/3.8.0.md

@@ -0,0 +1,38 @@
+# Jasmine Gem 3.8 Release Notes
+
+## Summary
+
+This release updates the jasmine-core dependency to 3.8.0. See the
+[jasmine-core release notes](https://github.com/pivotal/jasmine/blob/main/release_notes/3.8.0.md)
+for more information.
+
+## Changes
+
+* Ruby 3.0 compatibility
+
+# Internal notes
+
+* Added Ruby 2.7 and Ruby 3.0 to CI matrix
+
+* Migrated from Travis to Circle CI
+
+## Supported Environments
+
+The Jasmine gem has been tested in the following environments:
+
+| Rails version   | Ruby versions |
+|-----------------|---------------|
+| 6               | 2.5-3.0       |
+| 5               | 2.3-2.7       |
+| 4               | 2.3-2.6       |
+| Non-Rails usage | 2.3-3.0       |
+
+See the 
+[jasmine-core release notes](https://github.com/jasmine/jasmine/blob/main/release_notes/3.8.0.md)
+for supported browsers.
+
+
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

data/spec/ci_runner_spec.rb

@@ -61,6 +61,149 @@ describe Jasmine::CiRunner do
     expect(runner).to have_received(:run)
   end
 
+  it 'instantiates all formatters' do
+    class SimpleFormatter1
+    end
+
+    class SimpleFormatter2
+    end
+
+    expect(config).to receive(:formatters) { [SimpleFormatter1, SimpleFormatter2] }
+
+    ci_runner = Jasmine::CiRunner.new(config, thread: fake_thread, application_factory: application_factory, server_factory: server_factory, outputter: outputter)
+
+    ci_runner.run
+
+    expect(runner_factory).to have_received(:call).with(anything, anything) do |multi_formatter, url|
+      expect_any_instance_of(SimpleFormatter1).to receive(:format)
+      expect_any_instance_of(SimpleFormatter2).to receive(:format)
+
+      multi_formatter.format([])
+    end
+  end
+
+  it 'instantiates formatters with arguments' do
+    class SimpleFormatter
+      attr_reader :obj
+      def initialize(obj)
+        @obj = obj
+      end
+    end
+
+    expect(config).to receive(:formatters) { [SimpleFormatter] }
+
+    ci_runner = Jasmine::CiRunner.new(config, thread: fake_thread, application_factory: application_factory, server_factory: server_factory, outputter: outputter)
+
+    ci_runner.run
+
+    expect(runner_factory).to have_received(:call).with(anything, anything) do |multi_formatter, url|
+      expect_any_instance_of(SimpleFormatter).to receive(:format) do |formatter, results|
+        expect(formatter.obj).to eq(config)
+      end
+
+      multi_formatter.format([])
+    end
+  end
+
+  it 'works with formatters that are not classes' do
+    class Factory1
+      attr_reader :called
+      def new
+        @called = true
+        nil
+      end
+    end
+
+    class Factory2
+      attr_reader :called
+      attr_reader :obj
+      def new(obj)
+        @obj = obj
+        @called = true
+        nil
+      end
+    end
+
+    factory1 = Factory1.new
+    factory2 = Factory2.new
+
+    expect(config).to receive(:formatters) { [factory1, factory2] }
+
+    ci_runner = Jasmine::CiRunner.new(config, thread: fake_thread, application_factory: application_factory, server_factory: server_factory, outputter: outputter)
+
+    ci_runner.run
+
+    expect(factory1.called).to eq(true)
+    expect(factory2.called).to eq(true)
+    expect(factory2.obj).to eq(config)
+  end
+
+  it 'handles optional arguments by only passing config when it is required' do
+    class NoConfigFormatter
+      attr_reader :optional
+      def initialize(optional = {config: 'no'})
+        @optional = optional
+      end
+    end
+
+    class HasConfigFormatter
+      attr_reader :obj, :optional
+      def initialize(obj, optional = {config: 'no'})
+        @obj = obj
+        @optional = optional
+      end
+    end
+
+    class NoConfigFactory
+      def initialize(dummy_formatter)
+        @dummy_formatter = dummy_formatter
+      end
+      attr_reader :optional
+      def new(optional = {config: 'no'})
+        @optional = optional
+        @dummy_formatter
+      end
+    end
+
+    class HasConfigFactory
+      def initialize(dummy_formatter)
+        @dummy_formatter = dummy_formatter
+      end
+      attr_reader :obj, :optional
+      def new(obj, optional = {config: 'no'})
+        @obj = obj
+        @optional = optional
+        @dummy_formatter
+      end
+    end
+
+    no_config_factory = NoConfigFactory.new(double(:formatter, format: nil))
+    has_config_factory = HasConfigFactory.new(double(:formatter, format: nil))
+
+    expect(config).to receive(:formatters) { [NoConfigFormatter, HasConfigFormatter, no_config_factory, has_config_factory] }
+
+    ci_runner = Jasmine::CiRunner.new(config, thread: fake_thread, application_factory: application_factory, server_factory: server_factory, outputter: outputter)
+
+    ci_runner.run
+
+    expect(no_config_factory.optional).to eq({config: 'no'})
+    expect(has_config_factory.optional).to eq({config: 'no'})
+    expect(has_config_factory.obj).to eq(config)
+
+    expect(runner_factory).to have_received(:call).with(anything, anything) do |multi_formatter, url|
+      expect_any_instance_of(NoConfigFormatter).to receive(:format) do |formatter, results|
+        expect(formatter.optional).to eq({config: 'no'})
+      end
+
+      expect_any_instance_of(HasConfigFormatter).to receive(:format) do |formatter, results|
+        expect(formatter.optional).to eq({config: 'no'})
+        expect(formatter.obj).to eq(config)
+      end
+
+      multi_formatter.format([])
+    end
+  end
+
   it 'adds runner boot files when necessary' do
     expect(runner).to receive(:boot_js).at_least(:once) { 'foo/bar/baz.js' }
     expect(config).to receive(:runner_boot_dir=).with('foo/bar')

data/spec/configuration_spec.rb

@@ -215,5 +215,18 @@ describe Jasmine::Configuration do
       config.runner.call('hi')
     end
   end
+
+  describe 'colorization settings' do
+    it 'defaults to color' do
+      config = Jasmine::Configuration.new
+      expect(config.color).to eq(true)
+    end
+
+    it 'can be set to false' do
+      config = Jasmine::Configuration.new
+      config.color = false
+      expect(config.color).to eq(false)
+    end
+  end
 end
 

data/spec/jasmine_rails_spec.rb

@@ -4,10 +4,19 @@ require 'yaml'
 require 'jasmine/ruby_versions'
 
 if rails_available?
+  if !Bundler.respond_to?(:with_unbundled_env)
+    module Bundler
+      class << self
+        alias_method :with_unbundled_env, :with_clean_env
+      end
+    end
+  end
+
   describe 'A Rails app' do
     def bundle_install
-      puts `NOKOGIRI_USE_SYSTEM_LIBRARIES=true bundle install --path vendor --retry 3;`
+      bundle_output = `NOKOGIRI_USE_SYSTEM_LIBRARIES=true bundle install`
       unless $?.success?
+        puts bundle_output
         raise "Bundle failed to install."
       end
     end
@@ -16,26 +25,35 @@ if rails_available?
       temp_dir_before
       Dir::chdir @tmp
 
-      `rails new rails-example --skip-bundle  --skip-active-record`
+      if rails_version == 'rails6'
+        `rails new rails-example --skip-bundle  --skip-active-record --skip-bootsnap --skip-webpack-install --skip-javascript`
+      else
+        `rails new rails-example --skip-bundle  --skip-active-record`
+      end
       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', :git => 'http://github.com/jasmine/jasmine.git'"
-        if RUBY_PLATFORM != 'java' && ENV['RAILS_VERSION'] != 'rails5'
+        f.puts "gem 'jasmine-core', :git => 'http://github.com/jasmine/jasmine.git', ref: 'main'"
+        if RUBY_PLATFORM != 'java' && rails_version == 'rails4'
           f.puts "gem 'thin'"
         end
-        f.puts "gem 'angularjs-rails'"
-        f.puts "gem 'execjs', '2.0.2'"
         f.flush
       }
 
-      Bundler.with_clean_env do
+      FileUtils.mkdir_p('.bundle')
+      open('.bundle/config', 'a') do |f|
+        f.puts(<<~YAML)
+               ---
+               BUNDLE_PATH: "vendor"
+               BUNDLE_RETRY: "3"
+        YAML
+        f.flush
+      end
+
+      Bundler.with_unbundled_env do
         bundle_install
         `bundle exec rails g jasmine:install`
         expect($?).to eq 0
@@ -47,6 +65,19 @@ if rails_available?
         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
+
+      if rails_version == 'rails6'
+        FileUtils.mkdir_p('app/assets/javascripts')
+        open('app/assets/javascripts/application.js', 'a') { |f|
+          f.puts '//= require_tree .'
+          f.flush
+        }
+        FileUtils.mkdir_p('app/assets/config')
+        open('app/assets/config/manifest.js', 'a') { |f|
+          f.puts '//= link_directory ../javascripts .js'
+          f.flush
+        }
+      end
     end
 
     after :all do
@@ -56,55 +87,23 @@ if 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.
-      Bundler.with_clean_env do
+      Bundler.with_unbundled_env do
         output = `bundle exec rake -T`
         expect(output).to include('jasmine ')
         expect(output).to include('jasmine:ci')
       end
     end
 
-    describe "with phantomJS" do
-      it "rake jasmine:ci runs and returns expected results" do
-        Bundler.with_clean_env do
-          output = `bundle exec rake jasmine:ci`
-          expect(output).to include('5 specs, 0 failures')
-        end
-      end
-
-      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}`
-          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_not be_success
-          expect(output).to include('5 specs, 0 failures')
-        end
+    context 'with angular mocks' do
+      before(:all) do
+        open('spec/javascripts/helpers/angular_helper.js', 'w') { |f|
+          f.puts "//= require angular-mocks"
+          f.flush
+        }
       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'))
-
-        Bundler.with_clean_env do
-          output = `bundle exec rake jasmine:ci JASMINE_CONFIG_PATH=#{coffee_yaml}`
-          expect(output).to include('6 specs, 0 failures')
-        end
+      after(:all) do
+        FileUtils.rm('spec/javascripts/helpers/angular_helper.js')
       end
 
       it "rake jasmine runs and serves the expected webpage when using asset pipeline" do
@@ -113,114 +112,95 @@ if 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'] = %w[assets/application.js http://ajax.googleapis.com/ajax/libs/jquery/1.11.0/jquery.min.js]
           jasmine_config['stylesheets'] = ['assets/application.css']
         end
 
+        Bundler.with_unbundled_env do
+          `bundle add angularjs-rails`
+        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(\.self-[^\.]+)?\.js})
+          if rails_version == 'rails6'
+            expect(output).to match(%r{script src.*/(assets/application.debug-[^\.]+\.js)})
+            expect(output).to match(%r{<link rel=.stylesheet.*?href=.*/assets/application.debug-[^\.]+\.css})
+          else
+            expect(output).to match(%r{script src.*/assets/jasmine_examples/Player(\.self-[^\.]+)?\.js})
+            expect(output).to match(%r{script src.*/assets/jasmine_examples/Song(\.self-[^\.]+)?\.js})
+            expect(output).to match(%r{script src.*angular_helper\.js})
+            expect(output).to match(%r{<link rel=.stylesheet.*?href=./assets/foo(\.self-[^\.]+)?\.css\?.*?>})
+          end
           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(\.self-[^\.]+)?\.js})
-          expect(output).to match(%r{script src.*angular_helper\.js})
-          expect(output).to match(%r{<link rel=.stylesheet.*?href=./assets/foo(\.self-[^\.]+)?\.css\?.*?>})
 
           output = Net::HTTP.get(URI.parse('http://localhost:8888/__spec__/helpers/angular_helper.js'))
           expect(output).to match(/angular\.mock/)
         end
       end
+    end
 
-      it "sets assets_prefix when using sprockets" do
+    context 'with an assets_prefix set' do
+      before(:all) do
         open('app/assets/stylesheets/assets_prefix.js.erb', 'w') { |f|
           f.puts "<%= assets_prefix %>"
           f.flush
         }
+      end
 
+      after(:all) do
+        FileUtils.rm('app/assets/stylesheets/assets_prefix.js.erb')
+      end
+
+      it "sets assets_prefix when using sprockets" do
         run_jasmine_server do
           output = Net::HTTP.get(URI.parse('http://localhost:8888/assets/assets_prefix.js'))
           expect(output).to match("/assets")
         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}`
-          expect(output).to include('1 spec, 0 failures')
-        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'))
 
-      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
+      Bundler.with_unbundled_env do
+        output = `bundle exec rake jasmine:ci JASMINE_CONFIG_PATH=#{yaml}`
+        expect(output).to include('1 spec, 0 failures')
       end
+    end
 
-      describe 'using sprockets 4' do
-        before :all do
-          FileUtils.cp('Gemfile', 'Gemfile-old')
-          FileUtils.rm 'Gemfile.lock'
-
-          open('Gemfile', 'a') { |f|
-            f.puts "gem 'sprockets', '~> 4.0.0.beta6'"
-            f.flush
-          }
-          Bundler.with_clean_env do
-            bundle_install
-          end
-
-          FileUtils.mkdir_p('app/assets/config')
+    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
 
-          open('app/assets/config/manifest.js', 'w') { |f|
-            f.puts "//= link application.js"
-            f.puts "//= link application.css"
-            f.flush
-          }
+      Bundler.with_unbundled_env do
+        default_output = `bundle exec rake jasmine:ci`
+        if rails_version == 'rails6' || rails_version == 'rails5' || rails_version.nil?
+          expect(default_output).to include('Puma starting')
+        else
+          expect(default_output).to include('Thin web server')
         end
 
-        after :all do
-          FileUtils.mv 'Gemfile-old', 'Gemfile'
-          FileUtils.rm 'Gemfile.lock'
-          FileUtils.rm 'app/assets/config/manifest.js'
-          Bundler.with_clean_env do
-            bundle_install
-          end
-        end
+        custom_output = `bundle exec rake jasmine:ci JASMINE_CONFIG_PATH=#{rack_yaml} 2>&1`
+        expect(custom_output).to include("WEBrick")
+      end
+    end
 
+    if rails_version == 'rails6'
+      describe 'using sprockets 4' do
         it "serves source mapped assets" do
           run_jasmine_server do
             output = Net::HTTP.get(URI.parse('http://localhost:8888/'))
 
             js_match = output.match %r{script src.*/(assets/application.debug-[^\.]+\.js)}
-
             expect(js_match).to_not be_nil
-            expect(output).to match(%r{<link rel=.stylesheet.*?href=.*/assets/application.debug-[^\.]+\.css})
 
             js_path = js_match[1]
             output = Net::HTTP.get(URI.parse("http://localhost:8888/#{js_path}"))
@@ -230,28 +210,17 @@ if rails_available?
       end
     end
 
-    describe "with Chrome headless" do
-      before :all do
-        open('spec/javascripts/support/jasmine_helper.rb', 'w') { |f|
-          f.puts "Jasmine.configure do |config|\n  config.runner_browser = :chromeheadless\nend\n"
-          f.flush
-        }
-      end
-
-
-      it "rake jasmine:ci runs and returns expected results", :focus do
-        Bundler.with_clean_env do
-          `bundle add chrome_remote`
+    shared_examples_for 'a working jasmine:ci' do
+      it "rake jasmine:ci runs and returns expected results" do
+        Bundler.with_unbundled_env do
           output = `bundle exec rake jasmine:ci`
           expect(output).to include('5 specs, 0 failures')
-          `bundle remove chrome_remote`
+          expect($?).to be_success
         end
       end
 
       it "rake jasmine:ci returns proper exit code when specs fail" do
-        Bundler.with_clean_env do
-          `bundle add chrome_remote`
-
+        Bundler.with_unbundled_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'
@@ -259,13 +228,11 @@ if rails_available?
           output = `bundle exec rake jasmine:ci JASMINE_CONFIG_PATH=#{failing_yaml}`
           expect($?).to_not be_success
           expect(output).to include('6 specs, 1 failure')
-          `bundle remove chrome_remote`
         end
       end
 
       it "rake jasmine:ci runs specs when an error occurs in the javascript" do
-        Bundler.with_clean_env do
-          `bundle add chrome_remote`
+        Bundler.with_unbundled_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'
@@ -273,27 +240,51 @@ if rails_available?
           output = `bundle exec rake jasmine:ci JASMINE_CONFIG_PATH=#{exception_yaml}`
           expect($?).to_not be_success
           expect(output).to include('5 specs, 0 failures')
-          `bundle remove chrome_remote`
         end
       end
 
-      it "runs specs written in coffeescript" do
-        coffee_yaml = custom_jasmine_config('coffee') do |jasmine_config|
-          jasmine_config['spec_files'] << 'coffee_spec.coffee'
+      unless rails_version == 'rails6'
+        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'))
+
+          Bundler.with_unbundled_env do
+            output = `bundle exec rake jasmine:ci JASMINE_CONFIG_PATH=#{coffee_yaml}`
+            expect(output).to include('6 specs, 0 failures')
+            expect($?).to be_success
+          end
         end
-        FileUtils.cp(File.join(@root, 'spec', 'fixture', 'coffee_spec.coffee'), File.join('spec', 'javascripts'))
+      end
+    end
+
+    describe "with phantomJS" do
+      it_behaves_like 'a working jasmine:ci'
+    end
 
-        Bundler.with_clean_env do
+    describe "with Chrome headless" do
+      before :all do
+        open('spec/javascripts/support/jasmine_helper.rb', 'w') { |f|
+          f.puts "Jasmine.configure do |config|\n  config.runner_browser = :chromeheadless\nend\n"
+          f.flush
+        }
+        Bundler.with_unbundled_env do
           `bundle add chrome_remote`
-          output = `bundle exec rake jasmine:ci JASMINE_CONFIG_PATH=#{coffee_yaml}`
-          expect(output).to include('6 specs, 0 failures')
+        end
+      end
+
+      after :all do
+        Bundler.with_unbundled_env do
           `bundle remove chrome_remote`
         end
       end
+
+      it_behaves_like 'a working jasmine:ci'
     end
 
     def run_jasmine_server(options = "")
-      Bundler.with_clean_env do
+      Bundler.with_unbundled_env do
         begin
           pid = IO.popen("bundle exec rake jasmine #{options}").pid
           Jasmine::wait_for_listener(8888, 'localhost', 60)