webdrivers 4.0.1 → 5.2.0

data/lib/webdrivers/railtie.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'webdrivers'
 require 'rails'
 
 module Webdrivers

data/lib/webdrivers/system.rb

@@ -2,6 +2,13 @@
 
 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
   #
@@ -13,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
@@ -89,7 +98,7 @@ module Webdrivers
         when /tar\.bz2$/
           untarbz2_file(tempfile)
         when /\.zip$/
-          unzip_file(tempfile)
+          unzip_file(tempfile, File.basename(target))
         else
           Webdrivers.logger.debug 'No Decompression needed'
           FileUtils.cp(tempfile, File.join(Dir.pwd, file_name))
@@ -114,19 +123,17 @@ module Webdrivers
         end
       end
 
-      def unzip_file(filename)
+      def unzip_file(filename, driver_name)
         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
+          driver = zip_file.get_entry(driver_name)
+          f_path = File.join(Dir.pwd, driver.name)
+          delete(f_path)
+          FileUtils.mkdir_p(File.dirname(f_path)) unless File.exist?(File.dirname(f_path))
+          zip_file.extract(driver, f_path)
         end
-        @top_path
+        driver_name
       end
 
       def platform
@@ -141,19 +148,49 @@ 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
 
-      def call(cmd)
+      def call(process, arg = nil)
+        cmd = arg ? [process, arg] : process # Windows provides powershell command (process) only, no args.
         Webdrivers.logger.debug "making System call: #{cmd}"
-        `#{cmd}`
-      end
-
-      def escape_path(path)
-        return path.tr('/', '\\') if platform == 'win' # Windows
+        p = IO.popen(cmd)
+        out = p.read
+        p.close
+        raise "Failed to make system call: #{cmd}" unless $CHILD_STATUS.success?
 
-        Shellwords.escape(path) # Linux and macOS
+        Webdrivers.logger.debug "System call returned: #{out}"
+        out
       end
     end
   end

data/lib/webdrivers/tasks/chromedriver.rake

@@ -19,8 +19,6 @@ namespace :webdrivers do
     desc 'Remove and download updated chromedriver if necessary'
     task :update, [:version] do |_, args|
       args.with_defaults(version: 0)
-      Webdrivers.cache_time                     = ENV.fetch('WD_CACHE_TIME', 86_400)
-      Webdrivers.install_dir                    = ENV.fetch('WD_INSTALL_DIR', nil)
       Webdrivers::Chromedriver.required_version = args.version
       Webdrivers::Chromedriver.update
       Webdrivers.logger.info "Updated to chromedriver #{Webdrivers::Chromedriver.current_version}"

data/lib/webdrivers/tasks/edgedriver.rake

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+namespace :webdrivers do
+  require 'webdrivers/edgedriver'
+
+  namespace :edgedriver do
+    Webdrivers.logger.level = :info
+
+    desc 'Print current edgedriver version'
+    task :version do
+      gem_ver = Webdrivers::Edgedriver.current_version
+      if gem_ver
+        Webdrivers.logger.info "edgedriver #{gem_ver.version}"
+      else
+        Webdrivers.logger.warn 'No existing edgedriver found.'
+      end
+    end
+
+    desc 'Remove and download updated edgedriver if necessary'
+    task :update, [:version] do |_, args|
+      args.with_defaults(version: 0)
+      Webdrivers::Edgedriver.required_version = args.version
+      Webdrivers::Edgedriver.update
+      Webdrivers.logger.info "Updated to edgedriver #{Webdrivers::Edgedriver.current_version}"
+    end
+
+    desc 'Force remove edgedriver'
+    task :remove do
+      unless File.exist? Webdrivers::Edgedriver.driver_path
+        Webdrivers.logger.info 'No existing edgedriver to remove.'
+        next # Return early
+      end
+
+      cur_version = Webdrivers::Edgedriver.current_version
+      Webdrivers::Edgedriver.remove
+
+      if File.exist? Webdrivers::Edgedriver.driver_path # Failed for some reason
+        Webdrivers.logger.error 'Failed to remove edgedriver. Please try removing manually.'
+      else
+        Webdrivers.logger.info "Removed edgedriver #{cur_version}."
+      end
+    end
+  end
+end

data/lib/webdrivers/tasks/geckodriver.rake

@@ -19,8 +19,6 @@ namespace :webdrivers do
     desc 'Remove and download updated geckodriver if necessary'
     task :update, [:version] do |_, args|
       args.with_defaults(version: 0)
-      Webdrivers.cache_time                    = ENV.fetch('WD_CACHE_TIME', 86_400)
-      Webdrivers.install_dir                   = ENV.fetch('WD_INSTALL_DIR', nil)
       Webdrivers::Geckodriver.required_version = args.version
       Webdrivers::Geckodriver.update
       Webdrivers.logger.info "Updated to geckodriver #{Webdrivers::Geckodriver.current_version}"

data/lib/webdrivers/tasks/iedriver.rake

@@ -19,8 +19,6 @@ namespace :webdrivers do
     desc 'Remove and download updated IEDriverServer if necessary'
     task :update, [:version] do |_, args|
       args.with_defaults(version: 0)
-      Webdrivers.cache_time                 = ENV.fetch('WD_CACHE_TIME', 86_400)
-      Webdrivers.install_dir                = ENV.fetch('WD_INSTALL_DIR', nil)
       Webdrivers::IEdriver.required_version = args.version
       Webdrivers::IEdriver.update
       Webdrivers.logger.info "Updated to IEDriverServer #{Webdrivers::IEdriver.current_version}"

data/lib/webdrivers/version.rb

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

data/lib/webdrivers.rb

@@ -2,5 +2,6 @@
 
 require 'webdrivers/chromedriver'
 require 'webdrivers/geckodriver'
+require 'webdrivers/edgedriver'
 require 'webdrivers/iedriver'
 require 'webdrivers/railtie' if defined?(Rails)

data/spec/webdrivers/chrome_finder_spec.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Webdrivers::ChromeFinder do
+  let(:chrome_finder) { described_class }
+
+  context 'when the user relies on the gem to figure out the location of Chrome' do
+    it 'determines the location correctly based on the current OS' do
+      expect { chrome_finder.location }.not_to raise_error
+    end
+  end
+
+  context 'when the user provides a path to the Chrome binary' do
+    it 'uses Selenium::WebDriver::Chrome.path when it is defined' do
+      Selenium::WebDriver::Chrome.path = chrome_finder.location
+      locations = %i[win_location mac_location linux_location]
+      allow(chrome_finder).to receive_messages(locations)
+
+      expect(chrome_finder.version).not_to be_nil
+      locations.each { |loc| expect(chrome_finder).not_to have_received(loc) }
+    end
+  end
+
+  it "uses ENV['WD_CHROME_PATH'] when it is defined" do
+    allow(ENV).to receive(:[]).with('WD_CHROME_PATH').and_return(chrome_finder.location)
+    locations = %i[win_location mac_location linux_location]
+    allow(chrome_finder).to receive_messages(locations)
+
+    expect(chrome_finder.version).not_to be_nil
+    locations.each { |loc| expect(chrome_finder).not_to have_received(loc) }
+  end
+
+  it 'uses Selenium::WebDriver::Chrome.path over WD_CHROME_PATH' do
+    Selenium::WebDriver::Chrome.path = chrome_finder.location
+    allow(ENV).to receive(:[]).with('WD_CHROME_PATH').and_return('my_wd_chrome_path')
+    expect(chrome_finder.version).not_to be_nil
+    expect(ENV).not_to have_received(:[]).with('WD_CHROME_PATH')
+  end
+
+  context 'when Chrome is not installed' do
+    it 'raises BrowserNotFound' do
+      locations = %i[win_location mac_location linux_location]
+      allow(chrome_finder).to receive_messages(locations)
+      allow(chrome_finder).to receive(:user_defined_location).and_return(nil)
+
+      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

@@ -31,7 +31,7 @@ describe Webdrivers::Chromedriver do
       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(:browser_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'))
 
         chromedriver.update
@@ -44,7 +44,7 @@ describe Webdrivers::Chromedriver do
 
         allow(Webdrivers::Network).to receive(:get_response).and_return(client_error)
         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(:browser_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'))
 
         chromedriver.update
@@ -55,7 +55,7 @@ describe Webdrivers::Chromedriver do
       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(:browser_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}
@@ -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(:chrome_version).and_return(Gem::Version.new('73.0.3683.68'))
+      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
@@ -146,7 +147,7 @@ describe Webdrivers::Chromedriver do
     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")
+        .with(chromedriver.driver_path, '--version')
         .and_return '71.0.3578.137'
 
       expect(chromedriver.current_version).to eq Gem::Version.new('71.0.3578.137')
@@ -155,20 +156,20 @@ 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(:chrome_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(:chrome_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(:chrome_version).and_return('100.0.0')
-      msg = 'Unable to find latest point release version for 100.0.0. '\
+      allow(chromedriver).to receive(:browser_version).and_return Gem::Version.new('999.0.0')
+      msg = 'Unable to find latest point release version for 999.0.0. '\
 'You appear to be using a non-production version of Chrome. '\
 'Please set `Webdrivers::Chromedriver.required_version = <desired driver version>` '\
 'to a known chromedriver version: https://chromedriver.storage.googleapis.com/index.html'
@@ -177,7 +178,7 @@ describe Webdrivers::Chromedriver do
     end
 
     it 'raises VersionError for unknown version' do
-      allow(chromedriver).to receive(:chrome_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')
 
@@ -253,8 +258,19 @@ describe Webdrivers::Chromedriver do
   describe '#driver_path' do
     it 'returns full location of binary' do
       expected_bin = "chromedriver#{'.exe' if Selenium::WebDriver::Platform.windows?}"
-      expected_path = Webdrivers::System.escape_path("#{File.join(ENV['HOME'])}/.webdrivers/#{expected_bin}")
+      expected_path = File.absolute_path "#{File.join(ENV['HOME'])}/.webdrivers/#{expected_bin}"
       expect(chromedriver.driver_path).to eq(expected_path)
     end
   end
+
+  describe '#browser_version' do
+    it 'returns a Gem::Version object' do
+      expect(chromedriver.browser_version).to be_an_instance_of(Gem::Version)
+    end
+
+    it 'returns currently installed Chrome version' do
+      allow(Webdrivers::ChromeFinder).to receive(:version).and_return('72.0.0.0')
+      expect(chromedriver.browser_version).to be Gem::Version.new('72.0.0.0')
+    end
+  end
 end

data/spec/webdrivers/edge_finder_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Webdrivers::EdgeFinder do
+  let(:edge_finder) { described_class }
+
+  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
+      expect { edge_finder.location }.not_to raise_error
+    end
+  end
+
+  context 'when the user provides a path to the Edge binary' do
+    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)
+
+      expect(edge_finder.version).not_to be_nil
+      locations.each { |loc| expect(edge_finder).not_to have_received(loc) }
+    end
+
+    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)
+
+      expect(edge_finder.version).not_to be_nil
+      locations.each { |loc| expect(edge_finder).not_to have_received(loc) }
+    end
+
+    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_PATH')
+    end
+  end
+
+  context 'when Edge is not installed' do
+    it 'raises BrowserNotFound' do
+      locations = %i[win_location mac_location linux_location]
+      allow(edge_finder).to receive_messages(locations)
+      allow(edge_finder).to receive(:user_defined_location).and_return(nil)
+
+      expect { edge_finder.version }.to raise_error(Webdrivers::BrowserNotFound)
+    end
+  end
+end