jasmine 3.2.0 → 3.6.0

data/lib/jasmine/runners/chromeheadless_boot.js

@@ -0,0 +1,15 @@
+function ChromeHeadlessReporter() {
+  this.jasmineDone = function(details) {
+    console.log('jasmine_done', JSON.stringify(details));
+  };
+
+  this.specDone = function(results) {
+    console.log('jasmine_spec_result', JSON.stringify([].concat(results)));
+  };
+
+  this.suiteDone = function(results) {
+    console.log('jasmine_suite_result',JSON.stringify([].concat(results)));
+  };
+}
+
+jasmine.getEnv().addReporter(new ChromeHeadlessReporter());

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.2.0"
+  VERSION = "3.6.0"
 end

data/release_notes/3.3.0.md

@@ -0,0 +1,19 @@
+# Jasmine Gem 3.3 Release Notes
+
+## Summary
+
+This release updates the jasmine-core dependency to 3.3.0. See the
+[jasmine-core release notes](https://github.com/jasmine/jasmine/blob/master/release_notes/3.3.0.md)
+for more information
+
+## Changes
+
+* Fix jasmine-core dependency to allow patch version changes
+
+* Remove Rails 3 from README since it is no longer supported.
+  - See #299
+
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

data/release_notes/3.4.0.md

@@ -0,0 +1,17 @@
+# Jasmine Gem 3.4 Release Notes
+
+## Summary
+
+This release updates the jasmine-core dependency to 3.4.0. See the
+[jasmine-core release notes](https://github.com/jasmine/jasmine/blob/master/release_notes/3.4.0.md)
+for more information
+
+## Changes
+
+* Chrome headless as an option to phantomJS
+  - Merges [#301](https://github.com/jasmine/jasmine-gem/issues/301) from @stoivo
+  - Fixes [#293](https://github.com/jasmine/jasmine-gem/issues/293)
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

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/spec/chrome_headless_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Jasmine::Runners::ChromeHeadless do
+
+  let(:config) {
+    {
+      show_console_log: nil,
+      show_full_stack_trace: nil,
+      chrome_cli_options: nil,
+      chrome_binary: nil,
+    }
+  }
+
+  it 'uses chrome_binary from config is set' do
+    config[:chrome_binary] = "some_path"
+    runner = Jasmine::Runners::ChromeHeadless.new(nil, nil, double(config))
+
+    expect(runner.chrome_binary).to eq("some_path")
+  end
+
+  it 'uses chrome_binary from default chrome path if it exist' do
+    allow(File).to receive(:file?).and_return(true)
+    runner = Jasmine::Runners::ChromeHeadless.new(nil, nil, double(config))
+
+    expect(runner.chrome_binary).to eq("/usr/bin/google-chrome")
+  end
+
+  it 'chrome_binary raise an exeption if nowhere to be found' do
+    allow(File).to receive(:file?).and_return(false)
+    runner = Jasmine::Runners::ChromeHeadless.new(nil, nil, double(config))
+
+    expect {
+      runner.chrome_binary
+    }.to raise_error(RuntimeError)
+  end
+
+  describe "cli_options_string" do
+    it "empty hash is empty result" do
+      runner = Jasmine::Runners::ChromeHeadless.new(nil, nil, double(config))
+      expect(runner.cli_options_string).to eq("")
+    end
+
+    it "formats hash properly" do
+      config[:chrome_cli_options] = {"no-sandbox" => nil, "headless" => nil, "remote-debugging-port" => 9222}
+      runner = Jasmine::Runners::ChromeHeadless.new(nil, nil, double(config))
+      expect(runner.cli_options_string).to eq("--no-sandbox --headless --remote-debugging-port=9222")
+    end
+  end
+
+end

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,94 +87,75 @@ 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
 
-    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')
+    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
-    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')
+      after(:all) do
+        FileUtils.rm('spec/javascripts/helpers/angular_helper.js')
       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'
+      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
+        }
+
+        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
-        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
-    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_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/'))
+          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})
 
-      Bundler.with_clean_env do
-        output = `bundle exec rake jasmine:ci JASMINE_CONFIG_PATH=#{coffee_yaml}`
-        expect(output).to include('6 specs, 0 failures')
+          output = Net::HTTP.get(URI.parse('http://localhost:8888/__spec__/helpers/angular_helper.js'))
+          expect(output).to match(/angular\.mock/)
+        end
       end
     end
 
-    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
-      }
-
-      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']
+    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
 
-      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})
-        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/)
+      after(:all) do
+        FileUtils.rm('app/assets/stylesheets/assets_prefix.js.erb')
       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")
+      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
 
@@ -156,7 +168,7 @@ if rails_available?
       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
+      Bundler.with_unbundled_env do
         output = `bundle exec rake jasmine:ci JASMINE_CONFIG_PATH=#{yaml}`
         expect(output).to include('1 spec, 0 failures')
       end
@@ -168,9 +180,9 @@ if rails_available?
         jasmine_config['rack_options'] = { 'server' => 'webrick' }
       end
 
-      Bundler.with_clean_env do
+      Bundler.with_unbundled_env do
         default_output = `bundle exec rake jasmine:ci`
-        if ENV['RAILS_VERSION'] == 'rails5' || ENV['RAILS_VERSION'].nil?
+        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')
@@ -181,55 +193,98 @@ if rails_available?
       end
     end
 
-    describe 'using sprockets 4' do
-      before :all do
-        FileUtils.cp('Gemfile', 'Gemfile-old')
-        FileUtils.rm 'Gemfile.lock'
+    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/'))
 
-        open('Gemfile', 'a') { |f|
-          f.puts "gem 'sprockets', '~> 4.0.0.beta6'"
-          f.flush
-        }
-        Bundler.with_clean_env do
-          bundle_install
+            js_match = output.match %r{script src.*/(assets/application.debug-[^\.]+\.js)}
+            expect(js_match).to_not be_nil
+
+            js_path = js_match[1]
+            output = Net::HTTP.get(URI.parse("http://localhost:8888/#{js_path}"))
+            expect(output).to match(%r{//# sourceMappingURL=.*\.map})
+          end
         end
+      end
+    end
 
-        FileUtils.mkdir_p('app/assets/config')
+    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')
+          expect($?).to be_success
+        end
+      end
 
-        open('app/assets/config/manifest.js', 'w') { |f|
-          f.puts "//= link application.js"
-          f.puts "//= link application.css"
-          f.flush
-        }
+      it "rake jasmine:ci returns proper exit code when specs fail" do
+        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'
+          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
 
-      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
+      it "rake jasmine:ci runs specs when an error occurs in the javascript" do
+        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'
+          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
       end
 
-      it "serves source mapped assets" do
-        run_jasmine_server do
-          output = Net::HTTP.get(URI.parse('http://localhost:8888/'))
+      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'))
 
-          js_match = output.match %r{script src.*/(assets/application.debug-[^\.]+\.js)}
+          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
+      end
+    end
 
-          expect(js_match).to_not be_nil
-          expect(output).to match(%r{<link rel=.stylesheet.*?href=.*/assets/application.debug-[^\.]+\.css})
+    describe "with phantomJS" do
+      it_behaves_like 'a working jasmine:ci'
+    end
 
-          js_path = js_match[1]
-          output = Net::HTTP.get(URI.parse("http://localhost:8888/#{js_path}"))
-          expect(output).to match(%r{//# sourceMappingURL=.*\.map})
+    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`
         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)