capybara 2.15.0 → 3.0.0

data/lib/capybara/selenium/driver.rb

@@ -1,14 +1,15 @@
 # frozen_string_literal: true
+
 require "uri"
+require "English"
 
 class Capybara::Selenium::Driver < Capybara::Driver::Base
-
   DEFAULT_OPTIONS = {
-    :browser => :firefox,
+    browser: :firefox,
     clear_local_storage: false,
     clear_session_storage: false
-  }
-  SPECIAL_OPTIONS = [:browser, :clear_local_storage, :clear_session_storage]
+  }.freeze
+  SPECIAL_OPTIONS = %i[browser clear_local_storage clear_session_storage].freeze
 
   attr_reader :app, :options
 
@@ -16,19 +17,19 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
     unless @browser
       if firefox?
         options[:desired_capabilities] ||= {}
-        options[:desired_capabilities].merge!({ unexpectedAlertBehaviour: "ignore" })
+        options[:desired_capabilities][:unexpectedAlertBehaviour] = "ignore"
       end
 
-      @processed_options = options.reject { |key,_val| SPECIAL_OPTIONS.include?(key) }
+      @processed_options = options.reject { |key, _val| SPECIAL_OPTIONS.include?(key) }
       @browser = Selenium::WebDriver.for(options[:browser], @processed_options)
 
       @w3c = ((defined?(Selenium::WebDriver::Remote::W3CCapabilities) && @browser.capabilities.is_a?(Selenium::WebDriver::Remote::W3CCapabilities)) ||
               (defined?(Selenium::WebDriver::Remote::W3C::Capabilities) && @browser.capabilities.is_a?(Selenium::WebDriver::Remote::W3C::Capabilities)))
-
       main = Process.pid
+
       at_exit do
         # Store the exit status of the test run since it goes away after calling the at_exit proc...
-        @exit_status = $!.status if $!.is_a?(SystemExit)
+        @exit_status = $ERROR_INFO.status if $ERROR_INFO.is_a?(SystemExit)
         quit if Process.pid == main
         exit @exit_status if @exit_status # Force exit with stored status
       end
@@ -36,26 +37,9 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
     @browser
   end
 
-  def initialize(app, options={})
+  def initialize(app, **options)
+    load_selenium
     @session = nil
-    begin
-      require 'selenium-webdriver'
-      # Fix for selenium-webdriver 3.4.0 which misnamed these
-      if !defined?(::Selenium::WebDriver::Error::ElementNotInteractableError)
-        ::Selenium::WebDriver::Error.const_set('ElementNotInteractableError', Class.new(::Selenium::WebDriver::Error::WebDriverError))
-      end
-      if !defined?(::Selenium::WebDriver::Error::ElementClickInterceptedError)
-        ::Selenium::WebDriver::Error.const_set('ElementClickInterceptedError', Class.new(::Selenium::WebDriver::Error::WebDriverError))
-      end
-    rescue LoadError => e
-      if e.message =~ /selenium-webdriver/
-        raise LoadError, "Capybara's selenium driver is unable to load `selenium-webdriver`, please install the gem and add `gem 'selenium-webdriver'` to your Gemfile if you are using bundler."
-      else
-        raise e
-      end
-    end
-
-
     @app = app
     @browser = nil
     @exit_status = nil
@@ -68,10 +52,7 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
   end
 
   def refresh
-    accept_modal(nil, wait: 0.1) do
-      browser.navigate.refresh
-    end
-  rescue Capybara::ModalNotFound
+    browser.navigate.refresh
   end
 
   def go_back
@@ -106,7 +87,7 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
   def needs_server?; true; end
 
   def execute_script(script, *args)
-    browser.execute_script(script, *args.map { |arg| arg.is_a?(Capybara::Selenium::Node) ?  arg.native : arg} )
+    browser.execute_script(script, *args.map { |arg| arg.is_a?(Capybara::Selenium::Node) ? arg.native : arg })
   end
 
   def evaluate_script(script, *args)
@@ -114,62 +95,71 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
     unwrap_script_result(result)
   end
 
-  def save_screenshot(path, _options={})
+  def evaluate_async_script(script, *args)
+    browser.manage.timeouts.script_timeout = Capybara.default_max_wait_time
+    result = browser.execute_async_script(script, *args.map { |arg| arg.is_a?(Capybara::Selenium::Node) ? arg.native : arg })
+    unwrap_script_result(result)
+  end
+
+  def save_screenshot(path, **_options)
     browser.save_screenshot(path)
   end
 
   def reset!
     # Use instance variable directly so we avoid starting the browser just to reset the session
-    if @browser
-      navigated = false
-      start_time = Capybara::Helpers.monotonic_time
+    return unless @browser
+
+    if firefox? || chrome?
+      switch_to_window(window_handles.first)
+      window_handles.slice(1..-1).each { |win| close_window(win) }
+    end
+
+    navigated = false
+    start_time = Capybara::Helpers.monotonic_time
+    begin
+      unless navigated
+        # Only trigger a navigation if we haven't done it already, otherwise it
+        # can trigger an endless series of unload modals
+        begin
+          @browser.manage.delete_all_cookies
+          clear_storage
+        rescue Selenium::WebDriver::Error::UnhandledError
+          # delete_all_cookies fails when we've previously gone
+          # to about:blank, so we rescue this error and do nothing
+          # instead.
+        end
+        @browser.navigate.to("about:blank")
+      end
+      navigated = true
+
+      # Ensure the page is empty and trigger an UnhandledAlertError for any modals that appear during unload
+      until find_xpath("/html/body/*").empty?
+        raise Capybara::ExpectationNotMet, 'Timed out waiting for Selenium session reset' if (Capybara::Helpers.monotonic_time - start_time) >= 10
+        sleep 0.05
+      end
+    rescue Selenium::WebDriver::Error::UnhandledAlertError, Selenium::WebDriver::Error::UnexpectedAlertOpenError
+      # This error is thrown if an unhandled alert is on the page
+      # Firefox appears to automatically dismiss this alert, chrome does not
+      # We'll try to accept it
       begin
-        if !navigated
-          # Only trigger a navigation if we haven't done it already, otherwise it
-          # can trigger an endless series of unload modals
+        @browser.switch_to.alert.accept
+        sleep 0.25 # allow time for the modal to be handled
+      rescue modal_error
+        # The alert is now gone
+        if current_url != "about:blank"
           begin
-            @browser.manage.delete_all_cookies
-            if options[:clear_session_storage]
-              if @browser.respond_to? :session_storage
-                @browser.session_storage.clear
-              else
-                warn "sessionStorage clear requested but is not available for this driver"
-              end
-            end
-            if options[:clear_local_storage]
-              if @browser.respond_to? :local_storage
-                @browser.local_storage.clear
-              else
-                warn "localStorage clear requested but is not available for this driver"
-              end
-            end
-          rescue Selenium::WebDriver::Error::UnhandledError
-            # delete_all_cookies fails when we've previously gone
-            # to about:blank, so we rescue this error and do nothing
-            # instead.
+            # If navigation has not occurred attempt again and accept alert
+            # since FF may have dismissed the alert at first attempt
+            @browser.navigate.to("about:blank")
+            sleep 0.1 # slight wait for alert
+            @browser.switch_to.alert.accept
+          rescue modal_error # rubocop:disable Metrics/BlockNesting
+            # alert now gone, should mean navigation happened
           end
-          @browser.navigate.to("about:blank")
-        end
-        navigated = true
-
-        #Ensure the page is empty and trigger an UnhandledAlertError for any modals that appear during unload
-        until find_xpath("/html/body/*").empty? do
-          raise Capybara::ExpectationNotMet.new('Timed out waiting for Selenium session reset') if (Capybara::Helpers.monotonic_time - start_time) >= 10
-          sleep 0.05
         end
-      rescue Selenium::WebDriver::Error::UnhandledAlertError, Selenium::WebDriver::Error::UnexpectedAlertOpenError
-        # This error is thrown if an unhandled alert is on the page
-        # Firefox appears to automatically dismiss this alert, chrome does not
-        # We'll try to accept it
-        begin
-          @browser.switch_to.alert.accept
-          sleep 0.25 # allow time for the modal to be handled
-        rescue Selenium::WebDriver::Error::NoAlertPresentError
-          # The alert is now gone - nothing to do
-        end
-        # try cleaning up the browser again
-        retry
       end
+      # try cleaning up the browser again
+      retry
     end
   end
 
@@ -221,6 +211,7 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
   end
 
   def close_window(handle)
+    raise ArgumentError, "Not allowed to close the primary window" if handle == window_handles.first
     within_given_window(handle) do
       browser.close
     end
@@ -238,43 +229,28 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
     browser.switch_to.window handle
   end
 
-  def within_window(locator)
-    handle = find_window(locator)
-    browser.switch_to.window(handle) { yield }
-  end
+  def accept_modal(_type, **options)
+    yield if block_given?
+    modal = find_modal(options)
 
-  def accept_modal(_type, options={})
-    if headless_chrome?
-      insert_modal_handlers(true, options[:with], options[:text])
-      yield if block_given?
-      find_headless_modal(options)
-    else
-      yield if block_given?
-      modal = find_modal(options)
-      modal.send_keys options[:with] if options[:with]
-      message = modal.text
-      modal.accept
-      message
-    end
+    modal.send_keys options[:with] if options[:with]
+
+    message = modal.text
+    modal.accept
+    message
   end
 
-  def dismiss_modal(_type, options={})
-    if headless_chrome?
-      insert_modal_handlers(false, options[:with], options[:text])
-      yield if block_given?
-      find_headless_modal(options)
-    else
-      yield if block_given?
-      modal = find_modal(options)
-      message = modal.text
-      modal.dismiss
-      message
-    end
+  def dismiss_modal(_type, **options)
+    yield if block_given?
+    modal = find_modal(options)
+    message = modal.text
+    modal.dismiss
+    message
   end
 
   def quit
     @browser.quit if @browser
-  rescue Errno::ECONNREFUSED
+  rescue Selenium::WebDriver::Error::SessionNotCreatedError, Errno::ECONNREFUSED
     # Browser must have already gone
   rescue Selenium::WebDriver::Error::UnknownError => e
     unless silenced_unknown_error_message?(e.message) # Most likely already gone
@@ -286,14 +262,18 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
   end
 
   def invalid_element_errors
-    [::Selenium::WebDriver::Error::StaleElementReferenceError,
-     ::Selenium::WebDriver::Error::UnhandledError,
-     ::Selenium::WebDriver::Error::ElementNotVisibleError,
-     ::Selenium::WebDriver::Error::InvalidSelectorError, # Work around a race condition that can occur with chromedriver and #go_back/#go_forward
-     ::Selenium::WebDriver::Error::ElementNotInteractableError,
-     ::Selenium::WebDriver::Error::ElementClickInterceptedError,
-     ::Selenium::WebDriver::Error::InvalidElementStateError,
-     ::Selenium::WebDriver::Error::ElementNotSelectableError,
+    [
+      ::Selenium::WebDriver::Error::StaleElementReferenceError,
+      ::Selenium::WebDriver::Error::UnhandledError,
+      ::Selenium::WebDriver::Error::ElementNotVisibleError,
+      ::Selenium::WebDriver::Error::InvalidSelectorError, # Work around a race condition that can occur with chromedriver and #go_back/#go_forward
+      ::Selenium::WebDriver::Error::ElementNotInteractableError,
+      ::Selenium::WebDriver::Error::ElementClickInterceptedError,
+      ::Selenium::WebDriver::Error::InvalidElementStateError,
+      ::Selenium::WebDriver::Error::ElementNotSelectableError,
+      ::Selenium::WebDriver::Error::ElementNotSelectableError,
+      ::Selenium::WebDriver::Error::NoSuchElementError, # IE
+      ::Selenium::WebDriver::Error::InvalidArgumentError # IE
     ]
   end
 
@@ -317,47 +297,57 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
   end
 
   # @api private
-  def headless_chrome?
-    if chrome?
-      caps = @processed_options[:desired_capabilities]
-      chrome_options = caps[:chrome_options] || caps[:chromeOptions] || {}
-      args = chrome_options['args'] || chrome_options[:args] || []
-      return args.include?("--headless") || args.include?("headless")
-    end
-    return false
+  def edge?
+    browser_name == "edge"
   end
 
-
-  # @deprecated This method is being removed
-  def browser_initialized?
-    super && !@browser.nil?
+  # @api private
+  def ie?
+    browser_name == "ie"
   end
 
-  private
+private
 
-  # @api private
   def browser_name
     options[:browser].to_s
   end
 
-  def find_window(locator)
-    handles = browser.window_handles
-    return locator if handles.include? locator
-
-    original_handle = browser.window_handle
-    handles.each do |handle|
-      switch_to_window(handle)
-      if (locator == browser.execute_script("return window.name") ||
-          browser.title.include?(locator) ||
-          browser.current_url.include?(locator))
-        switch_to_window(original_handle)
-        return handle
+  def clear_storage
+    if options[:clear_session_storage]
+      if @browser.respond_to? :session_storage
+        @browser.session_storage.clear
+      else
+        warn "sessionStorage clear requested but is not available for this driver"
+      end
+    end
+    if options[:clear_local_storage]
+      if @browser.respond_to? :local_storage
+        @browser.local_storage.clear
+      else
+        warn "localStorage clear requested but is not available for this driver"
       end
     end
-    raise Capybara::ElementNotFound, "Could not find a window identified by #{locator}"
   end
 
-  def insert_modal_handlers(accept, response_text, expected_text=nil)
+  def modal_error
+    if defined?(Selenium::WebDriver::Error::NoSuchAlertError)
+      Selenium::WebDriver::Error::NoSuchAlertError
+    else
+      Selenium::WebDriver::Error::NoAlertPresentError
+    end
+  end
+
+  def insert_modal_handlers(accept, response_text)
+    prompt_response = if accept
+      if response_text.nil?
+        "default_text"
+      else
+        "'#{response_text.gsub("\\", "\\\\\\").gsub("'", "\\\\'")}'"
+      end
+    else
+      'null'
+    end
+
     script = <<-JS
       if (typeof window.capybara  === 'undefined') {
         window.capybara = {
@@ -389,20 +379,20 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
       }
       window.capybara.add_handler(modal_handler);
 
-      window.alert = window.confirm = function(str) {
-        window.capybara.handler_called(modal_handler, str);
+      window.alert = window.confirm = function(str = "") {
+        window.capybara.handler_called(modal_handler, str.toString());
         return #{accept ? 'true' : 'false'};
-      };
-      window.prompt = function(str) {
-        window.capybara.handler_called(modal_handler, str);
-        return #{accept ? "'#{response_text}'" : 'null'};
+      }
+      window.prompt = function(str = "", default_text = "") {
+        window.capybara.handler_called(modal_handler, str.toString());
+        return #{prompt_response};
       }
     JS
     execute_script script
   end
 
   def within_given_window(handle)
-    original_handle = self.current_window_handle
+    original_handle = current_window_handle
     if handle == original_handle
       yield
     else
@@ -413,39 +403,41 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
     end
   end
 
-  def find_modal(options={})
+  def find_modal(text: nil, **options)
     # Selenium has its own built in wait (2 seconds)for a modal to show up, so this wait is really the minimum time
     # Actual wait time may be longer than specified
     wait = Selenium::WebDriver::Wait.new(
-      timeout: options.fetch(:wait, session_options.default_max_wait_time) || 0 ,
-      ignore: Selenium::WebDriver::Error::NoAlertPresentError)
+      timeout: options.fetch(:wait, session_options.default_max_wait_time) || 0,
+      ignore: modal_error
+    )
     begin
       wait.until do
         alert = @browser.switch_to.alert
-        regexp = options[:text].is_a?(Regexp) ? options[:text] : Regexp.escape(options[:text].to_s)
+        regexp = text.is_a?(Regexp) ? text : Regexp.escape(text.to_s)
         alert.text.match(regexp) ? alert : nil
       end
     rescue Selenium::WebDriver::Error::TimeOutError
-      raise Capybara::ModalNotFound.new("Unable to find modal dialog#{" with #{options[:text]}" if options[:text]}")
+      raise Capybara::ModalNotFound, "Unable to find modal dialog#{" with #{text}" if text}"
     end
   end
 
-  def find_headless_modal(options={})
+  def find_headless_modal(text: nil, **options)
     # Selenium has its own built in wait (2 seconds)for a modal to show up, so this wait is really the minimum time
     # Actual wait time may be longer than specified
     wait = Selenium::WebDriver::Wait.new(
-      timeout: options.fetch(:wait, session_options.default_max_wait_time) || 0 ,
-      ignore: Selenium::WebDriver::Error::NoAlertPresentError)
+      timeout: options.fetch(:wait, session_options.default_max_wait_time) || 0,
+      ignore: modal_error
+    )
     begin
       wait.until do
         called, alert_text = evaluate_script('window.capybara && window.capybara.current_modal_status()')
         if called
           execute_script('window.capybara && window.capybara.modal_handlers.shift()')
-          regexp = options[:text].is_a?(Regexp) ? options[:text] : Regexp.escape(options[:text].to_s)
+          regexp = text.is_a?(Regexp) ? text : Regexp.escape(text.to_s)
           if alert_text.match(regexp)
             alert_text
           else
-            raise Capybara::ModalNotFound.new("Unable to find modal dialog#{" with #{options[:text]}" if options[:text]}")
+            raise Capybara::ModalNotFound, "Unable to find modal dialog#{" with #{text}" if text}"
           end
         elsif called.nil?
           # page changed so modal_handler data has gone away
@@ -456,7 +448,7 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
         end
       end
     rescue Selenium::WebDriver::Error::TimeOutError
-      raise Capybara::ModalNotFound.new("Unable to find modal dialog#{" with #{options[:text]}" if options[:text]}")
+      raise Capybara::ModalNotFound, "Unable to find modal dialog#{" with #{options[:text]}" if options[:text]}"
     end
   end
 
@@ -465,7 +457,7 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
   end
 
   def silenced_unknown_error_messages
-    [ /Error communicating with the remote browser/ ]
+    [/Error communicating with the remote browser/]
   end
 
   def unwrap_script_result(arg)
@@ -480,4 +472,21 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
       arg
     end
   end
+
+  def load_selenium
+    require 'selenium-webdriver'
+    # Fix for selenium-webdriver 3.4.0 which misnamed these
+    unless defined?(::Selenium::WebDriver::Error::ElementNotInteractableError)
+      ::Selenium::WebDriver::Error.const_set('ElementNotInteractableError', Class.new(::Selenium::WebDriver::Error::WebDriverError))
+    end
+    unless defined?(::Selenium::WebDriver::Error::ElementClickInterceptedError)
+      ::Selenium::WebDriver::Error.const_set('ElementClickInterceptedError', Class.new(::Selenium::WebDriver::Error::WebDriverError))
+    end
+  rescue LoadError => e
+    if e.message =~ /selenium-webdriver/
+      raise LoadError, "Capybara's selenium driver is unable to load `selenium-webdriver`, please install the gem and add `gem 'selenium-webdriver'` to your Gemfile if you are using bundler."
+    else
+      raise e
+    end
+  end
 end