capybara 3.0.3 → 3.1.0

data/spec/rspec_spec.rb

@@ -2,118 +2,120 @@
 
 require 'spec_helper'
 
-RSpec.describe 'capybara/rspec', type: :feature do
-  it "should include Capybara in rspec" do
-    visit('/foo')
-    expect(page.body).to include('Another World')
-  end
-
-  it "should include RSpec matcher proxies" do
-    expect(self.class.ancestors).to include Capybara::RSpecMatcherProxies
-  end
-
-  context "resetting session" do
-    it "sets a cookie in one example..." do
-      visit('/set_cookie')
-      expect(page.body).to include('Cookie set to test_cookie')
-    end
-
-    it "...then it is not available in the next" do
-      visit('/get_cookie')
-      expect(page.body).not_to include('test_cookie')
-    end
-  end
-
-  context "setting the current driver" do
-    it "sets the current driver in one example..." do
-      Capybara.current_driver = :selenium
+RSpec.describe 'capybara/rspec' do
+  context "Feature", type: :feature do
+    it "should include Capybara in rspec" do
+      visit('/foo')
+      expect(page.body).to include('Another World')
     end
 
-    it "...then it has returned to the default in the next example" do
-      expect(Capybara.current_driver).to eq(:rack_test)
+    it "should include RSpec matcher proxies" do
+      expect(self.class.ancestors).to include Capybara::RSpecMatcherProxies
     end
-  end
-
-  it "switches to the javascript driver when giving it as metadata", js: true do
-    expect(Capybara.current_driver).to eq(Capybara.javascript_driver)
-  end
 
-  it "switches to the given driver when giving it as metadata", driver: :culerity do
-    expect(Capybara.current_driver).to eq(:culerity)
-  end
+    context "resetting session" do
+      it "sets a cookie in one example..." do
+        visit('/set_cookie')
+        expect(page.body).to include('Cookie set to test_cookie')
+      end
 
-  context "#all" do
-    it "allows access to the Capybara finder" do
-      visit('/with_html')
-      found = all(:css, 'h2') { |element| element[:class] == 'head' }
-      expect(found.size).to eq(5)
+      it "...then it is not available in the next" do
+        visit('/get_cookie')
+        expect(page.body).not_to include('test_cookie')
+      end
     end
 
-    it "allows access to the RSpec matcher" do
-      visit('/with_html')
-      expect(%w[test1 test2]).to all(be_a(String))
-    end
-  end
+    context "setting the current driver" do
+      it "sets the current driver in one example..." do
+        Capybara.current_driver = :selenium
+      end
 
-  context "#within" do
-    it "allows access to the Capybara scoper" do
-      visit('/with_html')
-      expect do
-        within(:css, "#does_not_exist") { click_link "Go to simple" }
-      end.to raise_error(Capybara::ElementNotFound)
+      it "...then it has returned to the default in the next example" do
+        expect(Capybara.current_driver).to eq(:rack_test)
+      end
     end
 
-    it "allows access to the RSpec matcher" do
-      visit('/with_html')
-      # This reads terribly, but must call #within
-      expect(find(:css, 'span.number').text.to_i).to within(1).of(41)
+    it "switches to the javascript driver when giving it as metadata", js: true do
+      expect(Capybara.current_driver).to eq(Capybara.javascript_driver)
     end
-  end
-end
 
-RSpec.describe 'capybara/rspec', type: :other do
-  context "when RSpec::Matchers is included after Capybara::DSL" do
-    before do
-      class DSLMatchersTest
-        include Capybara::DSL
-        include RSpec::Matchers
-      end
-
-      @test_class_instance = DSLMatchersTest.new
+    it "switches to the given driver when giving it as metadata", driver: :culerity do
+      expect(Capybara.current_driver).to eq(:culerity)
     end
 
     context "#all" do
       it "allows access to the Capybara finder" do
-        @test_class_instance.visit('/with_html')
-        expect(@test_class_instance.all(:css, 'h2.head').size).to eq(5)
+        visit('/with_html')
+        found = all(:css, 'h2') { |element| element[:class] == 'head' }
+        expect(found.size).to eq(5)
       end
 
       it "allows access to the RSpec matcher" do
-        @test_class_instance.visit('/with_html')
-        expect(%w[test1 test2]).to @test_class_instance.all(be_a(String))
+        visit('/with_html')
+        strings = %w[test1 test2]
+        expect(strings).to all(be_a(String))
       end
     end
 
     context "#within" do
       it "allows access to the Capybara scoper" do
-        @test_class_instance.visit('/with_html')
+        visit('/with_html')
         expect do
-          @test_class_instance.within(:css, "#does_not_exist") { @test_class_instance.click_link "Go to simple" }
+          within(:css, "#does_not_exist") { click_link "Go to simple" }
         end.to raise_error(Capybara::ElementNotFound)
       end
 
       it "allows access to the RSpec matcher" do
-        @test_class_instance.visit('/with_html')
+        visit('/with_html')
         # This reads terribly, but must call #within
-        expect(@test_class_instance.find(:css, 'span.number').text.to_i).to @test_class_instance.within(1).of(41)
+        expect(find(:css, 'span.number').text.to_i).to within(1).of(41)
       end
     end
   end
-end
 
-RSpec.describe 'capybara/rspec', type: :other do
-  it "should not include Capybara" do
-    expect { visit('/') }.to raise_error(NoMethodError)
+  context 'Type: Other', type: :other do
+    context "when RSpec::Matchers is included after Capybara::DSL" do
+      before do
+        class DSLMatchersTest
+          include Capybara::DSL
+          include RSpec::Matchers
+        end
+
+        @test_class_instance = DSLMatchersTest.new
+      end
+
+      context "#all" do
+        it "allows access to the Capybara finder" do
+          @test_class_instance.visit('/with_html')
+          expect(@test_class_instance.all(:css, 'h2.head').size).to eq(5)
+        end
+
+        it "allows access to the RSpec matcher" do
+          @test_class_instance.visit('/with_html')
+          strings = %w[test1 test2]
+          expect(strings).to @test_class_instance.all(be_a(String))
+        end
+      end
+
+      context "#within" do
+        it "allows access to the Capybara scoper" do
+          @test_class_instance.visit('/with_html')
+          expect do
+            @test_class_instance.within(:css, "#does_not_exist") { @test_class_instance.click_link "Go to simple" }
+          end.to raise_error(Capybara::ElementNotFound)
+        end
+
+        it "allows access to the RSpec matcher" do
+          @test_class_instance.visit('/with_html')
+          # This reads terribly, but must call #within
+          expect(@test_class_instance.find(:css, 'span.number').text.to_i).to @test_class_instance.within(1).of(41)
+        end
+      end
+    end
+
+    it "should not include Capybara" do
+      expect { visit('/') }.to raise_error(NoMethodError)
+    end
   end
 end
 

data/spec/selenium_spec_marionette.rb

@@ -44,7 +44,7 @@ $stdout.puts `#{Selenium::WebDriver::Firefox.driver_path} --version` if ENV['CI'
 
 Capybara::SpecHelper.run_specs TestSessions::SeleniumMarionette, "selenium", capybara_skip: skipped_tests
 
-RSpec.describe "Capybara::Session with firefox" do
+RSpec.describe "Capybara::Session with firefox" do # rubocop:disable RSpec/MultipleDescribes
   include Capybara::SpecHelper
   include_examples  "Capybara::Session", TestSessions::SeleniumMarionette, :selenium_marionette
   include_examples  Capybara::RSpecMatchers, TestSessions::SeleniumMarionette, :selenium_marionette
@@ -57,7 +57,7 @@ RSpec.describe Capybara::Selenium::Driver do
 
   describe '#quit' do
     it "should reset browser when quit" do
-      expect(@driver.browser).to be
+      expect(@driver.browser).to be_truthy
       @driver.quit
       # access instance variable directly so we don't create a new browser instance
       expect(@driver.instance_variable_get(:@browser)).to be_nil
@@ -74,7 +74,7 @@ RSpec.describe Capybara::Selenium::Driver do
       end
 
       it "warns UnknownError returned during quit because the browser is probably already gone" do
-        expect_any_instance_of(Capybara::Selenium::Driver).to receive(:warn).with(/random message/)
+        allow(@driver).to receive(:warn)
         allow(@driver.browser).to(
           receive(:quit)
           .and_raise(Selenium::WebDriver::Error::UnknownError, "random message")
@@ -82,10 +82,11 @@ RSpec.describe Capybara::Selenium::Driver do
 
         expect { @driver.quit }.not_to raise_error
         expect(@driver.instance_variable_get(:@browser)).to be_nil
+        expect(@driver).to have_received(:warn).with(/random message/)
       end
 
       it "ignores silenced UnknownError returned during quit because the browser is almost definitely already gone" do
-        expect_any_instance_of(Capybara::Selenium::Driver).not_to receive(:warn)
+        allow(@driver).to receive(:warn)
         allow(@driver.browser).to(
           receive(:quit)
           .and_raise(Selenium::WebDriver::Error::UnknownError, "Error communicating with the remote browser")
@@ -93,6 +94,7 @@ RSpec.describe Capybara::Selenium::Driver do
 
         expect { @driver.quit }.not_to raise_error
         expect(@driver.instance_variable_get(:@browser)).to be_nil
+        expect(@driver).not_to have_received(:warn)
       end
     end
   end

data/spec/server_spec.rb

@@ -51,7 +51,7 @@ RSpec.describe Capybara::Server do
 
   it "should use given port" do
     @app = proc { |_env| [200, {}, ["Hello Server!"]] }
-    @server = Capybara::Server.new(@app, 22790).boot
+    @server = Capybara::Server.new(@app, port: 22790).boot
 
     @res = Net::HTTP.start(@server.host, 22790) { |http| http.get('/') }
     expect(@res.body).to include('Hello Server')
@@ -73,6 +73,28 @@ RSpec.describe Capybara::Server do
     expect(@res2.body).to include('Hello Second Server')
   end
 
+  it "should support SSL" do
+    begin
+      key = File.join(Dir.pwd, "spec", "fixtures", "key.pem")
+      cert = File.join(Dir.pwd, "spec", "fixtures", "certificate.pem")
+      Capybara.server = :puma, { Host: "ssl://#{Capybara.server_host}?key=#{key}&cert=#{cert}" }
+      app = proc { |_env| [200, {}, ['Hello SSL Server!']] }
+      server = Capybara::Server.new(app).boot
+
+      expect do
+        Net::HTTP.start(server.host, server.port) { |http| http.get('/__idntify__') }
+      end.to raise_error(EOFError)
+
+      res = Net::HTTP.start(server.host, server.port, use_ssl: true, verify_mode: OpenSSL::SSL::VERIFY_NONE) do |https|
+        https.get('/')
+      end
+
+      expect(res.body).to include('Hello SSL Server!')
+    ensure
+      Capybara.server = :default
+    end
+  end
+
   context "When Capybara.reuse_server is true" do
     before do
       @old_reuse_server = Capybara.reuse_server
@@ -189,10 +211,26 @@ RSpec.describe Capybara::Server do
   it "is not #responsive? when Net::HTTP raises a SystemCallError" do
     app = -> { [200, {}, ['Hello, world']] }
     server = Capybara::Server.new(app)
-    expect(Net::HTTP).to receive(:start).and_raise(SystemCallError.allocate)
+    allow(Net::HTTP).to receive(:start).and_raise(SystemCallError.allocate)
     expect(server.responsive?).to eq false
   end
 
+  [EOFError, Net::ReadTimeout].each do |err|
+    it "should attempt an HTTPS connection if HTTP connection returns #{err}" do
+      app = -> { [200, {}, ['Hello, world']] }
+      ordered_errors = [Errno::ECONNREFUSED, err]
+      # allow(Net::HTTP).to receive(:start).with(anything, anything, hash_excluding(:use_ssl)).and_yield { raise Errno::ECONNREFUSED }
+      allow(Net::HTTP).to receive(:start).with(anything, anything, hash_excluding(:use_ssl)) do
+        raise ordered_errors.shift
+      end
+      response = Net::HTTPSuccess.allocate
+      allow(response).to receive(:body).and_return app.object_id.to_s
+      allow(Net::HTTP).to receive(:start).with(anything, anything, hash_including(use_ssl: true)).and_return(response).once
+      Capybara::Server.new(app).boot
+      expect(Net::HTTP).to have_received(:start).exactly(3).times
+    end
+  end
+
   def start_request(server, wait_time)
     # Start request, but don't wait for it to finish
     socket = TCPSocket.new(server.host, server.port)

data/spec/session_spec.rb

@@ -3,10 +3,18 @@
 require 'spec_helper'
 
 RSpec.describe Capybara::Session do
-  it "verifies a passed app is a rack app" do
-    expect do
-      Capybara::Session.new(:unknown, random: "hash")
-    end.to raise_error TypeError, "The second parameter to Session::new should be a rack app if passed."
+  context "#new" do
+    it "should raise an error if passed non-existent driver" do
+      expect do
+        Capybara::Session.new(:quox, TestApp).driver
+      end.to raise_error(Capybara::DriverNotFoundError)
+    end
+
+    it "verifies a passed app is a rack app" do
+      expect do
+        Capybara::Session.new(:unknown, random: "hash")
+      end.to raise_error TypeError, "The second parameter to Session::new should be a rack app if passed."
+    end
   end
 
   context "current_driver" do

data/spec/shared_selenium_session.rb

@@ -7,27 +7,23 @@ RSpec.shared_examples "Capybara::Session" do |session, mode|
   let(:session) { session }
 
   context 'with selenium driver' do
-    before do
-      @session = session
-    end
-
     describe '#driver' do
       it "should be a selenium driver" do
-        expect(@session.driver).to be_an_instance_of(Capybara::Selenium::Driver)
+        expect(session.driver).to be_an_instance_of(Capybara::Selenium::Driver)
       end
     end
 
     describe '#mode' do
       it "should remember the mode" do
-        expect(@session.mode).to eq(mode)
+        expect(session.mode).to eq(mode)
       end
     end
 
     describe "#reset!" do
       it "freshly reset session should not be touched" do
-        @session.instance_variable_set(:@touched, true)
-        @session.reset!
-        expect(@session.instance_variable_get(:@touched)).to eq false
+        session.instance_variable_set(:@touched, true)
+        session.reset!
+        expect(session.instance_variable_get(:@touched)).to eq false
       end
     end
 
@@ -35,7 +31,7 @@ RSpec.shared_examples "Capybara::Session" do |session, mode|
       before do
         @current_dir = Dir.getwd
         Dir.chdir(File.join(File.dirname(__FILE__), '..'))
-        @env = { 'SELENIUM_BROWSER' => @session.driver.options[:browser].to_s }
+        @env = { 'SELENIUM_BROWSER' => session.driver.options[:browser].to_s }
       end
 
       after do
@@ -59,142 +55,167 @@ RSpec.shared_examples "Capybara::Session" do |session, mode|
 
     describe "#accept_alert", requires: [:modals] do
       it "supports a blockless mode" do
-        @session.visit('/with_js')
-        @session.click_link('Open alert')
-        @session.accept_alert
-        expect { @session.driver.browser.switch_to.alert }.to raise_error(@session.driver.send(:modal_error))
+        session.visit('/with_js')
+        session.click_link('Open alert')
+        session.accept_alert
+        expect { session.driver.browser.switch_to.alert }.to raise_error(session.driver.send(:modal_error))
       end
 
       it "can be called before visiting" do
-        @session.accept_alert "Initial alert" do
-          @session.visit('/initial_alert')
+        session.accept_alert "Initial alert" do
+          session.visit('/initial_alert')
         end
-        expect(@session).to have_text('Initial alert page')
+        expect(session).to have_text('Initial alert page')
       end
     end
 
     context '#fill_in_with empty string and no options' do
       it 'should trigger change when clearing a field' do
-        @session.visit('/with_js')
-        @session.fill_in('with_change_event', with: '')
+        session.visit('/with_js')
+        session.fill_in('with_change_event', with: '')
         # click outside the field to trigger the change event
-        @session.find(:css, 'body').click
-        expect(@session).to have_selector(:css, '.change_event_triggered', match: :one)
+        session.find(:css, 'body').click
+        expect(session).to have_selector(:css, '.change_event_triggered', match: :one)
       end
     end
 
     context "#fill_in with { :clear => :backspace } fill_option", requires: [:js] do
       it 'should fill in a field, replacing an existing value' do
-        @session.visit('/form')
-        @session.fill_in('form_first_name',
-                         with: 'Harry',
-                         fill_options: { clear: :backspace })
-        expect(@session.find(:fillable_field, 'form_first_name').value).to eq('Harry')
+        session.visit('/form')
+        session.fill_in('form_first_name',
+                        with: 'Harry',
+                        fill_options: { clear: :backspace })
+        expect(session.find(:fillable_field, 'form_first_name').value).to eq('Harry')
       end
 
       it 'should only trigger onchange once' do
-        @session.visit('/with_js')
-        @session.fill_in('with_change_event',
-                         with: 'some value',
-                         fill_options: { clear: :backspace })
+        session.visit('/with_js')
+        session.fill_in('with_change_event',
+                        with: 'some value',
+                        fill_options: { clear: :backspace })
         # click outside the field to trigger the change event
-        @session.find(:css, 'body').click
-        expect(@session.find(:css, '.change_event_triggered', match: :one)).to have_text 'some value'
+        session.find(:css, 'body').click
+        expect(session.find(:css, '.change_event_triggered', match: :one)).to have_text 'some value'
       end
 
       it 'should trigger change when clearing field' do
-        @session.visit('/with_js')
-        @session.fill_in('with_change_event',
-                         with: '',
-                         fill_options: { clear: :backspace })
+        session.visit('/with_js')
+        session.fill_in('with_change_event',
+                        with: '',
+                        fill_options: { clear: :backspace })
         # click outside the field to trigger the change event
-        @session.find(:css, 'body').click
-        expect(@session).to have_selector(:css, '.change_event_triggered', match: :one)
+        session.find(:css, 'body').click
+        expect(session).to have_selector(:css, '.change_event_triggered', match: :one)
       end
 
       it 'should trigger input event field_value.length times' do
-        @session.visit('/with_js')
-        @session.fill_in('with_change_event',
-                         with: '',
-                         fill_options: { clear: :backspace })
+        session.visit('/with_js')
+        session.fill_in('with_change_event',
+                        with: '',
+                        fill_options: { clear: :backspace })
         # click outside the field to trigger the change event
-        @session.find(:css, 'body').click
-        expect(@session).to have_xpath('//p[@class="input_event_triggered"]', count: 13)
+        session.find(:css, 'body').click
+        expect(session).to have_xpath('//p[@class="input_event_triggered"]', count: 13)
       end
     end
 
     context "#fill_in with { clear: :none } fill_options" do
       it 'should append to content in a field' do
-        @session.visit('/form')
-        @session.fill_in('form_first_name',
-                         with: 'Harry',
-                         fill_options: { clear: :none })
-        expect(@session.find(:fillable_field, 'form_first_name').value).to eq('JohnHarry')
+        session.visit('/form')
+        session.fill_in('form_first_name',
+                        with: 'Harry',
+                        fill_options: { clear: :none })
+        expect(session.find(:fillable_field, 'form_first_name').value).to eq('JohnHarry')
+      end
+    end
+
+    context  '#fill_in with Date' do
+      before do
+        session.visit('/form')
+        session.execute_script <<-JS
+          window.capybara_formDateFiredEvents = [];
+          ['focus', 'input', 'change'].forEach(function(eventType) {
+            document.getElementById('form_date')
+              .addEventListener(eventType, function() { window.capybara_formDateFiredEvents.push(eventType); });
+          });
+        JS
+        # work around weird FF issue where it would create an extra focus issue in some cases
+        session.find(:css, 'body').click
+      end
+
+      it "should generate standard events on changing value" do
+        session.fill_in('form_date', with: Date.today)
+        expect(session.evaluate_script('window.capybara_formDateFiredEvents')).to eq %w[focus input change]
+      end
+
+      it "should not generate input and change events if the value is not changed" do
+        session.fill_in('form_date', with: Date.today)
+        session.fill_in('form_date', with: Date.today)
+        # Chrome adds an extra focus for some reason - ok for now
+        expect(session.evaluate_script('window.capybara_formDateFiredEvents')).to eq(%w[focus input change])
       end
     end
 
     context "#fill_in with { clear: Array } fill_options" do
       it 'should pass the array through to the element' do
-        pending "selenium-webdriver/geckodriver doesn't support complex sets of characters" if marionette?(@session)
+        pending "selenium-webdriver/geckodriver doesn't support complex sets of characters" if marionette?(session)
         # this is mainly for use with [[:control, 'a'], :backspace] - however since that is platform dependant I'm testing with something less useful
-        @session.visit('/form')
-        @session.fill_in('form_first_name',
-                         with: 'Harry',
-                         fill_options: { clear: [[:shift, 'abc'], :backspace] })
-        expect(@session.find(:fillable_field, 'form_first_name').value).to eq('JohnABHarry')
+        session.visit('/form')
+        session.fill_in('form_first_name',
+                        with: 'Harry',
+                        fill_options: { clear: [[:shift, 'abc'], :backspace] })
+        expect(session.find(:fillable_field, 'form_first_name').value).to eq('JohnABHarry')
       end
     end
 
     describe "#path" do
       it "returns xpath" do
         # this is here because it is testing for an XPath that is specific to the algorithm used in the selenium driver
-        @session.visit('/path')
-        element = @session.find(:link, 'Second Link')
+        session.visit('/path')
+        element = session.find(:link, 'Second Link')
         expect(element.path).to eq('/html/body/div[2]/a[1]')
       end
     end
 
     describe "all with disappearing elements" do
       it "ignores stale elements in results" do
-        @session.visit('/path')
-        elements = @session.all(:link) { |_node| raise Selenium::WebDriver::Error::StaleElementReferenceError }
+        session.visit('/path')
+        elements = session.all(:link) { |_node| raise Selenium::WebDriver::Error::StaleElementReferenceError }
         expect(elements.size).to eq 0
       end
     end
 
     describe "#evaluate_script" do
       it "can return an element" do
-        @session.visit('/form')
-        element = @session.evaluate_script("document.getElementById('form_title')")
-        expect(element).to eq @session.find(:id, 'form_title')
+        session.visit('/form')
+        element = session.evaluate_script("document.getElementById('form_title')")
+        expect(element).to eq session.find(:id, 'form_title')
       end
 
       it "can return arrays of nested elements" do
-        @session.visit('/form')
-        elements = @session.evaluate_script('document.querySelectorAll("#form_city option")')
-        elements.each do |el|
-          expect(el).to be_instance_of Capybara::Node::Element
-        end
-        expect(elements).to eq @session.find(:css, '#form_city').all(:css, 'option').to_a
+        session.visit('/form')
+        elements = session.evaluate_script('document.querySelectorAll("#form_city option")')
+        expect(elements).to all(be_instance_of Capybara::Node::Element)
+        expect(elements).to eq session.find(:css, '#form_city').all(:css, 'option').to_a
       end
 
       it "can return hashes with elements" do
-        @session.visit('/form')
-        result = @session.evaluate_script("{ a: document.getElementById('form_title'), b: {c: document.querySelectorAll('#form_city option')}}")
+        session.visit('/form')
+        result = session.evaluate_script("{ a: document.getElementById('form_title'), b: {c: document.querySelectorAll('#form_city option')}}")
         expect(result).to eq(
-          'a' => @session.find(:id, 'form_title'),
+          'a' => session.find(:id, 'form_title'),
           'b' => {
-            'c' => @session.find(:css, '#form_city').all(:css, 'option').to_a
+            'c' => session.find(:css, '#form_city').all(:css, 'option').to_a
           }
         )
       end
 
       describe "#evaluate_async_script" do
         it "will timeout if the script takes too long" do
-          @session.visit('/with_js')
+          session.visit('/with_js')
           expect do
-            @session.using_wait_time(1) do
-              @session.evaluate_async_script("var cb = arguments[0]; setTimeout(function(){ cb(null) }, 3000)")
+            session.using_wait_time(1) do
+              session.evaluate_async_script("var cb = arguments[0]; setTimeout(function(){ cb(null) }, 3000)")
             end
           end.to raise_error Selenium::WebDriver::Error::ScriptTimeoutError
         end
@@ -203,27 +224,28 @@ RSpec.shared_examples "Capybara::Session" do |session, mode|
 
     describe "Element#inspect" do
       it "outputs obsolete elements" do
-        @session.visit('/form')
-        el = @session.find(:button, 'Click me!').click
-        expect(@session).to have_no_button('Click me!')
-        expect(el).not_to receive(:synchronize)
+        session.visit('/form')
+        el = session.find(:button, 'Click me!').click
+        expect(session).to have_no_button('Click me!')
+        allow(el).to receive(:synchronize)
         expect(el.inspect).to eq "Obsolete #<Capybara::Node::Element>"
+        expect(el).not_to have_received(:synchronize)
       end
     end
 
     describe "Element#click" do
       it "should handle fixed headers/footers" do
-        @session.visit('/with_fixed_header_footer')
-        # @session.click_link('Go to root')
-        @session.find(:link, 'Go to root').click
-        expect(@session).to have_current_path('/')
+        session.visit('/with_fixed_header_footer')
+        # session.click_link('Go to root')
+        session.find(:link, 'Go to root').click
+        expect(session).to have_current_path('/')
       end
     end
 
     context "Windows" do
       it "can't close the primary window" do
         expect do
-          @session.current_window.close
+          session.current_window.close
         end.to raise_error(ArgumentError, 'Not allowed to close the primary window')
       end
     end