webdrivers 3.8.1 → 3.9.0

data/lib/webdrivers/mswebdriver.rb

@@ -1,58 +1,54 @@
 # frozen_string_literal: true
 
+require 'webdrivers/common'
+
 module Webdrivers
-  class MSWebdriver < Common
+  class MSWebdriver
     class << self
-      def windows_version
-        Webdrivers.logger.debug 'Checking current version'
-
-        # current_version() from other webdrivers returns the version from the webdriver EXE.
-        # Unfortunately, MicrosoftWebDriver.exe does not have an option to get the version.
-        # To work around it we query the currently installed version of Microsoft Edge instead
-        # and compare it to the list of available downloads.
-        version = `powershell (Get-AppxPackage -Name Microsoft.MicrosoftEdge).Version`
-        raise 'Failed to check Microsoft Edge version.' if version.empty? # Package name changed?
-
-        Webdrivers.logger.debug "Current version of Microsoft Edge is #{version.chomp!}"
-
-        build = version.split('.')[1] # "41.16299.248.0" => "16299"
-        Webdrivers.logger.debug "Expecting MicrosoftWebDriver.exe version #{build}"
-        build.to_i
-      end
-
-      # Webdriver binaries for Microsoft Edge are not backwards compatible.
-      # For this reason, instead of downloading the latest binary we download the correct one for the
-      # currently installed browser version.
-      alias version windows_version
-
-      def version=(*)
-        raise 'Version can not be set for MSWebdriver because it is dependent on the version of Edge'
-      end
-
-      private
-
-      def file_name
-        'MicrosoftWebDriver.exe'
-      end
-
-      def downloads
-        array = Nokogiri::HTML(get(base_url)).xpath("//li[@class='driver-download']/a")
-        array.each_with_object({}) do |link, hash|
-          next if link.text == 'Insiders'
+      attr_accessor :ignore
+    end
+  end
+end
 
-          key = normalize_version link.text.scan(/\d+/).first.to_i
-          hash[key] = link['href']
+module Selenium
+  module WebDriver
+    module Edge
+      if Selenium::WebDriver::VERSION > '3.141.0'
+        class Service < WebDriver::Service
+          class << self
+            alias se_driver_path driver_path
+
+            def driver_path
+              unless Webdrivers::MSWebdriver.ignore
+                Webdrivers.logger.warn 'Microsoft WebDriver for the Edge browser is no longer supported by Webdrivers'\
+          ' gem. Due to changes in Edge implementation, the correct version can no longer be accurately provided. '\
+          'Download driver, and specify the location with `Selenium::WebDriver::Edge.driver_path = "/driver/path"`, '\
+          'or place it in PATH Environment Variable. '\
+          'Download directions here: https://developer.microsoft.com/en-us/microsoft-edge/tools/webdriver/#downloads '\
+          'To remove this warning in Webdrivers 3.x, set `Webdrivers.MSWebdriver.ignore`'
+              end
+
+              se_driver_path
+            end
+          end
+        end
+      else
+        class << self
+          alias se_driver_path driver_path
+
+          def driver_path
+            unless Webdrivers::MSWebdriver.ignore
+              Webdrivers.logger.warn 'Microsoft WebDriver for the Edge browser is no longer supported by Webdrivers'\
+          ' gem. Due to changes in Edge implementation, the correct version can no longer be accurately provided. '\
+          'Download driver, and specify the location with `Selenium::WebDriver::Edge.driver_path = "/driver/path"`, '\
+          'or place it in PATH Environment Variable. '\
+          'Download directions here: https://developer.microsoft.com/en-us/microsoft-edge/tools/webdriver/#downloads '\
+          'To remove this warning in Webdrivers 3.x, set `Webdrivers.MSWebdriver.ignore`'
+            end
+
+            se_driver_path
+          end
         end
-      end
-
-      def base_url
-        'https://developer.microsoft.com/en-us/microsoft-edge/tools/webdriver/'
-      end
-
-      # Assume we have the latest if file exists since MicrosoftWebdriver.exe does not have an
-      # argument to check the current version.
-      def correct_binary?
-        File.exist?(binary)
       end
     end
   end

data/lib/webdrivers/network.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Webdrivers
+  class Network
+    class << self
+      def get(url, limit = 10)
+        Webdrivers.logger.debug "Making network call to #{url}"
+
+        response = get_response(url, limit)
+        case response
+        when Net::HTTPSuccess
+          response.body
+        else
+          raise StandardError, "#{response.class::EXCEPTION_TYPE}: #{response.code} \"#{response.message}\" with #{url}"
+        end
+      end
+
+      def get_url(url, limit = 10)
+        Webdrivers.logger.debug "Making network call to #{url}"
+
+        get_response(url, limit).uri.to_s
+      end
+
+      def get_response(url, limit = 10)
+        raise StandardError, 'Too many HTTP redirects' if limit.zero?
+
+        begin
+          response = http.get_response(URI(url))
+        rescue SocketError
+          raise ConnectionError, "Can not reach #{url}"
+        end
+
+        Webdrivers.logger.debug "Get response: #{response.inspect}"
+
+        if response.is_a?(Net::HTTPRedirection)
+          location = response['location']
+          Webdrivers.logger.debug "Redirected to #{location}"
+          get_response(location, limit - 1)
+        else
+          response
+        end
+      end
+
+      def http
+        if using_proxy
+          Net::HTTP.Proxy(Webdrivers.proxy_addr, Webdrivers.proxy_port,
+                          Webdrivers.proxy_user, Webdrivers.proxy_pass)
+        else
+          Net::HTTP
+        end
+      end
+
+      def using_proxy
+        Webdrivers.proxy_addr && Webdrivers.proxy_port
+      end
+    end
+  end
+end

data/lib/webdrivers/system.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require 'rubygems/package'
+require 'zip'
+
+module Webdrivers
+  class System
+    class << self
+      def delete(file)
+        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
+        rescue Errno::EACCES # Solves an intermittent file locking issue on Windows
+          sleep(delay)
+          retry if File.exist?(file) && attempts_made <= max_attempts
+          raise
+        end
+      end
+
+      def install_dir
+        Webdrivers.install_dir || File.expand_path(File.join(ENV['HOME'], '.webdrivers'))
+      end
+
+      def cache_version(file_name, version)
+        FileUtils.mkdir_p(install_dir) unless File.exist?(install_dir)
+
+        File.open("#{install_dir}/#{file_name.gsub('.exe', '')}.version", 'w+') do |file|
+          file.print(version)
+        end
+      end
+
+      def cached_version(file_name)
+        File.open("#{install_dir}/#{file_name.gsub('.exe', '')}.version", 'r', &:read)
+      end
+
+      def valid_cache?(file_name)
+        file = "#{install_dir}/#{file_name.gsub('.exe', '')}.version"
+        return false unless File.exist?(file)
+
+        Time.now - File.mtime(file) < Webdrivers.cache_time
+      end
+
+      def download(url, target)
+        FileUtils.mkdir_p(install_dir) unless File.exist?(install_dir)
+
+        download_file(url, target)
+
+        FileUtils.chmod 'ugo+rx', target
+        Webdrivers.logger.debug "Completed download and processing of #{target}"
+        target
+      end
+
+      def download_file(url, target)
+        file_name = File.basename(url)
+        Dir.chdir(install_dir) do
+          tempfile = Tempfile.open(['', file_name], binmode: true) do |file|
+            file.print Network.get(url)
+            file
+          end
+
+          raise "Could not download #{url}" unless File.exist?(tempfile.to_path)
+
+          Webdrivers.logger.debug "Successfully downloaded #{tempfile.to_path}"
+
+          decompress_file(tempfile, file_name, target)
+          tempfile.close!
+        end
+      end
+
+      def exists?(file)
+        result = File.exist? file
+        Webdrivers.logger.debug "#{file} is#{' not' unless result} already downloaded"
+        result
+      end
+
+      def decompress_file(tempfile, file_name, target)
+        tempfile = tempfile.to_path
+        case tempfile
+        when /tar\.gz$/
+          untargz_file(tempfile, File.basename(target))
+        when /tar\.bz2$/
+          untarbz2_file(tempfile)
+        when /\.zip$/
+          unzip_file(tempfile)
+        else
+          Webdrivers.logger.debug 'No Decompression needed'
+          FileUtils.cp(tempfile, File.join(Dir.pwd, file_name))
+        end
+        raise "Could not decompress #{url} to get #{target}" unless File.exist?(target)
+      end
+
+      def untarbz2_file(filename)
+        Webdrivers.logger.debug "Decompressing #{filename}"
+
+        call("tar xjf #{filename}").gsub('.tar.bz2', '')
+      end
+
+      def untargz_file(source, target)
+        Webdrivers.logger.debug "Decompressing #{source}"
+
+        tar_extract = Gem::Package::TarReader.new(Zlib::GzipReader.open(source))
+
+        File.open(target, 'w+b') do |ucf|
+          tar_extract.each { |entry| ucf << entry.read }
+          File.basename ucf
+        end
+      end
+
+      def unzip_file(filename)
+        Webdrivers.logger.debug "Decompressing #{filename}"
+
+        Zip::File.open(filename) do |zip_file|
+          zip_file.each do |f|
+            @top_path ||= f.name
+            f_path = File.join(Dir.pwd, f.name)
+            delete(f_path)
+            FileUtils.mkdir_p(File.dirname(f_path)) unless File.exist?(File.dirname(f_path))
+            zip_file.extract(f, f_path)
+          end
+        end
+        @top_path
+      end
+
+      def platform
+        if Selenium::WebDriver::Platform.linux?
+          'linux'
+        elsif Selenium::WebDriver::Platform.mac?
+          'mac'
+        elsif Selenium::WebDriver::Platform.windows?
+          'win'
+        else
+          raise NotImplementedError, 'Your OS is not supported by webdrivers gem.'
+        end
+      end
+
+      def bitsize
+        Selenium::WebDriver::Platform.bitsize
+      end
+
+      def call(cmd)
+        Webdrivers.logger.debug "making System call: #{cmd}"
+        `#{cmd}`
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -9,4 +9,10 @@ require 'webdrivers'
 RSpec.configure do |config|
   config.filter_run_including focus: true unless ENV['CI']
   config.run_all_when_everything_filtered = true
+  config.expect_with :rspec do |expectations|
+    expectations.syntax = :expect
+  end
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
 end

data/spec/webdrivers/chromedriver_spec.rb

@@ -5,125 +5,239 @@ require 'spec_helper'
 describe Webdrivers::Chromedriver do
   let(:chromedriver) { described_class }
 
-  it 'updates' do
-    chromedriver.update
+  before do
+    chromedriver.remove
+    chromedriver.required_version = nil
   end
 
-  it 'parses chromedriver versions before 2.10' do
-    expect(chromedriver.send(:normalize_version, '2.9').version).to eq '2.9'
-  end
+  describe '#update' do
+    context 'when evaluating #correct_binary?' do
+      it 'does not download when latest version and current version match' do
+        allow(chromedriver).to receive(:latest_version).and_return(Gem::Version.new('72.0.0'))
+        allow(chromedriver).to receive(:current_version).and_return(Gem::Version.new('72.0.0'))
 
-  it 'finds latest version' do
-    old_version = Gem::Version.new('2.30')
-    future_version = Gem::Version.new('80.00')
-    latest_version = chromedriver.latest_version
+        chromedriver.update
 
-    expect(latest_version).to be > old_version
-    expect(latest_version).to be < future_version
-  end
+        expect(chromedriver.send(:exists?)).to be false
+      end
 
-  it 'downloads latest release for current version of Chrome by default' do
-    chromedriver.remove
-    chromedriver.download
-    cur_ver    = chromedriver.current_version.version
-    latest_ver = chromedriver.latest_version.version
-    expect(cur_ver).to eq latest_ver
-  end
+      it 'does not download when offline, binary exists and is less than v70' do
+        allow(Net::HTTP).to receive(:get_response).and_raise(SocketError)
+        allow(chromedriver).to receive(:exists?).and_return(true)
+        allow(chromedriver).to receive(:current_version).and_return(Gem::Version.new(69))
 
-  it 'downloads specified version by Float' do
-    chromedriver.remove
-    chromedriver.version = 2.29
-    chromedriver.download
-    expect(chromedriver.current_version.version).to include '2.29'
-  end
+        chromedriver.update
 
-  it 'downloads specified version by String' do
-    chromedriver.remove
-    chromedriver.version = '73.0.3683.68'
-    chromedriver.download
-    expect(chromedriver.current_version.version).to eq '73.0.3683.68'
-  end
+        expect(File.exist?(chromedriver.driver_path)).to be false
+      end
 
-  it 'removes chromedriver' do
-    chromedriver.remove
-    expect(chromedriver.current_version).to be_nil
-  end
+      it 'does not download when offline, binary exists and matches major browser version' do
+        allow(Net::HTTP).to receive(:get_response).and_raise(SocketError)
+        allow(chromedriver).to receive(:exists?).and_return(true)
+        allow(chromedriver).to receive(:chrome_version).and_return(Gem::Version.new('73.0.3683.68'))
+        allow(chromedriver).to receive(:current_version).and_return(Gem::Version.new('73.0.3683.20'))
 
-  context 'when using a Chromium version < 70.0.3538' do
-    it 'downloads chromedriver 2.46' do
-      chromedriver.remove
-      chromedriver.version = nil
-      chromedriver.instance_variable_set('@latest_version', nil)
+        chromedriver.update
+
+        expect(File.exist?(chromedriver.driver_path)).to be false
+      end
+
+      it 'raises ConnectionError when offline, and binary does not match major browser version' do
+        allow(Net::HTTP).to receive(:get_response).and_raise(SocketError)
+        allow(chromedriver).to receive(:exists?).and_return(true)
+        allow(chromedriver).to receive(:chrome_version).and_return(Gem::Version.new('73.0.3683.68'))
+        allow(chromedriver).to receive(:current_version).and_return(Gem::Version.new('72.0.0.0'))
+
+        msg = %r{Can not reach https://chromedriver.storage.googleapis.com}
+        expect { chromedriver.update }.to raise_error(Webdrivers::ConnectionError, msg)
+      end
+
+      it 'raises ConnectionError when offline, and no binary exists' do
+        allow(Net::HTTP).to receive(:get_response).and_raise(SocketError)
+        allow(chromedriver).to receive(:exists?).and_return(false)
+
+        msg = %r{Can not reach https://chromedriver.storage.googleapis.com}
+        expect { chromedriver.update }.to raise_error(Webdrivers::ConnectionError, msg)
+      end
+    end
+
+    context 'when correct binary is found' do
+      before { allow(chromedriver).to receive(:correct_binary?).and_return(true) }
+
+      it 'does not download' do
+        chromedriver.update
+
+        expect(chromedriver.current_version).to be_nil
+      end
+
+      it 'does not raise exception if offline' do
+        allow(Net::HTTP).to receive(:get_response).and_raise(SocketError)
+
+        chromedriver.update
+
+        expect(chromedriver.current_version).to be_nil
+      end
+    end
+
+    context 'when correct binary is not found' do
+      before { allow(chromedriver).to receive(:correct_binary?).and_return(false) }
+
+      it 'downloads binary' do
+        chromedriver.update
+
+        expect(chromedriver.current_version).not_to be_nil
+      end
+
+      it 'raises ConnectionError if offline' do
+        allow(Net::HTTP).to receive(:get_response).and_raise(SocketError)
+
+        msg = %r{Can not reach https://chromedriver.storage.googleapis.com/}
+        expect { chromedriver.update }.to raise_error(Webdrivers::ConnectionError, msg)
+      end
+    end
+
+    it 'makes a network call if cached driver does not match the browser' do
+      Webdrivers::System.cache_version('chromedriver', '71.0.3578.137')
+      allow(chromedriver).to receive(:chrome_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)
 
-      allow(chromedriver).to receive(:chrome_version).and_return('70.0.0')
       chromedriver.update
 
-      expect(chromedriver.current_version.version[/\d+.\d+/]).to eq('2.46')
+      expect(Webdrivers::Network).to have_received(:get).twice
     end
   end
 
-  context 'when using a Chromium version that does not have an associated driver' do
-    before do
-      chromedriver.remove
-      chromedriver.version = nil
-      chromedriver.instance_variable_set('@latest_version', nil)
+  describe '#current_version' do
+    it 'returns nil if binary does not exist on the system' do
+      allow(chromedriver).to receive(:driver_path).and_return('')
+
+      expect(chromedriver.current_version).to be_nil
+    end
+
+    it 'returns a Gem::Version instance if binary is on the system' do
+      allow(chromedriver).to receive(:exists?).and_return(true)
+      allow(Webdrivers::System).to receive(:call)
+        .with("#{chromedriver.driver_path} --version")
+        .and_return '71.0.3578.137'
+
+      expect(chromedriver.current_version).to eq Gem::Version.new('71.0.3578.137')
+    end
+  end
+
+  describe '#latest_version' do
+    it 'returns 2.41 if the browser version is less than 70' do
+      allow(chromedriver).to receive(:chrome_version).and_return('69.0.0')
+
+      expect(chromedriver.latest_version).to eq(Gem::Version.new('2.41'))
     end
 
-    it 'raises an exception for beta version' do
+    it 'returns the correct point release for a production version greater than 70' do
+      allow(chromedriver).to receive(:chrome_version).and_return '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(:chrome_version).and_return('100.0.0')
       msg = 'you appear to be using a non-production version of Chrome; please set '\
-'`Webdrivers::Chromedriver.version = <desired driver version>` to an known chromedriver version: '\
+'`Webdrivers::Chromedriver.required_version = <desired driver version>` to an known chromedriver version: '\
 'https://chromedriver.storage.googleapis.com/index.html'
-      expect { chromedriver.update }.to raise_exception(StandardError, msg)
+
+      expect { chromedriver.latest_version }.to raise_exception(Webdrivers::VersionError, msg)
     end
 
-    it 'raises an exception for unknown version' do
-      allow(chromedriver).to receive(:chrome_version).and_return('72.0.0')
-      msg = 'please set `Webdrivers::Chromedriver.version = <desired driver version>` to an known chromedriver '\
-'version: https://chromedriver.storage.googleapis.com/index.html'
-      expect { chromedriver.update }.to raise_exception(StandardError, msg)
+    it 'raises VersionError for unknown version' do
+      allow(chromedriver).to receive(:chrome_version).and_return('72.0.9999.0000')
+      msg = 'please set `Webdrivers::Chromedriver.required_version = <desired driver version>` '\
+'to an known chromedriver version: https://chromedriver.storage.googleapis.com/index.html'
+
+      expect { chromedriver.latest_version }.to raise_exception(Webdrivers::VersionError, msg)
     end
-  end
 
-  # Workaround for Google Chrome when using Jruby on Windows.
-  # @see https://github.com/titusfortner/webdrivers/issues/41
-  if RUBY_PLATFORM == 'java' && Selenium::WebDriver::Platform.windows?
-    context 'when using Jruby on Windows' do
-      it 'uses Jruby specific workaround to retrieve the Google Chrome version' do
-        chromedriver.remove
-        chromedriver.update
-        expect(chromedriver.current_version).not_to be_nil
-      end
+    it 'raises ConnectionError when offline' do
+      allow(Net::HTTP).to receive(:get_response).and_raise(SocketError)
+
+      msg = %r{^Can not reach https://chromedriver.storage.googleapis.com}
+      expect { chromedriver.latest_version }.to raise_error(Webdrivers::ConnectionError, msg)
+    end
+
+    it 'creates cached file' do
+      allow(Webdrivers::Network).to receive(:get).and_return('71.0.3578.137')
+
+      chromedriver.latest_version
+      expect(File.exist?("#{Webdrivers::System.install_dir}/chromedriver.version")).to eq true
+    end
+
+    it 'does not make network call if cache is valid' do
+      allow(Webdrivers).to receive(:cache_time).and_return(3600)
+      Webdrivers::System.cache_version('chromedriver', '71.0.3578.137')
+      allow(Webdrivers::Network).to receive(:get)
+
+      expect(chromedriver.latest_version).to eq Gem::Version.new('71.0.3578.137')
+
+      expect(Webdrivers::Network).not_to have_received(:get)
+    end
+
+    it 'makes a network call if cache is expired' do
+      Webdrivers::System.cache_version('chromedriver', '71.0.3578.137')
+      allow(Webdrivers::Network).to receive(:get).and_return('73.0.3683.68')
+      allow(Webdrivers::System).to receive(:valid_cache?)
+
+      expect(chromedriver.latest_version).to eq Gem::Version.new('73.0.3683.68')
+
+      expect(Webdrivers::Network).to have_received(:get)
+      expect(Webdrivers::System).to have_received(:valid_cache?)
     end
   end
 
-  context 'when offline' do
-    before do
-      chromedriver.instance_variable_set('@latest_version', nil)
-      allow(chromedriver).to receive(:site_available?).and_return(false)
+  describe '#required_version=' do
+    it 'returns the version specified as a Float' do
+      chromedriver.required_version = 73.0
+
+      expect(chromedriver.required_version).to eq Gem::Version.new('73.0')
+    end
+
+    it 'returns the version specified as a String' do
+      chromedriver.required_version = '73.0'
+
+      expect(chromedriver.required_version).to eq Gem::Version.new('73.0')
     end
+  end
 
-    it 'raises exception finding latest version' do
-      expect { chromedriver.latest_version }.to raise_error(StandardError, 'Can not reach site')
+  describe '#remove' do
+    it 'removes existing chromedriver' do
+      chromedriver.update
+
+      chromedriver.remove
+      expect(chromedriver.current_version).to be_nil
     end
 
-    it 'raises exception downloading' do
-      expect { chromedriver.download }.to raise_error(StandardError, 'Can not reach site')
+    it 'does not raise exception if no chromedriver found' do
+      expect { chromedriver.remove }.not_to raise_error
     end
   end
 
-  it 'allows setting of install directory' do
-    begin
-      install_dir = File.expand_path(File.join(ENV['HOME'], '.webdrivers2'))
-      Webdrivers.install_dir = install_dir
-      expect(chromedriver.install_dir).to eq install_dir
-    ensure
-      Webdrivers.install_dir = nil
+  describe '#install_dir' do
+    it 'uses ~/.webdrivers as default value' do
+      expect(Webdrivers::System.install_dir).to include('.webdriver')
+    end
+
+    it 'uses provided value' do
+      begin
+        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
     end
   end
 
-  it 'returns full location of binary' do
-    install_dir = File.expand_path(File.join(ENV['HOME'], '.webdrivers'))
-    expect(chromedriver.binary).to match %r{#{install_dir}/chromedriver}
+  describe '#driver_path' do
+    it 'returns full location of binary' do
+      expect(chromedriver.driver_path).to match("#{File.join(ENV['HOME'])}/.webdrivers/chromedriver")
+    end
   end
 end