webdrivers 4.0.0 → 5.2.0

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.0'
+  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,9 +106,10 @@ 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)
 
@@ -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')
 
@@ -252,7 +257,20 @@ describe Webdrivers::Chromedriver do
 
   describe '#driver_path' do
     it 'returns full location of binary' do
-      expect(chromedriver.driver_path).to match("#{File.join(ENV['HOME'])}/.webdrivers/chromedriver")
+      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,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

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