webdrivers 4.1.2 → 5.0.0

data/lib/webdrivers/iedriver.rb

@@ -34,7 +34,7 @@ module Webdrivers
       #
       # @return [String]
       def base_url
-        'https://selenium-release.storage.googleapis.com/'
+        'https://api.github.com/repos/seleniumhq/selenium/releases'
       end
 
       private
@@ -43,32 +43,26 @@ module Webdrivers
         'IEDriverServer.exe'
       end
 
+      def direct_url(version)
+        downloads[version]
+      end
+
       def downloads
-        doc = Nokogiri::XML.parse(Network.get(base_url))
-        items = doc.css('Key').collect(&:text)
-        items.select! { |item| item.include?('IEDriverServer_Win32') }
-        ds = items.each_with_object({}) do |item, hash|
-          key = normalize_version item[/([^_]+)\.zip/, 1]
-          hash[key] = "#{base_url}#{item}"
+        ds = download_manifest.each_with_object({}) do |item, hash|
+          version = normalize_version item['name'][/\.?([^_]+)\.zip/, 1]
+          hash[version] = item['browser_download_url']
         end
         Webdrivers.logger.debug "Versions now located on downloads site: #{ds.keys}"
         ds
       end
-    end
-  end
-end
 
-if ::Selenium::WebDriver::Service.respond_to? :driver_path=
-  ::Selenium::WebDriver::IE::Service.driver_path = proc { ::Webdrivers::IEdriver.update }
-else
-  # v3.141.0 and lower
-  module Selenium
-    module WebDriver
-      module IE
-        def self.driver_path
-          @driver_path ||= Webdrivers::IEdriver.update
-        end
+      def download_manifest
+        json = Network.get(base_url)
+        all_assets = JSON.parse(json).map { |release| release['assets'] }.flatten
+        all_assets.select { |asset| asset['name'].include?('IEDriverServer_Win32') }
       end
     end
   end
 end
+
+::Selenium::WebDriver::IE::Service.driver_path = proc { ::Webdrivers::IEdriver.update }

data/lib/webdrivers/logger.rb

@@ -1,11 +1,5 @@
 # frozen_string_literal: true
 
-require 'forwardable'
-require 'logger'
-
-# Code adapted from Selenium Implementation
-# https://github.com/SeleniumHQ/selenium/blob/master/rb/lib/selenium/webdriver/common/logger.rb
-
 module Webdrivers
   #
   # @example Enable full logging
@@ -18,94 +12,9 @@ module Webdrivers
   #   Webdrivers.logger.info('This is info message')
   #   Webdrivers.logger.warn('This is warning message')
   #
-  class Logger
-    extend Forwardable
-    include ::Logger::Severity
-
-    def_delegators :@logger, :debug, :debug?,
-                   :info, :info?,
-                   :warn, :warn?,
-                   :error, :error?,
-                   :fatal, :fatal?,
-                   :level
-
+  class Logger < Selenium::WebDriver::Logger
     def initialize
-      @logger = create_logger($stdout)
-    end
-
-    def output=(io)
-      # `Logger#reopen` was added in Ruby 2.3
-      if @logger.respond_to?(:reopen)
-        @logger.reopen(io)
-      else
-        @logger = create_logger(io)
-      end
-    end
-
-    #
-    # For Ruby < 2.3 compatibility
-    # Based on https://github.com/ruby/ruby/blob/ruby_2_3/lib/logger.rb#L250
-    #
-
-    def level=(severity)
-      if severity.is_a?(Integer)
-        @logger.level = severity
-      else
-        case severity.to_s.downcase
-        when 'debug'
-          @logger.level = DEBUG
-        when 'info'
-          @logger.level = INFO
-        when 'warn'
-          @logger.level = WARN
-        when 'error'
-          @logger.level = ERROR
-        when 'fatal'
-          @logger.level = FATAL
-        when 'unknown'
-          @logger.level = UNKNOWN
-        else
-          raise ArgumentError, "invalid log level: #{severity}"
-        end
-      end
-    end
-
-    #
-    # Returns IO object used by logger internally.
-    #
-    # Normally, we would have never needed it, but we want to
-    # use it as IO object for all child processes to ensure their
-    # output is redirected there.
-    #
-    # It is only used in debug level, in other cases output is suppressed.
-    #
-    # @api private
-    #
-    def io
-      @logger.instance_variable_get(:@logdev).instance_variable_get(:@dev)
-    end
-
-    #
-    # Marks code as deprecated with replacement.
-    #
-    # @param [String] old
-    # @param [String] new
-    #
-    def deprecate(old, new)
-      warn "[DEPRECATION] #{old} is deprecated. Use #{new} instead."
-    end
-
-    private
-
-    def create_logger(output)
-      logger = ::Logger.new(output)
-      logger.progname = 'Webdrivers'
-      logger.level = ($DEBUG ? DEBUG : WARN)
-      logger.formatter = proc do |severity, time, progname, msg|
-        "#{time.strftime('%F %T')} #{severity} #{progname} #{msg}\n"
-      end
-
-      logger
+      super('Webdrivers')
     end
   end
 end

data/lib/webdrivers/network.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'net/http'
+
 module Webdrivers
   #
   # @api private

data/lib/webdrivers/system.rb

@@ -4,6 +4,12 @@ require 'rubygems/package'
 require 'zip'
 require 'English'
 
+# validate zip entry sizes to avoid zip bombs
+# see https://github.com/rubyzip/rubyzip#size-validation
+# and https://github.com/rubyzip/rubyzip/pull/403 for further details
+# this will be the default in rubyzip 2.0+
+Zip.validate_entry_sizes = true
+
 module Webdrivers
   #
   # @api private
@@ -14,11 +20,13 @@ module Webdrivers
         max_attempts = 3
         attempts_made = 0
         delay = 0.5
-        Webdrivers.logger.debug "Deleting #{file}"
 
         begin
           attempts_made += 1
-          File.delete file if File.exist? file
+          if File.exist? file
+            Webdrivers.logger.debug "Deleting #{file}"
+            File.delete file
+          end
         rescue Errno::EACCES # Solves an intermittent file locking issue on Windows
           sleep(delay)
           retry if File.exist?(file) && attempts_made <= max_attempts
@@ -140,6 +148,35 @@ module Webdrivers
         end
       end
 
+      def apple_m1_architecture?
+        if platform == 'mac' && RUBY_PLATFORM.include?('arm64-darwin')
+          Webdrivers.logger.debug 'Apple architecture: M1 (arm64-darwin)'
+          return true
+        end
+
+        Webdrivers.logger.debug 'Apple architecture: Intel (mac64)'
+        false
+      end
+
+      # @return [TrueClass, FalseClass]
+      def wsl_v1?
+        platform == 'linux' && File.open('/proc/version').read.include?('Microsoft')
+      end
+
+      # @param [String] path
+      # @return [String]
+      def to_win32_path(path)
+        return path if /[a-z]:\\/iu.match?(path)
+
+        call("wslpath -w '#{path}'").chomp
+      end
+
+      # @param [String] path
+      # @return [String]
+      def to_wsl_path(path)
+        call("wslpath -u '#{path}'").chomp
+      end
+
       def bitsize
         Selenium::WebDriver::Platform.bitsize
       end

data/lib/webdrivers/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Webdrivers
-  VERSION = '4.1.2'
+  VERSION = '5.0.0'
 end

data/spec/webdrivers/chrome_finder_spec.rb

@@ -47,4 +47,57 @@ describe Webdrivers::ChromeFinder do
       expect { chrome_finder.version }.to raise_error(Webdrivers::BrowserNotFound)
     end
   end
+
+  context 'when running in WSL' do
+    before do
+      skip "The current platform cannot be WSL, as it's not Linux" unless Selenium::WebDriver::Platform.linux?
+
+      allow(Webdrivers::System).to receive(:wsl_v1?).and_return(true)
+      allow(Webdrivers::System).to receive(:to_wsl_path).and_return('')
+      allow(Webdrivers::System).to receive(:to_win32_path).and_return('')
+    end
+
+    it 'checks Windows locations for Chrome' do
+      drive = 'c'
+      user = 'WinUser'
+      file = 'chrome.exe'
+      path = [
+        '/home/wsl-user/.local/bin',
+        '/usr/local/bin',
+        '/usr/local/games',
+        '/usr/bin',
+        "/#{drive}/Users/#{user}/AppData/Local/Microsoft/WindowsApps",
+        '/snap/bin'
+      ].join ':'
+
+      allow(chrome_finder).to receive(:user_defined_location).and_return(nil)
+      allow(ENV).to receive(:[]).with('WD_CHROME_PATH').and_return(nil)
+      allow(ENV).to receive(:[]).with('PATH').and_return(path)
+      allow(File).to receive(:exist?).and_return(false)
+
+      locations = [
+        "#{drive}:\\Users\\#{user}\\AppData\\Local\\Google\\Chrome\\Application\\#{file}",
+        "#{drive}:\\Program Files (x86)\\Chromium\\Application\\#{file}",
+        "#{drive}:\\Program Files\\Google\\Chrome\\Application\\#{file}"
+      ]
+
+      # CIs don't support WSL yet, so our mocks lead to the error path for simplicity
+      expect { chrome_finder.location }.to raise_error(Webdrivers::BrowserNotFound)
+
+      locations.each do |dir|
+        expect(Webdrivers::System).to have_received(:to_wsl_path).with(dir)
+      end
+    end
+
+    it 'uses win_version to get the Chrome version using win32 path' do
+      allow(chrome_finder).to receive(:win_version).and_return('')
+      allow(File).to receive(:exist?).and_return(true)
+
+      # CIs don't support WSL yet, so our mocks lead to the error path for simplicity
+      expect { chrome_finder.version }.to raise_error(Webdrivers::VersionError)
+
+      expect(Webdrivers::System).to have_received(:to_win32_path)
+      expect(chrome_finder).to have_received(:win_version)
+    end
+  end
 end

data/spec/webdrivers/chromedriver_spec.rb

@@ -106,15 +106,16 @@ describe Webdrivers::Chromedriver do
       end
     end
 
-    it 'makes a network call if cached driver does not match the browser' do
+    it 'makes network calls if cached driver does not match the browser' do
       Webdrivers::System.cache_version('chromedriver', '71.0.3578.137')
+      allow(chromedriver).to receive(:current_version).and_return(Gem::Version.new('71.0.3578.137'))
       allow(chromedriver).to receive(:browser_version).and_return(Gem::Version.new('73.0.3683.68'))
       allow(Webdrivers::Network).to receive(:get).and_return('73.0.3683.68')
       allow(Webdrivers::System).to receive(:download)
 
       chromedriver.update
 
-      expect(Webdrivers::Network).to have_received(:get).once
+      expect(Webdrivers::Network).to have_received(:get).twice
     end
 
     context 'when required version is 0' do
@@ -155,19 +156,19 @@ describe Webdrivers::Chromedriver do
 
   describe '#latest_version' do
     it 'returns 2.41 if the browser version is less than 70' do
-      allow(chromedriver).to receive(:browser_version).and_return('69.0.0')
+      allow(chromedriver).to receive(:browser_version).and_return Gem::Version.new('69.0.0')
 
       expect(chromedriver.latest_version).to eq(Gem::Version.new('2.41'))
     end
 
     it 'returns the correct point release for a production version greater than 70' do
-      allow(chromedriver).to receive(:browser_version).and_return '71.0.3578.9999'
+      allow(chromedriver).to receive(:browser_version).and_return Gem::Version.new('71.0.3578.9999')
 
       expect(chromedriver.latest_version).to eq Gem::Version.new('71.0.3578.137')
     end
 
     it 'raises VersionError for beta version' do
-      allow(chromedriver).to receive(:browser_version).and_return('100.0.0')
+      allow(chromedriver).to receive(:browser_version).and_return Gem::Version.new('100.0.0')
       msg = 'Unable to find latest point release version for 100.0.0. '\
 'You appear to be using a non-production version of Chrome. '\
 'Please set `Webdrivers::Chromedriver.required_version = <desired driver version>` '\
@@ -177,7 +178,7 @@ describe Webdrivers::Chromedriver do
     end
 
     it 'raises VersionError for unknown version' do
-      allow(chromedriver).to receive(:browser_version).and_return('72.0.9999.0000')
+      allow(chromedriver).to receive(:browser_version).and_return Gem::Version.new('72.0.9999.0000')
       msg = 'Unable to find latest point release version for 72.0.9999. '\
 'Please set `Webdrivers::Chromedriver.required_version = <desired driver version>` '\
 'to a known chromedriver version: https://chromedriver.storage.googleapis.com/index.html'
@@ -199,9 +200,12 @@ describe Webdrivers::Chromedriver do
       expect(File.exist?("#{Webdrivers::System.install_dir}/chromedriver.version")).to eq true
     end
 
-    it 'does not make network call if cache is valid' do
+    it 'does not make network calls if cache is valid and driver exists' do
       allow(Webdrivers).to receive(:cache_time).and_return(3600)
       Webdrivers::System.cache_version('chromedriver', '71.0.3578.137')
+      allow(chromedriver).to receive(:current_version).and_return Gem::Version.new('71.0.3578.137')
+      allow(chromedriver).to receive(:browser_version).and_return Gem::Version.new('71.0.3578.137')
+      allow(Webdrivers::System).to receive(:exists?).and_return(true)
       allow(Webdrivers::Network).to receive(:get)
 
       expect(chromedriver.latest_version).to eq Gem::Version.new('71.0.3578.137')
@@ -209,10 +213,11 @@ describe Webdrivers::Chromedriver do
       expect(Webdrivers::Network).not_to have_received(:get)
     end
 
-    it 'makes a network call if cache is expired' do
+    it 'makes network calls if cache is expired' do
       Webdrivers::System.cache_version('chromedriver', '71.0.3578.137')
+      allow(chromedriver).to receive(:browser_version).and_return Gem::Version.new('71.0.3578.137')
       allow(Webdrivers::Network).to receive(:get).and_return('73.0.3683.68')
-      allow(Webdrivers::System).to receive(:valid_cache?)
+      allow(Webdrivers::System).to receive(:valid_cache?).and_return(false)
 
       expect(chromedriver.latest_version).to eq Gem::Version.new('73.0.3683.68')
 

data/spec/webdrivers/edge_finder_spec.rb

@@ -5,13 +5,7 @@ require 'spec_helper'
 describe Webdrivers::EdgeFinder do
   let(:edge_finder) { described_class }
 
-  before(:all) do # rubocop:disable RSpec/BeforeAfterAll
-    # Skip these tests if version of selenium-webdriver being tested with doesn't
-    # have Chromium based Edge support
-    unless defined?(Selenium::WebDriver::EdgeChrome)
-      skip "The current selenium-webdriver doesn't include Chromium based Edge support"
-    end
-  end
+  before { skip 'Edge is not yet supported on Linux' if Webdrivers::System.platform == 'linux' }
 
   context 'when the user relies on the gem to figure out the location of Edge' do
     it 'determines the location correctly based on the current OS' do
@@ -20,8 +14,8 @@ describe Webdrivers::EdgeFinder do
   end
 
   context 'when the user provides a path to the Edge binary' do
-    it 'uses Selenium::WebDriver::EdgeChrome.path when it is defined' do
-      Selenium::WebDriver::EdgeChrome.path = edge_finder.location
+    it 'uses Selenium::WebDriver::Edge.path when it is defined' do
+      Selenium::WebDriver::Edge.path = edge_finder.location
       locations = %i[win_location mac_location linux_location]
       allow(edge_finder).to receive_messages(locations)
 
@@ -29,8 +23,8 @@ describe Webdrivers::EdgeFinder do
       locations.each { |loc| expect(edge_finder).not_to have_received(loc) }
     end
 
-    it "uses ENV['WD_EDGE_CHROME_PATH'] when it is defined" do
-      allow(ENV).to receive(:[]).with('WD_EDGE_CHROME_PATH').and_return(edge_finder.location)
+    it "uses ENV['WD_EDGE_PATH'] when it is defined" do
+      allow(ENV).to receive(:[]).with('WD_EDGE_PATH').and_return(edge_finder.location)
       locations = %i[win_location mac_location linux_location]
       allow(edge_finder).to receive_messages(locations)
 
@@ -38,11 +32,11 @@ describe Webdrivers::EdgeFinder do
       locations.each { |loc| expect(edge_finder).not_to have_received(loc) }
     end
 
-    it 'uses Selenium::WebDriver::EdgeChrome.path over WD_EDGE_CHROME_PATH' do
-      Selenium::WebDriver::EdgeChrome.path = edge_finder.location
-      allow(ENV).to receive(:[]).with('WD_EDGE_CHROME_PATH').and_return('my_wd_chrome_path')
+    it 'uses Selenium::WebDriver::Edge.path over WD_EDGE_PATH' do
+      Selenium::WebDriver::Edge.path = edge_finder.location
+      allow(ENV).to receive(:[]).with('WD_EDGE_PATH').and_return('my_wd_chrome_path')
       expect(edge_finder.version).not_to be_nil
-      expect(ENV).not_to have_received(:[]).with('WD_EDGE_CHROME_PATH')
+      expect(ENV).not_to have_received(:[]).with('WD_EDGE_PATH')
     end
   end
 

data/spec/webdrivers/edgedriver_spec.rb

@@ -5,16 +5,11 @@ require 'spec_helper'
 describe Webdrivers::Edgedriver do
   let(:edgedriver) { described_class }
 
-  before(:all) do # rubocop:disable RSpec/BeforeAfterAll
-    # Skip these tests if version of selenium-webdriver being tested with doesn't
-    # have Chromium based Edge support
-    unless defined?(Selenium::WebDriver::EdgeChrome)
-      skip "The current selenium-webdriver doesn't include Chromium based Edge support"
-    end
+  before do
+    skip 'Edge is not yet supported on Linux' if Webdrivers::System.platform == 'linux'
+    edgedriver.remove
   end
 
-  before { edgedriver.remove }
-
   describe '#update' do
     context 'when evaluating #correct_binary?' do
       it 'does not download when latest version and current version match' do
@@ -114,15 +109,16 @@ describe Webdrivers::Edgedriver do
       end
     end
 
-    it 'makes a network call if cached driver does not match the browser' do
+    it 'makes network calls if cached driver does not match the browser' do
       Webdrivers::System.cache_version('msedgedriver', '71.0.3578.137')
-      allow(edgedriver).to receive(:browser_version).and_return(Gem::Version.new('73.0.3683.68'))
+      allow(edgedriver).to receive(:current_version).and_return Gem::Version.new('71.0.3578.137')
+      allow(edgedriver).to receive(:browser_version).and_return Gem::Version.new('73.0.3683.68')
       allow(Webdrivers::Network).to receive(:get).and_return('73.0.3683.68'.encode('UTF-16'))
       allow(Webdrivers::System).to receive(:download)
 
       edgedriver.update
 
-      expect(Webdrivers::Network).to have_received(:get).once
+      expect(Webdrivers::Network).to have_received(:get).twice
     end
 
     context 'when required version is 0' do
@@ -163,13 +159,13 @@ describe Webdrivers::Edgedriver do
 
   describe '#latest_version' do
     it 'returns the correct point release for a production version' do
-      allow(edgedriver).to receive(:browser_version).and_return '77.0.207.0'
+      allow(edgedriver).to receive(:browser_version).and_return Gem::Version.new('77.0.207.0')
 
       expect(edgedriver.latest_version).to be_between(Gem::Version.new('77.0.207.0'), Gem::Version.new('78'))
     end
 
     it 'raises VersionError for beta version' do
-      allow(edgedriver).to receive(:browser_version).and_return('100.0.0')
+      allow(edgedriver).to receive(:browser_version).and_return Gem::Version.new('100.0.0')
       msg = 'Unable to find latest point release version for 100.0.0. '\
 'You appear to be using a non-production version of Edge. '\
 'Please set `Webdrivers::Edgedriver.required_version = <desired driver version>` '\
@@ -179,8 +175,7 @@ describe Webdrivers::Edgedriver do
     end
 
     it 'raises VersionError for unknown version' do
-      skip "MS doesn't yet support point release latest versioning."
-      allow(edgedriver).to receive(:browser_version).and_return('77.0.9999.0000')
+      allow(edgedriver).to receive(:browser_version).and_return Gem::Version.new('77.0.9999')
       msg = 'Unable to find latest point release version for 77.0.9999. '\
 'Please set `Webdrivers::Edgedriver.required_version = <desired driver version>` '\
 'to a known edgedriver version: Can not reach https://msedgedriver.azureedge.net/'
@@ -196,28 +191,31 @@ describe Webdrivers::Edgedriver do
     end
 
     it 'creates cached file' do
-      allow(edgedriver).to receive(:browser_version).and_return('77.0.207.0')
+      allow(edgedriver).to receive(:browser_version).and_return Gem::Version.new('77.0.207.0')
       allow(Webdrivers::Network).to receive(:get).and_return('77.0.207.0'.encode('UTF-16'))
 
       edgedriver.latest_version
       expect(File.exist?("#{Webdrivers::System.install_dir}/msedgedriver.version")).to eq true
     end
 
-    it 'does not make network call if cache is valid' do
+    it 'does not make network calls if cache is valid and driver exists' do
       allow(Webdrivers).to receive(:cache_time).and_return(3600)
-      Webdrivers::System.cache_version('msedgedriver', '77.0.207.0')
+      Webdrivers::System.cache_version('msedgedriver', '82.0.445.0')
+      allow(edgedriver).to receive(:current_version).and_return Gem::Version.new('82.0.445.0')
+      allow(edgedriver).to receive(:browser_version).and_return Gem::Version.new('82.0.445.0')
+      allow(Webdrivers::System).to receive(:exists?).and_return(true)
       allow(Webdrivers::Network).to receive(:get)
 
-      expect(edgedriver.latest_version).to eq Gem::Version.new('77.0.207.0')
+      expect(edgedriver.latest_version).to eq Gem::Version.new('82.0.445.0')
 
       expect(Webdrivers::Network).not_to have_received(:get)
     end
 
-    it 'makes a network call if cache is expired' do
+    it 'makes network calls if cache is expired' do
       Webdrivers::System.cache_version('msedgedriver', '71.0.3578.137')
       allow(Webdrivers::Network).to receive(:get).and_return('77.0.207.0'.encode('UTF-16'))
-      allow(Webdrivers::System).to receive(:valid_cache?)
-      allow(edgedriver).to receive(:browser_version).and_return('77.0.207.0')
+      allow(Webdrivers::System).to receive(:valid_cache?).and_return(false)
+      allow(edgedriver).to receive(:browser_version).and_return Gem::Version.new('77.0.207.0')
 
       expect(edgedriver.latest_version).to eq Gem::Version.new('77.0.207.0')
 

data/spec/webdrivers/geckodriver_spec.rb

@@ -135,9 +135,10 @@ You can obtain a copy of the license at https://mozilla.org/MPL/2.0/"
       expect(File.exist?("#{Webdrivers::System.install_dir}/geckodriver.version")).to eq true
     end
 
-    it 'does not make network call if cache is valid' do
+    it 'does not make network calls if cache is valid and driver exists' do
       allow(Webdrivers).to receive(:cache_time).and_return(3600)
       Webdrivers::System.cache_version('geckodriver', '0.23.0')
+      allow(Webdrivers::System).to receive(:exists?).and_return(true)
       allow(Webdrivers::Network).to receive(:get)
 
       expect(geckodriver.latest_version).to eq Gem::Version.new('0.23.0')
@@ -191,14 +192,12 @@ You can obtain a copy of the license at https://mozilla.org/MPL/2.0/"
     end
 
     it 'uses provided value' do
-      begin
-        install_dir = File.expand_path(File.join(ENV['HOME'], '.webdrivers2'))
-        Webdrivers.install_dir = install_dir
+      install_dir = File.expand_path(File.join(ENV['HOME'], '.webdrivers2'))
+      Webdrivers.install_dir = install_dir
 
-        expect(Webdrivers::System.install_dir).to eq install_dir
-      ensure
-        Webdrivers.install_dir = nil
-      end
+      expect(Webdrivers::System.install_dir).to eq install_dir
+    ensure
+      Webdrivers.install_dir = nil
     end
   end
 

data/spec/webdrivers/i_edriver_spec.rb

@@ -6,6 +6,10 @@ describe Webdrivers::IEdriver do
   let(:iedriver) { described_class }
 
   before do
+    if ENV['CI'] && !Selenium::WebDriver::Platform.windows?
+      skip('Only run IE tests on Windows on CI because rate limiting')
+    end
+
     iedriver.remove
     iedriver.required_version = nil
   end
@@ -69,7 +73,7 @@ describe Webdrivers::IEdriver do
       it 'raises ConnectionError if offline' do
         allow(Net::HTTP).to receive(:get_response).and_raise(SocketError)
 
-        msg = %r{Can not reach https://selenium-release.storage.googleapis.com/}
+        msg = %r{Can not reach https://api.github.com/repos/seleniumhq/selenium/releases}
         expect { iedriver.update }.to raise_error(Webdrivers::ConnectionError, msg)
       end
     end
@@ -109,15 +113,17 @@ describe Webdrivers::IEdriver do
     end
 
     it 'creates cached file' do
-      allow(Webdrivers::Network).to receive(:get).and_return('3.4.0')
+      json = '[{"assets": [{"name":"IEDriverServer_Win32_3.150.0.zip"}]}]'
+      allow(Webdrivers::Network).to receive(:get).and_return(json)
 
       iedriver.latest_version
       expect(File.exist?("#{Webdrivers::System.install_dir}/IEDriverServer.version")).to eq true
     end
 
-    it 'does not make network call if cache is valid' do
+    it 'does not make network calls if cache is valid and driver exists' do
       allow(Webdrivers).to receive(:cache_time).and_return(3600)
       Webdrivers::System.cache_version('IEDriverServer', '3.4.0')
+      allow(Webdrivers::System).to receive(:exists?).and_return(true)
       allow(Webdrivers::Network).to receive(:get)
 
       expect(iedriver.latest_version).to eq Gem::Version.new('3.4.0')
@@ -173,14 +179,12 @@ describe Webdrivers::IEdriver do
     end
 
     it 'uses provided value' do
-      begin
-        install_dir = File.expand_path(File.join(ENV['HOME'], '.webdrivers2'))
-        Webdrivers.install_dir = install_dir
+      install_dir = File.expand_path(File.join(ENV['HOME'], '.webdrivers2'))
+      Webdrivers.install_dir = install_dir
 
-        expect(Webdrivers::System.install_dir).to eq install_dir
-      ensure
-        Webdrivers.install_dir = nil
-      end
+      expect(Webdrivers::System.install_dir).to eq install_dir
+    ensure
+      Webdrivers.install_dir = nil
     end
   end