webdrivers 4.3.0 → 4.6.0

data/lib/webdrivers/iedriver.rb

@@ -44,16 +44,19 @@ module Webdrivers
       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[/([^_]+)\.zip/, 1]
+          hash[version] = "#{base_url}#{item}"
         end
         Webdrivers.logger.debug "Versions now located on downloads site: #{ds.keys}"
         ds
       end
+
+      def download_manifest
+        doc = Nokogiri::XML.parse(Network.get(base_url))
+        items = doc.css('Key').collect(&:text)
+        items.select { |item| item.include?('IEDriverServer_Win32') }
+      end
     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

@@ -148,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.3.0'
+  VERSION = '4.6.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

@@ -6,9 +6,7 @@ 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)
+    if Selenium::WebDriver::VERSION[0].to_i < 4
       skip "The current selenium-webdriver doesn't include Chromium based Edge support"
     end
   end
@@ -20,8 +18,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 +27,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 +36,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

@@ -6,9 +6,7 @@ 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)
+    if Selenium::WebDriver::VERSION[0].to_i < 4
       skip "The current selenium-webdriver doesn't include Chromium based Edge support"
     end
   end
@@ -114,15 +112,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 +162,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>` '\
@@ -196,28 +195,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')

data/spec/webdrivers/i_edriver_spec.rb

@@ -115,9 +115,10 @@ describe Webdrivers::IEdriver do
       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')

data/spec/webdrivers/system_spec.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Webdrivers::System do
+  describe '#wsl_v1?' do
+    subject { described_class.wsl_v1? }
+
+    before do
+      allow(described_class).to receive(:platform).and_return(platform)
+      allow(File).to receive(:open).with('/proc/version').and_return(StringIO.new(wsl_proc_version_contents))
+    end
+
+    let(:platform) { 'linux' }
+    let(:wsl_proc_version_contents) { '' }
+
+    context 'when the current platform is linux and WSL version is 1' do
+      let(:wsl_proc_version_contents) do
+        'Linux version 4.4.0-18362-Microsoft'\
+        '(Microsoft@Microsoft.com) (gcc version 5.4.0 (GCC) )'\
+        '#836-Microsoft Mon May 05 16:04:00 PST 2020'
+      end
+
+      it { is_expected.to eq true }
+    end
+
+    context 'when the current platform is linux and WSL version is 2' do
+      let(:wsl_proc_version_contents) do
+        'Linux version 4.19.84-microsoft-standard '\
+        '(oe-user@oe-host) (gcc version 8.2.0 (GCC)) '\
+        '#1 SMP Wed Nov 13 11:44:37 UTC 2019'
+      end
+
+      it { is_expected.to eq false }
+    end
+
+    context 'when the current platform is mac' do
+      let(:platform) { 'mac' }
+
+      it { is_expected.to eq false }
+    end
+  end
+
+  describe '#to_win32_path' do
+    before { allow(described_class).to receive(:call).and_return("C:\\path\\to\\folder\n") }
+
+    it 'uses wslpath' do
+      described_class.to_win32_path '/c/path/to/folder'
+
+      expect(described_class).to have_received(:call).with('wslpath -w \'/c/path/to/folder\'')
+    end
+
+    it 'removes the trailing newline' do
+      expect(described_class.to_win32_path('/c/path/to/folder')).not_to end_with('\n')
+    end
+
+    context 'when the path is already in Windows format' do
+      it 'returns early' do
+        expect(described_class.to_win32_path('D:\\')).to eq 'D:\\'
+
+        expect(described_class).not_to have_received(:call)
+      end
+    end
+  end
+
+  describe '#to_wsl_path' do
+    before { allow(described_class).to receive(:call).and_return("/c/path/to/folder\n") }
+
+    it 'uses wslpath' do
+      described_class.to_wsl_path 'C:\\path\\to\\folder'
+
+      expect(described_class).to have_received(:call).with('wslpath -u \'C:\\path\\to\\folder\'')
+    end
+
+    it 'removes the trailing newline' do
+      expect(described_class.to_wsl_path('/c/path/to/folder')).not_to end_with('\n')
+    end
+  end
+end