jasmine 2.0.0 → 2.99.0

data/spec/ci_runner_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+
+describe Jasmine::CiRunner do
+  let(:runner) { double(:runner, :run => nil) }
+  let(:runner_factory) { double(:runner_factory, :call => runner) }
+
+  let(:config) do
+    double(:configuration,
+           :runner => runner_factory,
+           :formatters => [],
+           :host => 'http://foo.bar.com',
+           :port => '1234',
+           :rack_options => 'rack options',
+           :stop_spec_on_expectation_failure => false,
+           :random => false
+          )
+  end
+
+  let(:thread_instance) { double(:thread, :abort_on_exception= => nil) }
+  let(:fake_thread) do
+    thread = double(:thread)
+    allow(thread).to receive(:new) do |&block|
+      @thread_block = block
+      thread_instance
+    end
+    thread
+  end
+  let(:application_factory) { double(:application, :app => 'my fake app') }
+  let(:fake_server) { double(:server, :start => nil) }
+  let(:server_factory) { double(:server_factory, :new => fake_server) }
+  let(:outputter) { double(:outputter, :puts => nil) }
+
+  before do
+    allow(Jasmine).to receive(:wait_for_listener)
+  end
+
+  it 'starts a server and runner' do
+    ci_runner = Jasmine::CiRunner.new(config, thread: fake_thread, application_factory: application_factory, server_factory: server_factory, outputter: outputter)
+
+    ci_runner.run
+
+    expect(config).to have_received(:port).with(:ci).at_least(:once)
+    expect(config).not_to have_received(:port).with(:server)
+
+    expect(runner_factory).to have_received(:call).with(instance_of(Jasmine::Formatters::Multi), /\bthrowFailures=false\b/)
+    expect(runner_factory).to have_received(:call).with(instance_of(Jasmine::Formatters::Multi), /\brandom=false\b/)
+
+    expect(application_factory).to have_received(:app).with(config)
+    expect(server_factory).to have_received(:new).with('1234', 'my fake app', 'rack options')
+
+    expect(fake_thread).to have_received(:new)
+    expect(thread_instance).to have_received(:abort_on_exception=).with(true)
+
+    @thread_block.call
+    expect(fake_server).to have_received(:start)
+
+    expect(Jasmine).to have_received(:wait_for_listener).with('1234', 'foo.bar.com')
+
+    expect(runner).to have_received(:run)
+  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')
+    expect(config).to receive(:runner_boot_files=) do |proc|
+      expect(proc.call).to eq ['foo/bar/baz.js']
+    end
+
+    ci_runner = Jasmine::CiRunner.new(config, thread: fake_thread, application_factory: application_factory, server_factory: server_factory, outputter: outputter)
+
+    ci_runner.run
+  end
+
+  it 'returns true for a successful run' do
+    allow(Jasmine::Formatters::ExitCode).to receive(:new) { double(:exit_code, :succeeded? => true) }
+
+    ci_runner = Jasmine::CiRunner.new(config, thread: fake_thread, application_factory: application_factory, server_factory: server_factory, outputter: outputter)
+
+    expect(ci_runner.run).to be(true)
+  end
+
+  it 'returns false for a failed run' do
+    allow(Jasmine::Formatters::ExitCode).to receive(:new) { double(:exit_code, :succeeded? => false) }
+
+    ci_runner = Jasmine::CiRunner.new(config, thread: fake_thread, application_factory: application_factory, server_factory: server_factory, outputter: outputter)
+
+    expect(ci_runner.run).to be(false)
+  end
+
+  it 'can tell the jasmine page to throw expectation failures' do
+    allow(config).to receive(:stop_spec_on_expectation_failure) { true }
+
+    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(instance_of(Jasmine::Formatters::Multi), /\bthrowFailures=true\b/)
+  end
+
+  it 'can tell the jasmine page to randomize' do
+    allow(config).to receive(:random) { true }
+
+    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(instance_of(Jasmine::Formatters::Multi), /\brandom=true\b/)
+  end
+
+  it 'allows randomization to be turned on, overriding the config' do
+    allow(config).to receive(:random) { false }
+
+    ci_runner = Jasmine::CiRunner.new(config, random: true, thread: fake_thread, application_factory: application_factory, server_factory: server_factory, outputter: outputter)
+
+    ci_runner.run
+
+    expect(runner_factory).to have_received(:call).with(instance_of(Jasmine::Formatters::Multi), /\brandom=true\b/)
+  end
+
+  it 'allows randomization to be turned off, overriding the config' do
+    allow(config).to receive(:random) { true }
+
+    ci_runner = Jasmine::CiRunner.new(config, random: false, thread: fake_thread, application_factory: application_factory, server_factory: server_factory, outputter: outputter)
+
+    ci_runner.run
+
+    expect(runner_factory).to have_received(:call).with(instance_of(Jasmine::Formatters::Multi), /\brandom=false\b/)
+  end
+
+  it 'allows a randomization seed to be specified' do
+    ci_runner = Jasmine::CiRunner.new(config, seed: '4231', thread: fake_thread, application_factory: application_factory, server_factory: server_factory, outputter: outputter)
+
+    ci_runner.run
+
+    expect(runner_factory).to have_received(:call).with(instance_of(Jasmine::Formatters::Multi), /\bseed=4231\b/)
+  end
+end

data/spec/configuration_spec.rb

@@ -53,10 +53,10 @@ describe Jasmine::Configuration do
       config.add_path_mapper(lambda { |c| test_mapper1.new(c) })
       config.add_path_mapper(lambda { |c| test_mapper2.new(c) })
       config.add_path_mapper(lambda { |c| test_mapper3.new(c) })
-      config.css_files.should == []
+      expect(config.css_files).to eq []
       config.jasmine_css_files = lambda { %w(jasmine_css) }
       config.css_files = lambda { %w(css) }
-      config.css_files.should == %w(mapped_jasmine/jasmine_css/jasmine mapped_src/css/src)
+      expect(config.css_files).to eq %w(mapped_jasmine/jasmine_css/jasmine mapped_src/css/src)
     end
   end
 
@@ -66,14 +66,16 @@ describe Jasmine::Configuration do
       config.add_path_mapper(lambda { |c| test_mapper1.new(c) })
       config.add_path_mapper(lambda { |c| test_mapper2.new(c) })
       config.add_path_mapper(lambda { |c| test_mapper3.new(c) })
-      config.js_files.should == []
+      expect(config.js_files).to eq []
       config.jasmine_files = lambda { %w(jasmine) }
       config.src_files = lambda  { %w(src) }
       config.boot_files = lambda { %w(boot) }
       config.spec_files = lambda { %w(spec) }
-      config.js_files.should == %w(
+      config.helper_files = lambda { %w(helper) }
+      expect(config.js_files).to eq %w(
         mapped_jasmine/jasmine/jasmine
         mapped_boot/boot/boot mapped_src/src/src
+        mapped_spec/helper/spec
         mapped_spec/spec/spec)
     end
   end
@@ -84,8 +86,8 @@ describe Jasmine::Configuration do
       result = double
       config.add_rack_path('some/path', lambda { result })
       map = config.rack_path_map
-      map['some/path'].should be
-      map['some/path'].call.should == result
+      expect(map['some/path']).to be
+      expect(map['some/path'].call).to eq result
     end
   end
 
@@ -94,26 +96,42 @@ describe Jasmine::Configuration do
       config = Jasmine::Configuration.new()
       app = double
       config.add_rack_app(app)
-      config.rack_apps.should == [[app, nil]]
+      expect(config.rack_apps).to eq [{ :app => app, :args => [], :block => nil }]
     end
-    it 'permits the addition of arbitary rack apps with arbitrary config' do
+
+    it 'permits the addition of arbitary rack apps with a config block' do
       config = Jasmine::Configuration.new()
       app = double
       block = lambda { 'foo' }
       config.add_rack_app(app, &block)
-      config.rack_apps.should == [[app, block]]
+      expect(config.rack_apps).to eq [{ :app => app, :args => [], :block => block }]
+    end
+
+    it 'permits the addition of arbitary rack apps with arbitrary config' do
+      config = Jasmine::Configuration.new()
+      app = double
+      config.add_rack_app(app, { :foo => 'bar' })
+      expect(config.rack_apps).to eq [{ :app => app, :args => [{ :foo => 'bar' }], :block => nil }]
+    end
+
+    it 'permits the addition of arbitary rack apps with arbitrary config and a config block' do
+      config = Jasmine::Configuration.new()
+      app = double
+      block = lambda { 'foo' }
+      config.add_rack_app(app, { :foo => 'bar' }, &block)
+      expect(config.rack_apps).to eq [{ :app => app, :args => [{ :foo => 'bar' }], :block => block }]
     end
   end
 
   describe 'host' do
     it 'should default to localhost' do
-      Jasmine::Configuration.new().host.should == 'http://localhost'
+      expect(Jasmine::Configuration.new().host).to eq 'http://localhost'
     end
 
     it 'returns host if set' do
       config = Jasmine::Configuration.new()
       config.host = 'foo'
-      config.host.should == 'foo'
+      expect(config.host).to eq 'foo'
     end
   end
 
@@ -121,36 +139,52 @@ describe Jasmine::Configuration do
     it 'returns value if set' do
       config = Jasmine::Configuration.new()
       config.spec_format = 'fish'
-      config.spec_format.should == 'fish'
+      expect(config.spec_format).to eq 'fish'
+    end
+  end
+
+  describe 'prevent phantomjs auto install' do
+    it 'returns value if set' do
+      config = Jasmine::Configuration.new()
+      config.prevent_phantom_js_auto_install = true
+      expect(config.prevent_phantom_js_auto_install).to eq true
+    end
+  end
+
+  describe 'show full stack trace' do
+    it 'returns value if set' do
+      config = Jasmine::Configuration.new()
+      config.show_full_stack_trace = true
+      expect(config.show_full_stack_trace).to eq true
     end
   end
 
   describe 'jasmine ports' do
     it 'returns new CI port and caches return value' do
       config = Jasmine::Configuration.new()
-      Jasmine.stub(:find_unused_port).and_return('1234')
-      config.port(:ci).should == '1234'
-      Jasmine.stub(:find_unused_port).and_return('4321')
-      config.port(:ci).should == '1234'
+      allow(Jasmine).to receive(:find_unused_port).and_return('1234')
+      expect(config.port(:ci)).to eq '1234'
+      allow(Jasmine).to receive(:find_unused_port).and_return('4321')
+      expect(config.port(:ci)).to eq '1234'
     end
 
     it 'returns ci port if configured' do
       config = Jasmine::Configuration.new()
       config.ci_port = '5678'
-      Jasmine.stub(:find_unused_port).and_return('1234')
-      config.port(:ci).should == '5678'
+      allow(Jasmine).to receive(:find_unused_port).and_return('1234')
+      expect(config.port(:ci)).to eq '5678'
     end
 
     it 'returns configured server port' do
       config = Jasmine::Configuration.new()
       config.server_port = 'fish'
-      config.port(:server).should == 'fish'
+      expect(config.port(:server)).to eq 'fish'
     end
 
     it 'returns default server port' do
       config = Jasmine::Configuration.new()
 
-      config.port(:server).should == 8888
+      expect(config.port(:server)).to eq 8888
     end
   end
 
@@ -158,13 +192,13 @@ describe Jasmine::Configuration do
     it 'returns value if set' do
       config = Jasmine::Configuration.new()
       config.formatters = ['pants']
-      config.formatters.should == ['pants']
+      expect(config.formatters).to eq ['pants']
     end
 
     it 'returns defaults' do
       config = Jasmine::Configuration.new()
 
-      config.formatters.should == [Jasmine::Formatters::Console]
+      expect(config.formatters).to eq [Jasmine::Formatters::Console]
     end
   end
 
@@ -173,7 +207,7 @@ describe Jasmine::Configuration do
       config = Jasmine::Configuration.new
       foo = double(:foo)
       config.runner = foo
-      config.runner.should == foo
+      expect(config.runner).to eq foo
     end
 
     it 'does nothing by default' do

data/spec/fixture/afterall_spec.js

@@ -0,0 +1,8 @@
+describe('failing afterAll', function() {
+  afterAll(function() {
+    throw 'afterAll go boom';
+  });
+
+  it('is fine otherwise', function() {
+  });
+});

data/spec/fixture/console_log_spec.js

@@ -0,0 +1,5 @@
+describe('console.log', function() {
+  it('can be passed through', function() {
+    console.log("I'm in the webpage!");
+  });
+});

data/spec/fixture/exception_test.js

@@ -0,0 +1 @@
+desibe('oops', function() {});

data/spec/fixture/phantomConfig.js

@@ -0,0 +1,6 @@
+exports.configure = function (page) {
+  page.viewportSize = {
+    width: 200,
+    height: 400
+  };
+};

data/spec/fixture/viewport_spec.js

@@ -0,0 +1,6 @@
+describe('having a viewport', function() {
+  it('should have a small viewport', function() {
+    expect(window.innerWidth).toBe(200);
+    expect(window.innerHeight).toBe(400);
+  });
+});

data/spec/jasmine_command_line_tool_spec.rb

@@ -14,26 +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'] }
+        expect(output).to match /Jasmine has been installed\./
+
+        config = YAML.load_file(File.join(@tmp, 'spec/javascripts/support/jasmine.yml'))
+        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
 
@@ -50,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
@@ -61,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
 
@@ -81,43 +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 [] }
+    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'] }
+    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,35 +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/)
+    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
@@ -58,6 +59,66 @@ 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
+    before do
+      FileUtils.cp(File.join(@root, 'spec', 'fixture', 'console_log_spec.js'), File.join('spec', 'javascripts'))
+    end
+
+    it 'hides console.log by default' do
+      output = `rake jasmine:ci`
+      expect(output).to_not include("I'm in the webpage!")
+    end
+
+    it 'can be told to show console.log' do
+      log_yaml = custom_jasmine_config('log') do |jasmine_config|
+        jasmine_config['show_console_log'] = true
+      end
+      output = `rake jasmine:ci JASMINE_CONFIG_PATH=#{log_yaml}`
+      expect(output).to include("I'm in the webpage!")
+    end
+  end
+
+  it 'should allow customizing the phantom page' do
+    FileUtils.cp(File.join(@root, 'spec', 'fixture', 'viewport_spec.js'), File.join('spec', 'javascripts'))
+    FileUtils.cp(File.join(@root, 'spec', 'fixture', 'phantomConfig.js'), File.join('spec', 'javascripts', 'support'))
+    viewport_yaml = custom_jasmine_config('viewport') do |jasmine_config|
+      jasmine_config['phantom_config_script'] = 'spec/javascripts/support/phantomConfig.js'
+      jasmine_config['show_console_log'] = true
+    end
+
+    output = `rake jasmine:ci JASMINE_CONFIG_PATH=#{viewport_yaml}`
+    expect(output).to match /[1-9]\d* specs, 0 failures/
+  end
+
+  it 'should throw a useful error when the phantom customization fails' do
+    bad_phantom_yaml = custom_jasmine_config('viewport') do |jasmine_config|
+      jasmine_config['phantom_config_script'] = 'spec/javascripts/support/doesNotExist.js'
+      jasmine_config['show_console_log'] = true
+    end
+
+    output = `rake jasmine:ci JASMINE_CONFIG_PATH=#{bad_phantom_yaml}`
+    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`
+    expect($?).to_not be_success
+    expect(output).to match /afterAll go boom/
+  end
+
+  it 'should tell jasmine to randomize the execution order' do
+    randomized_yaml = custom_jasmine_config('random') do |jasmine_config|
+      jasmine_config['random'] = true
+    end
+
+    output = `rake jasmine:ci JASMINE_CONFIG_PATH=#{randomized_yaml}`
+    expect($?).to be_success
+    expect(output).to match /Randomized with seed/
   end
 end