webdrivers 4.0.1 → 5.2.0

data/spec/webdrivers/edgedriver_spec.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Webdrivers::Edgedriver do
+  let(:edgedriver) { described_class }
+
+  before do
+    edgedriver.remove
+  end
+
+  describe '#update' do
+    context 'when evaluating #correct_binary?' do
+      it 'does not download when latest version and current version match' do
+        allow(edgedriver).to receive(:latest_version).and_return(Gem::Version.new('72.0.0'))
+        allow(edgedriver).to receive(:current_version).and_return(Gem::Version.new('72.0.0'))
+
+        edgedriver.update
+
+        expect(edgedriver.send(:exists?)).to be false
+      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(edgedriver).to receive(:exists?).and_return(true)
+        allow(edgedriver).to receive(:current_version).and_return(Gem::Version.new(69))
+
+        edgedriver.update
+
+        expect(File.exist?(edgedriver.driver_path)).to be false
+      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(edgedriver).to receive(:exists?).and_return(true)
+        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('73.0.3683.20'))
+
+        edgedriver.update
+
+        expect(File.exist?(edgedriver.driver_path)).to be false
+      end
+
+      it 'does not download when get raises exception, binary exists and matches major browser version' do
+        client_error = instance_double(Net::HTTPNotFound, class: Net::HTTPNotFound, code: 404, message: '')
+
+        allow(Webdrivers::Network).to receive(:get_response).and_return(client_error)
+        allow(edgedriver).to receive(:exists?).and_return(true)
+        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('73.0.3683.20'))
+
+        edgedriver.update
+
+        expect(File.exist?(edgedriver.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(edgedriver).to receive(:exists?).and_return(true)
+        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('72.0.0.0'))
+
+        msg = %r{Can not reach https://msedgedriver.azureedge.net/}
+        expect { edgedriver.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(edgedriver).to receive(:exists?).and_return(false)
+
+        msg = %r{Can not reach https://msedgedriver.azureedge.net/}
+        expect { edgedriver.update }.to raise_error(Webdrivers::ConnectionError, msg)
+      end
+    end
+
+    context 'when correct binary is found' do
+      before { allow(edgedriver).to receive(:correct_binary?).and_return(true) }
+
+      it 'does not download' do
+        edgedriver.update
+
+        expect(edgedriver.current_version).to be_nil
+      end
+
+      it 'does not raise exception if offline' do
+        allow(Net::HTTP).to receive(:get_response).and_raise(SocketError)
+
+        edgedriver.update
+
+        expect(edgedriver.current_version).to be_nil
+      end
+    end
+
+    context 'when correct binary is not found' do
+      before { allow(edgedriver).to receive(:correct_binary?).and_return(false) }
+
+      it 'downloads binary' do
+        edgedriver.update
+
+        expect(edgedriver.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://msedgedriver.azureedge.net/}
+        expect { edgedriver.update }.to raise_error(Webdrivers::ConnectionError, msg)
+      end
+    end
+
+    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(: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).twice
+    end
+
+    context 'when required version is 0' do
+      it 'downloads the latest version' do
+        allow(edgedriver).to receive(:latest_version).and_return(Gem::Version.new('98.0.1089.1'))
+        edgedriver.required_version = 0
+        edgedriver.update
+        expect(edgedriver.current_version.version).to eq('98.0.1089.1')
+      end
+    end
+
+    context 'when required version is nil' do
+      it 'downloads the latest version' do
+        allow(edgedriver).to receive(:latest_version).and_return(Gem::Version.new('98.0.1089.1'))
+        edgedriver.required_version = nil
+        edgedriver.update
+        expect(edgedriver.current_version.version).to eq('98.0.1089.1')
+      end
+    end
+  end
+
+  describe '#current_version' do
+    it 'returns nil if binary does not exist on the system' do
+      allow(edgedriver).to receive(:driver_path).and_return('')
+
+      expect(edgedriver.current_version).to be_nil
+    end
+
+    it 'returns a Gem::Version instance if binary is on the system' do
+      allow(edgedriver).to receive(:exists?).and_return(true)
+      allow(Webdrivers::System).to receive(:call)
+        .with(edgedriver.driver_path, '--version')
+        .and_return '71.0.3578.137'
+
+      expect(edgedriver.current_version).to eq Gem::Version.new('71.0.3578.137')
+    end
+  end
+
+  describe '#latest_version' do
+    it 'returns the correct point release for a production version' do
+      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 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 Edge. '\
+'Please set `Webdrivers::Edgedriver.required_version = <desired driver version>` '\
+'to a known edgedriver version: Can not reach https://msedgedriver.azureedge.net'
+
+      expect { edgedriver.latest_version }.to raise_exception(Webdrivers::VersionError, msg)
+    end
+
+    it 'raises VersionError for unknown version' do
+      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'
+
+      expect { edgedriver.latest_version }.to raise_exception(Webdrivers::VersionError, msg)
+    end
+
+    it 'raises ConnectionError when offline' do
+      allow(Net::HTTP).to receive(:get_response).and_raise(SocketError)
+
+      msg = %r{^Can not reach https://msedgedriver.azureedge.net}
+      expect { edgedriver.latest_version }.to raise_error(Webdrivers::ConnectionError, msg)
+    end
+
+    it 'creates cached file' do
+      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 calls if cache is valid and driver exists' do
+      allow(Webdrivers).to receive(:cache_time).and_return(3600)
+      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('82.0.445.0')
+
+      expect(Webdrivers::Network).not_to have_received(:get)
+    end
+
+    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?).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')
+
+      expect(Webdrivers::Network).to have_received(:get)
+      expect(Webdrivers::System).to have_received(:valid_cache?)
+    end
+  end
+
+  describe '#required_version=' do
+    after { edgedriver.required_version = nil }
+
+    it 'returns the version specified as a Float' do
+      edgedriver.required_version = 73.0
+
+      expect(edgedriver.required_version).to eq Gem::Version.new('73.0')
+    end
+
+    it 'returns the version specified as a String' do
+      edgedriver.required_version = '73.0'
+
+      expect(edgedriver.required_version).to eq Gem::Version.new('73.0')
+    end
+  end
+
+  describe '#remove' do
+    it 'removes existing edgedriver' do
+      edgedriver.update
+
+      edgedriver.remove
+      expect(edgedriver.current_version).to be_nil
+    end
+
+    it 'does not raise exception if no edgedriver found' do
+      expect { edgedriver.remove }.not_to raise_error
+    end
+  end
+
+  describe '#driver_path' do
+    it 'returns full location of binary' do
+      expected_bin = "msedgedriver#{'.exe' if Selenium::WebDriver::Platform.windows?}"
+      expected_path = File.absolute_path "#{File.join(ENV['HOME'])}/.webdrivers/#{expected_bin}"
+      expect(edgedriver.driver_path).to eq(expected_path)
+    end
+  end
+
+  describe '#browser_version' do
+    it 'returns a Gem::Version object' do
+      expect(edgedriver.browser_version).to be_an_instance_of(Gem::Version)
+    end
+
+    it 'returns currently installed Edge version' do
+      allow(Webdrivers::EdgeFinder).to receive(:version).and_return('72.0.0.0')
+      expect(edgedriver.browser_version).to be Gem::Version.new('72.0.0.0')
+    end
+  end
+end

data/spec/webdrivers/geckodriver_spec.rb

@@ -92,6 +92,40 @@ describe Webdrivers::Geckodriver do
       msg = /Net::HTTPServerException: 404 "Not Found"/
       expect { geckodriver.update }.to raise_error(StandardError, msg)
     end
+
+    context 'when platform is Apple Sillicon' do
+      it 'downloads aarch64 binary' do
+        allow(Webdrivers::System).to receive(:platform).and_return('mac')
+        allow(Webdrivers::System).to receive(:apple_m1_architecture?).and_return(true)
+        base = 'https://github.com/mozilla/geckodriver/releases/download'
+        binary = 'geckodriver-v0.31.0-macos-aarch64.tar.gz'
+        url = "#{base}/v0.31.0/#{binary}"
+
+        allow(Webdrivers::System).to receive(:download).with(url, geckodriver.driver_path)
+
+        geckodriver.required_version = '0.31.0'
+        geckodriver.update
+
+        expect(Webdrivers::System).to have_received(:download).with(url, geckodriver.driver_path)
+      end
+    end
+
+    context 'when platform isn\'t Apple Sillicon' do
+      it 'downloads default binary' do
+        allow(Webdrivers::System).to receive(:platform).and_return('mac')
+        allow(Webdrivers::System).to receive(:apple_m1_architecture?).and_return(false)
+        base = 'https://github.com/mozilla/geckodriver/releases/download'
+        binary = 'geckodriver-v0.31.0-macos.tar.gz'
+        url = "#{base}/v0.31.0/#{binary}"
+
+        allow(Webdrivers::System).to receive(:download).with(url, geckodriver.driver_path)
+
+        geckodriver.required_version = '0.31.0'
+        geckodriver.update
+
+        expect(Webdrivers::System).to have_received(:download).with(url, geckodriver.driver_path)
+      end
+    end
   end
 
   describe '#current_version' do
@@ -112,7 +146,7 @@ testing/geckodriver in https://hg.mozilla.org/mozilla-central.
 This program is subject to the terms of the Mozilla Public License 2.0.
 You can obtain a copy of the license at https://mozilla.org/MPL/2.0/"
 
-      allow(Webdrivers::System).to receive(:call).with("#{geckodriver.driver_path} --version").and_return return_value
+      allow(Webdrivers::System).to receive(:call).with(geckodriver.driver_path, '--version').and_return return_value
 
       expect(geckodriver.current_version).to eq Gem::Version.new('0.24.0')
     end
@@ -135,9 +169,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,21 +226,19 @@ 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
 
   describe '#driver_path' do
     it 'returns full location of binary' do
       expected_bin = "geckodriver#{'.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(geckodriver.driver_path).to eq(expected_path)
     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
@@ -87,7 +91,7 @@ describe Webdrivers::IEdriver do
 
       return_value = 'something IEDriverServer.exe 3.5.1 something else'
 
-      allow(Webdrivers::System).to receive(:call).with("#{iedriver.driver_path} --version").and_return return_value
+      allow(Webdrivers::System).to receive(:call).with(iedriver.driver_path, '--version').and_return return_value
 
       expect(iedriver.current_version).to eq Gem::Version.new('3.5.1')
     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,20 +179,18 @@ 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
 
   describe '#driver_path' do
     it 'returns full location of binary' do
-      expected_path = Webdrivers::System.escape_path("#{File.join(ENV['HOME'])}/.webdrivers/IEDriverServer.exe")
+      expected_path = File.absolute_path "#{File.join(ENV['HOME'])}/.webdrivers/IEDriverServer.exe"
       expect(iedriver.driver_path).to eq(expected_path)
     end
   end

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

data/spec/webdrivers/webdrivers_spec.rb

@@ -29,15 +29,15 @@ describe Webdrivers do
     end
 
     context 'when ENV variable WD_CACHE_TIME is set' do
-      before { described_class.cache_time = 86_400 }
+      before { described_class.cache_time = 3600 }
 
-      it 'uses cache time value from ENV variable over the Webdrivers.cache_time value' do
-        allow(ENV).to receive(:[]).with('WD_CACHE_TIME').and_return(999)
-        expect(described_class.cache_time).to be(999)
+      it 'uses cache time value from Webdrivers.cache_time over the ENV variable value' do
+        allow(ENV).to receive(:[]).with('WD_CACHE_TIME').and_return(900)
+        expect(described_class.cache_time).to be(3600)
       end
 
       it 'returns cache time as an Integer' do
-        allow(ENV).to receive(:fetch).with('WD_CACHE_TIME', 86_400).and_return('999')
+        allow(ENV).to receive(:fetch).with('WD_CACHE_TIME', 3600).and_return('999')
         expect(described_class.cache_time).to be_an_instance_of(Integer)
       end
     end
@@ -49,25 +49,31 @@ describe Webdrivers do
     end
 
     it 'uses provided value' do
-      begin
-        install_dir                 = File.expand_path(File.join(ENV['HOME'], '.webdrivers2'))
-        described_class.install_dir = install_dir
+      install_dir                 = File.expand_path(File.join(ENV['HOME'], '.webdrivers2'))
+      described_class.install_dir = install_dir
 
-        expect(described_class.install_dir).to eq install_dir
+      expect(described_class.install_dir).to eq install_dir
+    ensure
+      described_class.install_dir = nil
+    end
+
+    context 'when ENV variable WD_INSTALL_DIR is set and Webdrivers.install_dir is not' do
+      it 'uses path from the ENV variable' do
+        described_class.install_dir = nil
+        allow(ENV).to receive(:[]).with('WD_INSTALL_DIR').and_return('custom_dir')
+        expect(described_class.install_dir).to be('custom_dir')
       ensure
         described_class.install_dir = nil
       end
     end
 
-    context 'when ENV variable WD_INSTALL_DIR is set and Webdrivers.install_dir is not' do
-      it 'uses path from the ENV variable' do
-        begin
-          described_class.install_dir = nil
-          allow(ENV).to receive(:[]).with('WD_INSTALL_DIR').and_return('custom_dir')
-          expect(described_class.install_dir).to be('custom_dir')
-        ensure
-          described_class.install_dir = nil
-        end
+    context 'when both ENV variable WD_INSTALL_DIR and Webdrivers.install_dir are set' do
+      it 'uses path from Webdrivers.install_dir' do
+        described_class.install_dir = 'my_install_dir_path'
+        allow(ENV).to receive(:[]).with('WD_INSTALL_DIR').and_return('my_env_path')
+        expect(described_class.install_dir).to be('my_install_dir_path')
+      ensure
+        described_class.install_dir = nil
       end
     end
   end