capybara-mechanize 1.11.0 → 1.12.0

data/spec/driver/mechanize_driver_spec.rb

@@ -1,104 +1,106 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Capybara::Mechanize::Driver, 'local' do
   let(:driver) { Capybara::Mechanize::Driver.new(ExtendedTestApp) }
 
-  describe "#configure" do
-    it "allows extended configuration of the agent" do
-      ::Mechanize.any_instance.should_receive(:foo=).with("test")
+  describe '#configure' do
+    it 'allows extended configuration of the agent' do
+      expect_any_instance_of(::Mechanize).to receive(:foo=).with('test')
       driver.configure do |agent|
-        agent.foo = "test"
+        agent.foo = 'test'
       end
     end
   end
 
   describe ':headers option' do
     it 'should always set headers' do
-      driver = Capybara::RackTest::Driver.new(TestApp, :headers => {'HTTP_FOO' => 'foobar'})
+      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 = 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 = 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 = 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
 
   describe ':follow_redirects option' do
-    it "defaults to following redirects" do
+    it 'defaults to following redirects' 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)
+    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
 
   describe ':redirect_limit option' do
-    context "with default redirect limit" do
+    context 'with default redirect limit' do
       let(:driver) { Capybara::RackTest::Driver.new(TestApp) }
 
-      it "should follow 5 redirects" do
-        driver.visit("/redirect/5/times")
-        driver.html.should include('redirection complete')
+      it 'should follow 5 redirects' do
+        driver.visit('/redirect/5/times')
+        expect(driver.html).to include('redirection complete')
       end
 
-      it "should not follow more than 6 redirects" do
+      it 'should not follow more than 6 redirects' do
         expect do
-          driver.visit("/redirect/6/times")
+          driver.visit('/redirect/6/times')
         end.to raise_error(Capybara::InfiniteRedirectError)
       end
     end
 
-    context "with 21 redirect limit" do
-      let(:driver) { Capybara::RackTest::Driver.new(TestApp, :redirect_limit => 21) }
+    context 'with 21 redirect limit' do
+      let(:driver) { Capybara::RackTest::Driver.new(TestApp, redirect_limit: 21) }
 
-      it "should follow 21 redirects" do
-        driver.visit("/redirect/21/times")
-        driver.html.should include('redirection complete')
+      it 'should follow 21 redirects' do
+        driver.visit('/redirect/21/times')
+        expect(driver.html).to include('redirection complete')
       end
 
-      it "should not follow more than 21 redirects" do
+      it 'should not follow more than 21 redirects' do
         expect do
-          driver.visit("/redirect/22/times")
+          driver.visit('/redirect/22/times')
         end.to raise_error(Capybara::InfiniteRedirectError)
       end
     end
   end
 
-  it "should default to local mode for relative paths" do
-    driver.should_not be_remote('/')
+  it 'should default to local mode for relative paths' do
+    expect(driver).not_to be_remote('/')
   end
 
-  it "should default to local mode for the default host" do
-    driver.should_not be_remote('http://www.example.com')
+  it 'should default to local mode for the default host' do
+    expect(driver).not_to be_remote('http://www.example.com')
   end
 
-  context "with an app_host" do
+  context 'with an app_host' do
     before do
       Capybara.app_host = 'http://www.remote.com'
     end
@@ -107,12 +109,12 @@ describe Capybara::Mechanize::Driver, 'local' do
       Capybara.app_host = nil
     end
 
-    it "should treat urls as remote" do
-      driver.should be_remote('http://www.remote.com')
+    it 'should treat urls as remote' do
+      expect(driver).to be_remote('http://www.remote.com')
     end
   end
 
-  context "with a default url, no app host" do
+  context 'with a default url, no app host' do
     before do
       Capybara.default_host = 'http://www.local.com'
     end
@@ -121,7 +123,7 @@ describe Capybara::Mechanize::Driver, 'local' do
       Capybara.default_host = CAPYBARA_DEFAULT_HOST
     end
 
-    context "local hosts" do
+    context 'local hosts' do
       before do
         Capybara::Mechanize.local_hosts = ['subdomain.local.com']
       end
@@ -130,51 +132,51 @@ describe Capybara::Mechanize::Driver, 'local' do
         Capybara::Mechanize.local_hosts = nil
       end
 
-      it "should allow local hosts to be set" do
-        driver.should_not be_remote('http://subdomain.local.com')
+      it 'should allow local hosts to be set' do
+        expect(driver).not_to be_remote('http://subdomain.local.com')
       end
     end
 
-    it "should treat urls with the same host names as local" do
-      driver.should_not be_remote('http://www.local.com')
+    it 'should treat urls with the same host names as local' do
+      expect(driver).not_to be_remote('http://www.local.com')
     end
 
-    it "should treat other urls as remote" do
-      driver.should be_remote('http://www.remote.com')
+    it 'should treat other urls as remote' do
+      expect(driver).to be_remote('http://www.remote.com')
     end
 
-    it "should treat relative paths as remote if the previous request was remote" do
+    it 'should treat relative paths as remote if the previous request was remote' do
       driver.visit(remote_test_url)
-      driver.should be_remote('/some_relative_link')
+      expect(driver).to be_remote('/some_relative_link')
     end
 
-    it "should treat relative paths as local if the previous request was local" do
+    it 'should treat relative paths as local if the previous request was local' do
       driver.visit('http://www.local.com')
-      driver.should_not be_remote('/some_relative_link')
+      expect(driver).not_to be_remote('/some_relative_link')
     end
 
-    it "should receive the right host" do
+    it 'should receive the right host' do
       driver.visit('http://www.local.com/host')
       should_be_a_local_get
     end
 
-    it "should consider relative paths to be local when the previous request was local" do
+    it 'should consider relative paths to be local when the previous request was local' do
       driver.visit('http://www.local.com/host')
       driver.visit('/host')
 
       should_be_a_local_get
-      driver.should_not be_remote('/first_local')
+      expect(driver).not_to be_remote('/first_local')
     end
 
-    it "should consider relative paths to be remote when the previous request was remote" do
+    it 'should consider relative paths to be remote when the previous request was remote' do
       driver.visit("#{remote_test_url}/host")
       driver.get('/host')
 
       should_be_a_remote_get
-      driver.should be_remote('/second_remote')
+      expect(driver).to be_remote('/second_remote')
     end
 
-    it "should always switch to the right context" do
+    it 'should always switch to the right context' do
       driver.visit('http://www.local.com/host')
       driver.get('/host')
       driver.get("#{remote_test_url}/host")
@@ -182,44 +184,44 @@ describe Capybara::Mechanize::Driver, 'local' do
       driver.get('http://www.local.com/host')
 
       should_be_a_local_get
-      driver.should_not be_remote('/second_local')
+      expect(driver).not_to be_remote('/second_local')
     end
 
-    it "should follow redirects from local to remote" do
+    it 'should follow redirects from local to remote' do
       driver.visit("http://www.local.com/redirect_to/#{remote_test_url}/host")
       should_be_a_remote_get
     end
 
-    it "should follow redirects from remote to local" do
+    it 'should follow redirects from remote to local' do
       driver.visit("#{remote_test_url}/redirect_to/http://www.local.com/host")
       should_be_a_local_get
     end
 
-    it "passes the status code of remote calls back to be validated" do
+    it 'passes the status code of remote calls back to be validated' do
       quietly do
         driver.visit(remote_test_url)
         driver.get('/asdfafadfsdfs')
-        driver.response.status.should be >= 400
+        expect(driver.response.status).to be >= 400
       end
     end
 
-    context "when errors are set to true" do
-      it "raises an useful error because it is probably a misconfiguration" do
+    context 'when errors are set to true' do
+      it 'raises an useful error because it is probably a misconfiguration' do
         quietly do
           original = Capybara.raise_server_errors
 
-          expect {
+          expect do
             driver.visit(remote_test_url)
             Capybara.raise_server_errors = true
             driver.get('/asdfafadfsdfs')
-          }.to raise_error(%r{Received the following error for a GET request to /asdfafadfsdfs:})
+          end.to raise_error(%r{Received the following error for a GET request to /asdfafadfsdfs:})
           Capybara.raise_server_errors = original
         end
       end
     end
   end
 
-  it "should include the right host when remote" do
+  it 'should include the right host when remote' do
     driver.visit("#{remote_test_url}/host")
     should_be_a_remote_get
   end
@@ -237,17 +239,16 @@ describe Capybara::Mechanize::Driver, 'local' do
       driver.visit("#{remote_test_url}/host")
       should_be_a_remote_get
       driver.reset!
-      driver.visit("/host")
+      driver.visit('/host')
       should_be_a_local_get
     end
   end
 
   def should_be_a_remote_get
-    driver.current_url.should include(remote_test_url)
+    expect(driver.current_url).to include(remote_test_url)
   end
 
   def should_be_a_local_get
-    driver.current_url.should include("www.local.com")
+    expect(driver.current_url).to include('www.local.com')
   end
-
 end

data/spec/driver/remote_mechanize_driver_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe Capybara::Mechanize::Driver, 'remote' do
@@ -11,35 +13,35 @@ describe Capybara::Mechanize::Driver, 'remote' do
 
   let(:driver) { Capybara::Mechanize::Driver.new(ExtendedTestApp) }
 
-  context "in remote mode" do
-    it "should pass arguments through to a get request" do
-      driver.visit("#{remote_test_url}/form/get", {:form => {:value => "success"}})
-      driver.html.should include('success')
+  context 'in remote mode' do
+    it 'should pass arguments through to a get request' do
+      driver.visit("#{remote_test_url}/form/get", form: { value: 'success' })
+      expect(driver.html).to include('success')
     end
 
-    it "should pass arguments through to a post request" do
-      driver.post("#{remote_test_url}/form", {:form => {:value => "success"}})
-      driver.html.should include('success')
+    it 'should pass arguments through to a post request' do
+      driver.post("#{remote_test_url}/form", form: { value: 'success' })
+      expect(driver.html).to include('success')
     end
 
-    describe "redirect" do
-      it "should handle redirects with http-params" do
+    describe 'redirect' do
+      it 'should handle redirects with http-params' do
         driver.visit "#{remote_test_url}/redirect_with_http_param"
-        driver.html.should include('correct redirect')
+        expect(driver.html).to include('correct redirect')
       end
     end
 
-    context "for a post request" do
+    context 'for a post request' do
       it 'transforms nested map in post data' do
-        driver.post("#{remote_test_url}/form", {:form => {:key => 'value'}})
-        driver.html.should match(/:key=>"value"|key: value/)
+        driver.post("#{remote_test_url}/form", form: { key: 'value' })
+        expect(driver.html).to match(/:key=>"value"|key: value/)
       end
     end
 
     context 'process remote request' do
       it 'transforms nested map in post data' do
-        driver.submit(:post, "#{remote_test_url}/form", {:form => {:key => 'value'}})
-        driver.html.should match(/:key=>"value"|key: value/)
+        driver.submit(:post, "#{remote_test_url}/form", form: { key: 'value' })
+        expect(driver.html).to match(/:key=>"value"|key: value/)
       end
     end
   end

data/spec/session/mechanize_spec.rb

@@ -1,23 +1,37 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module TestSessions
   Mechanize = Capybara::Session.new(:mechanize, TestApp)
 end
 
-Capybara::SpecHelper.run_specs TestSessions::Mechanize, "Mechanize", :capybara_skip => [
-  :js,
-  :screenshot,
-  :frames,
-  :windows,
-  :server,
-  :hover,
-  :modals,
-  :about_scheme,
-  :send_keys,
-  :css,
-  :download
+skipped_tests = %i[
+  about_scheme
+  active_element
+  css
+  download
+  frames
+  hover
+  html_validation
+  js
+  modals
+  screenshot
+  scroll
+  send_keys
+  server
+  shadow_dom
+  spatial
+  windows
 ]
 
+Capybara::SpecHelper.run_specs(TestSessions::Mechanize, 'Mechanize', capybara_skip: skipped_tests) do |example|
+  case example.metadata[:full_description]
+  when /has_css\? should support case insensitive :class and :id options/
+    skip "Nokogiri doesn't support case insensitive CSS attribute matchers"
+  end
+end
+
 describe Capybara::Session do
   context 'with mechanize driver' do
     let(:session) { Capybara::Session.new(:mechanize, ExtendedTestApp) }
@@ -31,37 +45,37 @@ describe Capybara::Session do
     end
 
     describe '#driver' do
-      it "should be a mechanize driver" do
-        session.driver.should be_an_instance_of(Capybara::Mechanize::Driver)
+      it 'should be a mechanize driver' do
+        expect(session.driver).to be_an_instance_of(Capybara::Mechanize::Driver)
       end
     end
 
     describe '#mode' do
-      it "should remember the mode" do
-        session.mode.should == :mechanize
+      it 'should remember the mode' do
+        expect(session.mode).to eq(:mechanize)
       end
     end
 
     describe '#click_link' do
-      it "should use data-method if option is true" do
+      it 'should use data-method if option is true' 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')
+        session.visit '/with_html'
+        session.click_link 'A link with data-method'
+        expect(session.html).to include('The requested object was deleted')
       end
 
-      it "should not use data-method if option is false" do
+      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')
+        session.visit '/with_html'
+        session.click_link 'A link with data-method'
+        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')
+        session.visit '/with_html'
+        session.click_link 'A link with capitalized data-method'
+        expect(session.html).to include('The requested object was deleted')
       end
 
       after do
@@ -69,44 +83,44 @@ describe Capybara::Session do
       end
     end
 
-    describe "#attach_file" do
-      context "with multipart form" 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.')
+    describe '#attach_file' do
+      context 'with multipart form' do
+        it 'should submit an empty form-data section if no file is submitted' do
+          session.visit('/form')
+          session.click_button('Upload Empty')
+          expect(session.html).to include('Successfully ignored empty file field.')
         end
       end
     end
 
-    it "should use the last remote url when following relative links" do
+    it 'should use the last remote url when following relative links' do
       session.visit("#{remote_test_url}/relative_link_to_host")
-      session.click_link "host"
-      session.body.should include("Current host is #{remote_test_url}/request_info/host, method get")
+      session.click_link 'host'
+      expect(session.body).to include("Current host is #{remote_test_url}/request_info/host, method get")
     end
 
-    it "should use the last remote url when submitting a form with a relative action" do
+    it 'should use the last remote url when submitting a form with a relative action' do
       session.visit("#{remote_test_url}/form_with_relative_action_to_host")
-      session.click_button "submit"
-      session.body.should include("Current host is #{remote_test_url}/request_info/host, method post")
+      session.click_button 'submit'
+      expect(session.body).to include("Current host is #{remote_test_url}/request_info/host, method post")
     end
 
-    it "should use the last url when submitting a form with no action" do
+    it 'should use the last url when submitting a form with no action' do
       session.visit("#{remote_test_url}/request_info/form_with_no_action")
-      session.click_button "submit"
-      session.body.should include("Current host is #{remote_test_url}/request_info/form_with_no_action, method post")
+      session.click_button 'submit'
+      expect(session.body).to include("Current host is #{remote_test_url}/request_info/form_with_no_action, method post")
     end
 
-    it "should send correct user agent" do
+    it 'should send correct user agent' do
       session.visit("#{remote_test_url}/request_info/user_agent")
-      session.body.should include("Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_0) AppleWebKit/535.2 (KHTML, like Gecko) Chrome/15.0.853.0 Safari/535.2")
+      expect(session.body).to include('Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_0) AppleWebKit/535.2 (KHTML, like Gecko) Chrome/15.0.853.0 Safari/535.2')
     end
 
     context 'form referer when switching from local to remote' do
       it 'sends the referer' do
         session.visit "/form_posts_to/#{remote_test_url}/get_referer"
         session.click_button 'submit'
-        session.body.should include 'Got referer'
+        expect(session.body).to include 'Got referer'
       end
     end
   end