webdrivers 2.3.2 → 4.7.0

data/lib/webdrivers/tasks/chromedriver.rake

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

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

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

data/lib/webdrivers/tasks/iedriver.rake

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

data/lib/webdrivers/version.rb

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

data/lib/webdrivers.rb

@@ -1,9 +1,7 @@
-require "webdrivers/common"
-require "webdrivers/chromedriver"
-require "webdrivers/edgedriver"
-require "webdrivers/geckodriver"
-require "webdrivers/iedriver"
-require "webdrivers/phantomjs"
-require 'fileutils'
-require 'rbconfig'
-require 'open-uri'
+# frozen_string_literal: true
+
+require 'webdrivers/chromedriver'
+require 'webdrivers/geckodriver'
+require 'webdrivers/edgedriver'
+require 'webdrivers/iedriver'
+require 'webdrivers/railtie' if defined?(Rails)

data/spec/spec_helper.rb

@@ -1,2 +1,18 @@
-require "rspec"
-require "webdrivers"
+# frozen_string_literal: true
+
+require 'simplecov'
+SimpleCov.start
+
+require 'rspec'
+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/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

@@ -0,0 +1,276 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Webdrivers::Chromedriver do
+  let(:chromedriver) { described_class }
+
+  before { chromedriver.remove }
+
+  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'))
+
+        chromedriver.update
+
+        expect(chromedriver.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(chromedriver).to receive(:exists?).and_return(true)
+        allow(chromedriver).to receive(:current_version).and_return(Gem::Version.new(69))
+
+        chromedriver.update
+
+        expect(File.exist?(chromedriver.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(chromedriver).to receive(:exists?).and_return(true)
+        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
+
+        expect(File.exist?(chromedriver.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(chromedriver).to receive(:exists?).and_return(true)
+        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
+
+        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(: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}
+        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 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).twice
+    end
+
+    context 'when required version is 0' do
+      it 'downloads the latest version' do
+        allow(chromedriver).to receive(:latest_version).and_return(Gem::Version.new('72.0.3626.7'))
+        chromedriver.required_version = 0
+        chromedriver.update
+        expect(chromedriver.current_version.version).to eq('72.0.3626.7')
+      end
+    end
+
+    context 'when required version is nil' do
+      it 'downloads the latest version' do
+        allow(chromedriver).to receive(:latest_version).and_return(Gem::Version.new('72.0.3626.7'))
+        chromedriver.required_version = nil
+        chromedriver.update
+        expect(chromedriver.current_version.version).to eq('72.0.3626.7')
+      end
+    end
+  end
+
+  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(: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 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 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>` '\
+'to a known chromedriver version: https://chromedriver.storage.googleapis.com/index.html'
+
+      expect { chromedriver.latest_version }.to raise_exception(Webdrivers::VersionError, msg)
+    end
+
+    it 'raises VersionError for unknown version' do
+      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'
+
+      expect { chromedriver.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://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 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')
+
+      expect(Webdrivers::Network).not_to have_received(:get)
+    end
+
+    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?).and_return(false)
+
+      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
+
+  describe '#required_version=' do
+    after { chromedriver.required_version = nil }
+
+    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
+
+  describe '#remove' do
+    it 'removes existing chromedriver' do
+      chromedriver.update
+
+      chromedriver.remove
+      expect(chromedriver.current_version).to be_nil
+    end
+
+    it 'does not raise exception if no chromedriver found' do
+      expect { chromedriver.remove }.not_to raise_error
+    end
+  end
+
+  describe '#driver_path' do
+    it 'returns full location of binary' do
+      expected_bin = "chromedriver#{'.exe' if Selenium::WebDriver::Platform.windows?}"
+      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,58 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Webdrivers::EdgeFinder do
+  let(:edge_finder) { described_class }
+
+  before(:all) do # rubocop:disable RSpec/BeforeAfterAll
+    if Selenium::WebDriver::VERSION[0].to_i < 4
+      skip 'The current selenium-webdriver does not include Chromium based Edge support'
+    elsif Webdrivers::System.platform == 'linux'
+      skip 'Edge is not yet supported on Linux'
+    end
+  end
+
+  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