capybara 2.2.1 → 2.3.0

data/spec/capybara_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
-describe Capybara do
-
+RSpec.describe Capybara do
   describe 'default_wait_time' do
     after do
       Capybara.default_wait_time = @previous_default_time
@@ -10,7 +9,7 @@ describe Capybara do
     it "should be changeable" do
       @previous_default_time = Capybara.default_wait_time
       Capybara.default_wait_time = 5
-      Capybara.default_wait_time.should == 5
+      expect(Capybara.default_wait_time).to eq(5)
     end
   end
 
@@ -21,7 +20,7 @@ describe Capybara do
       end
       session = Capybara::Session.new(:schmoo, TestApp)
       session.visit('/')
-      session.body.should include("Hello world!")
+      expect(session.body).to include("Hello world!")
     end
   end
 
@@ -32,19 +31,19 @@ describe Capybara do
 
     it "should default to a proc that calls run_default_server" do
       mock_app = double('app')
-      Capybara.should_receive(:run_default_server).with(mock_app, 8000)
+      expect(Capybara).to receive(:run_default_server).with(mock_app, 8000)
       Capybara.server.call(mock_app, 8000)
     end
 
     it "should return a custom server proc" do
       server = lambda {|app, port|}
       Capybara.server(&server)
-      Capybara.server.should == server
+      expect(Capybara.server).to eq(server)
     end
   end
 end
 
-describe Capybara::Session do
+RSpec.describe Capybara::Session do
   context 'with non-existant driver' do
     it "should raise an error" do
       expect {

data/spec/dsl_spec.rb

@@ -5,7 +5,7 @@ class TestClass
   include Capybara::DSL
 end
 
-Capybara::SpecHelper.run_specs TestClass.new, "DSL", :skip => [
+Capybara::SpecHelper.run_specs TestClass.new, "DSL", :capybara_skip => [
   :js,
   :screenshot,
   :frames,
@@ -14,7 +14,7 @@ Capybara::SpecHelper.run_specs TestClass.new, "DSL", :skip => [
   :hover
 ]
 
-describe Capybara::DSL do
+RSpec.describe Capybara::DSL do
   after do
     Capybara.session_name = nil
     Capybara.default_driver = nil
@@ -25,36 +25,36 @@ describe Capybara::DSL do
 
   describe '#default_driver' do
     it "should default to rack_test" do
-      Capybara.default_driver.should == :rack_test
+      expect(Capybara.default_driver).to eq(:rack_test)
     end
 
     it "should be changeable" do
       Capybara.default_driver = :culerity
-      Capybara.default_driver.should == :culerity
+      expect(Capybara.default_driver).to eq(:culerity)
     end
   end
 
   describe '#current_driver' do
     it "should default to the default driver" do
-      Capybara.current_driver.should == :rack_test
+      expect(Capybara.current_driver).to eq(:rack_test)
       Capybara.default_driver = :culerity
-      Capybara.current_driver.should == :culerity
+      expect(Capybara.current_driver).to eq(:culerity)
     end
 
     it "should be changeable" do
       Capybara.current_driver = :culerity
-      Capybara.current_driver.should == :culerity
+      expect(Capybara.current_driver).to eq(:culerity)
     end
   end
 
   describe '#javascript_driver' do
     it "should default to selenium" do
-      Capybara.javascript_driver.should == :selenium
+      expect(Capybara.javascript_driver).to eq(:selenium)
     end
 
     it "should be changeable" do
       Capybara.javascript_driver = :culerity
-      Capybara.javascript_driver.should == :culerity
+      expect(Capybara.javascript_driver).to eq(:culerity)
     end
   end
 
@@ -62,26 +62,26 @@ describe Capybara::DSL do
     it "should restore the default driver" do
       Capybara.current_driver = :culerity
       Capybara.use_default_driver
-      Capybara.current_driver.should == :rack_test
+      expect(Capybara.current_driver).to eq(:rack_test)
     end
   end
 
   describe '#using_driver' do
     before do
-      Capybara.current_driver.should_not == :selenium
+      expect(Capybara.current_driver).not_to eq(:selenium)
     end
 
     it 'should set the driver using Capybara.current_driver=' do
       driver = nil
       Capybara.using_driver(:selenium) { driver = Capybara.current_driver }
-      driver.should == :selenium
+      expect(driver).to eq(:selenium)
     end
 
     it 'should return the driver to default if it has not been changed' do
       Capybara.using_driver(:selenium) do
-        Capybara.current_driver.should == :selenium
+        expect(Capybara.current_driver).to eq(:selenium)
       end
-      Capybara.current_driver.should == Capybara.default_driver
+      expect(Capybara.current_driver).to eq(Capybara.default_driver)
     end
 
     it 'should reset the driver even if an exception occurs' do
@@ -90,24 +90,24 @@ describe Capybara::DSL do
         Capybara.using_driver(:selenium) { raise "ohnoes!" }
       rescue Exception
       end
-      Capybara.current_driver.should == driver_before_block
+      expect(Capybara.current_driver).to eq(driver_before_block)
     end
 
     it 'should return the driver to what it was previously' do
       Capybara.current_driver = :selenium
       Capybara.using_driver(:culerity) do
         Capybara.using_driver(:rack_test) do
-          Capybara.current_driver.should == :rack_test
+          expect(Capybara.current_driver).to eq(:rack_test)
         end
-        Capybara.current_driver.should == :culerity
+        expect(Capybara.current_driver).to eq(:culerity)
       end
-      Capybara.current_driver.should == :selenium
+      expect(Capybara.current_driver).to eq(:selenium)
     end
 
     it 'should yield the passed block' do
       called = false
       Capybara.using_driver(:selenium) { called = true }
-      called.should == true
+      expect(called).to eq(true)
     end
   end
 
@@ -125,8 +125,8 @@ describe Capybara::DSL do
       Capybara.using_wait_time 6 do
         in_block = Capybara.default_wait_time
       end
-      in_block.should == 6
-      Capybara.default_wait_time.should == @previous_wait_time
+      expect(in_block).to eq(6)
+      expect(Capybara.default_wait_time).to eq(@previous_wait_time)
     end
 
     it "should ensure wait time is reset" do
@@ -135,70 +135,70 @@ describe Capybara::DSL do
           raise "hell"
         end
       end.to raise_error
-      Capybara.default_wait_time.should == @previous_wait_time
+      expect(Capybara.default_wait_time).to eq(@previous_wait_time)
     end
   end
 
   describe '#app' do
     it "should be changeable" do
       Capybara.app = "foobar"
-      Capybara.app.should == 'foobar'
+      expect(Capybara.app).to eq('foobar')
     end
   end
 
   describe '#current_session' do
     it "should choose a session object of the current driver type" do
-      Capybara.current_session.should be_a(Capybara::Session)
+      expect(Capybara.current_session).to be_a(Capybara::Session)
     end
 
     it "should use #app as the application" do
       Capybara.app = proc {}
-      Capybara.current_session.app.should == Capybara.app
+      expect(Capybara.current_session.app).to eq(Capybara.app)
     end
 
     it "should change with the current driver" do
-      Capybara.current_session.mode.should == :rack_test
+      expect(Capybara.current_session.mode).to eq(:rack_test)
       Capybara.current_driver = :selenium
-      Capybara.current_session.mode.should == :selenium
+      expect(Capybara.current_session.mode).to eq(:selenium)
     end
 
     it "should be persistent even across driver changes" do
       object_id = Capybara.current_session.object_id
-      Capybara.current_session.object_id.should == object_id
+      expect(Capybara.current_session.object_id).to eq(object_id)
       Capybara.current_driver = :selenium
-      Capybara.current_session.mode.should == :selenium
-      Capybara.current_session.object_id.should_not == object_id
+      expect(Capybara.current_session.mode).to eq(:selenium)
+      expect(Capybara.current_session.object_id).not_to eq(object_id)
 
       Capybara.current_driver = :rack_test
-      Capybara.current_session.object_id.should == object_id
+      expect(Capybara.current_session.object_id).to eq(object_id)
     end
 
     it "should change when changing application" do
       object_id = Capybara.current_session.object_id
-      Capybara.current_session.object_id.should == object_id
+      expect(Capybara.current_session.object_id).to eq(object_id)
       Capybara.app = proc {}
-      Capybara.current_session.object_id.should_not == object_id
-      Capybara.current_session.app.should == Capybara.app
+      expect(Capybara.current_session.object_id).not_to eq(object_id)
+      expect(Capybara.current_session.app).to eq(Capybara.app)
     end
 
     it "should change when the session name changes" do
       object_id = Capybara.current_session.object_id
       Capybara.session_name = :administrator
-      Capybara.session_name.should == :administrator
-      Capybara.current_session.object_id.should_not == object_id
+      expect(Capybara.session_name).to eq(:administrator)
+      expect(Capybara.current_session.object_id).not_to eq(object_id)
       Capybara.session_name = :default
-      Capybara.session_name.should == :default
-      Capybara.current_session.object_id.should == object_id
+      expect(Capybara.session_name).to eq(:default)
+      expect(Capybara.current_session.object_id).to eq(object_id)
     end
   end
 
   describe "#using_session" do
     it "should change the session name for the duration of the block" do
-      Capybara.session_name.should == :default
+      expect(Capybara.session_name).to eq(:default)
       Capybara.using_session(:administrator) do
-        Capybara.session_name.should == :administrator
+        expect(Capybara.session_name).to eq(:administrator)
       end
-      Capybara.session_name.should == :default
+      expect(Capybara.session_name).to eq(:default)
     end
 
     it "should reset the session to the default, even if an exception occurs" do
@@ -208,19 +208,19 @@ describe Capybara::DSL do
         end
       rescue Exception
       end
-      Capybara.session_name.should == :default
+      expect(Capybara.session_name).to eq(:default)
     end
 
     it "should yield the passed block" do
       called = false
       Capybara.using_session(:administrator) { called = true }
-      called.should == true
+      expect(called).to eq(true)
     end
   end
 
   describe "#session_name" do
     it "should default to :default" do
-      Capybara.session_name.should == :default
+      expect(Capybara.session_name).to eq(:default)
     end
   end
 
@@ -232,22 +232,22 @@ describe Capybara::DSL do
     it "should be possible to include it in another class" do
       @session.visit('/with_html')
       @session.click_link('ullamco')
-      @session.body.should include('Another World')
+      expect(@session.body).to include('Another World')
     end
 
     it "should provide a 'page' shortcut for more expressive tests" do
       @session.page.visit('/with_html')
       @session.page.click_link('ullamco')
-      @session.page.body.should include('Another World')
+      expect(@session.page.body).to include('Another World')
     end
 
     it "should provide an 'using_session' shortcut" do
-      Capybara.should_receive(:using_session).with(:name)
+      expect(Capybara).to receive(:using_session).with(:name)
       @session.using_session(:name)
     end
 
     it "should provide a 'using_wait_time' shortcut" do
-      Capybara.should_receive(:using_wait_time).with(6)
+      expect(Capybara).to receive(:using_wait_time).with(6)
       @session.using_wait_time(6)
     end
   end

data/spec/fixtures/selenium_driver_rspec_failure.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
-describe Capybara::Selenium::Driver do
+RSpec.describe Capybara::Selenium::Driver do
   it "should exit with a non-zero exit status" do
     browser = Capybara::Selenium::Driver.new(TestApp).browser
-    true.should == false
+    expect(true).to eq(false)
   end
 end

data/spec/fixtures/selenium_driver_rspec_success.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
-describe Capybara::Selenium::Driver do
+RSpec.describe Capybara::Selenium::Driver do
   it "should exit with a zero exit status" do
     browser = Capybara::Selenium::Driver.new(TestApp).browser
-    true.should == true
+    expect(true).to eq(true)
   end
 end

data/spec/rack_test_spec.rb

@@ -4,7 +4,7 @@ module TestSessions
   RackTest = Capybara::Session.new(:rack_test, TestApp)
 end
 
-Capybara::SpecHelper.run_specs TestSessions::RackTest, "RackTest", :skip => [
+Capybara::SpecHelper.run_specs TestSessions::RackTest, "RackTest", :capybara_skip => [
   :js,
   :screenshot,
   :frames,
@@ -13,7 +13,7 @@ Capybara::SpecHelper.run_specs TestSessions::RackTest, "RackTest", :skip => [
   :hover
 ]
 
-describe Capybara::Session do
+RSpec.describe Capybara::Session do
   context 'with rack test driver' do
     before do
       @session = TestSessions::RackTest
@@ -21,13 +21,13 @@ describe Capybara::Session do
 
     describe '#driver' do
       it "should be a rack test driver" do
-        @session.driver.should be_an_instance_of(Capybara::RackTest::Driver)
+        expect(@session.driver).to be_an_instance_of(Capybara::RackTest::Driver)
       end
     end
 
     describe '#mode' do
       it "should remember the mode" do
-        @session.mode.should == :rack_test
+        expect(@session.mode).to eq(:rack_test)
       end
     end
 
@@ -36,21 +36,21 @@ describe Capybara::Session do
         @session.driver.options[:respect_data_method] = true
         @session.visit "/with_html"
         @session.click_link "A link with data-method"
-        @session.html.should include('The requested object was deleted')
+        expect(@session.html).to include('The requested object was deleted')
       end
 
       it "should not use data-method if option is false" do
         @session.driver.options[:respect_data_method] = false
         @session.visit "/with_html"
         @session.click_link "A link with data-method"
-        @session.html.should include('Not deleted')
+        expect(@session.html).to include('Not deleted')
       end
 
       it "should use data-method if available even if it's capitalized" do
         @session.driver.options[:respect_data_method] = true
         @session.visit "/with_html"
         @session.click_link "A link with capitalized data-method"
-        @session.html.should include('The requested object was deleted')
+        expect(@session.html).to include('The requested object was deleted')
       end
 
       after do
@@ -63,14 +63,14 @@ describe Capybara::Session do
         it "should submit an empty form-data section if no file is submitted" do
           @session.visit("/form")
           @session.click_button("Upload Empty")
-          @session.html.should include('Successfully ignored empty file field.')
+          expect(@session.html).to include('Successfully ignored empty file field.')
         end
       end
     end
   end
 end
 
-describe Capybara::RackTest::Driver do
+RSpec.describe Capybara::RackTest::Driver do
   before do
     @driver = TestSessions::RackTest.driver
   end
@@ -79,27 +79,27 @@ describe Capybara::RackTest::Driver do
     it 'should always set headers' do
       @driver = Capybara::RackTest::Driver.new(TestApp, :headers => {'HTTP_FOO' => 'foobar'})
       @driver.visit('/get_header')
-      @driver.html.should include('foobar')
+      expect(@driver.html).to include('foobar')
     end
 
     it 'should keep headers on link clicks' do
       @driver = Capybara::RackTest::Driver.new(TestApp, :headers => {'HTTP_FOO' => 'foobar'})
       @driver.visit('/header_links')
       @driver.find_xpath('.//a').first.click
-      @driver.html.should include('foobar')
+      expect(@driver.html).to include('foobar')
     end
 
     it 'should keep headers on form submit' do
       @driver = Capybara::RackTest::Driver.new(TestApp, :headers => {'HTTP_FOO' => 'foobar'})
       @driver.visit('/header_links')
       @driver.find_xpath('.//input').first.click
-      @driver.html.should include('foobar')
+      expect(@driver.html).to include('foobar')
     end
 
     it 'should keep headers on redirects' do
       @driver = Capybara::RackTest::Driver.new(TestApp, :headers => {'HTTP_FOO' => 'foobar'})
       @driver.visit('/get_header_via_redirect')
-      @driver.html.should include('foobar')
+      expect(@driver.html).to include('foobar')
     end
   end
 
@@ -108,16 +108,16 @@ describe Capybara::RackTest::Driver do
       @driver = Capybara::RackTest::Driver.new(TestApp)
 
       @driver.visit('/redirect')
-      @driver.response.header['Location'].should be_nil
-      @driver.browser.current_url.should match %r{/landed$}
+      expect(@driver.response.header['Location']).to be_nil
+      expect(@driver.browser.current_url).to match %r{/landed$}
     end
 
     it "is possible to not follow redirects" do
       @driver = Capybara::RackTest::Driver.new(TestApp, :follow_redirects => false)
 
       @driver.visit('/redirect')
-      @driver.response.header['Location'].should match %r{/redirect_again$}
-      @driver.browser.current_url.should match %r{/redirect$}
+      expect(@driver.response.header['Location']).to match %r{/redirect_again$}
+      expect(@driver.browser.current_url).to match %r{/redirect$}
     end
   end
 
@@ -129,7 +129,7 @@ describe Capybara::RackTest::Driver do
 
       it "should follow 5 redirects" do
         @driver.visit("/redirect/5/times")
-        @driver.html.should include('redirection complete')
+        expect(@driver.html).to include('redirection complete')
       end
 
       it "should not follow more than 6 redirects" do
@@ -146,7 +146,7 @@ describe Capybara::RackTest::Driver do
 
       it "should follow 21 redirects" do
         @driver.visit("/redirect/21/times")
-        @driver.html.should include('redirection complete')
+        expect(@driver.html).to include('redirection complete')
       end
 
       it "should not follow more than 21 redirects" do
@@ -157,3 +157,17 @@ describe Capybara::RackTest::Driver do
     end
   end
 end
+
+module CSSHandlerIncludeTester
+  def dont_extend_css_handler
+    raise 'should never be called'
+  end
+end
+include CSSHandlerIncludeTester
+
+RSpec.describe  Capybara::RackTest::CSSHandlers do  
+  it "should not be extended by global includes" do
+    expect(Capybara::RackTest::CSSHandlers.new).not_to respond_to(:dont_extend_css_handler)
+  end
+end
+