capybara 2.5.0 → 2.18.0

data/lib/capybara/selenium/driver.rb

@@ -1,17 +1,29 @@
+# frozen_string_literal: true
 require "uri"
 
 class Capybara::Selenium::Driver < Capybara::Driver::Base
+
   DEFAULT_OPTIONS = {
-    :browser => :firefox
+    :browser => :firefox,
+    clear_local_storage: false,
+    clear_session_storage: false
   }
-  SPECIAL_OPTIONS = [:browser]
+  SPECIAL_OPTIONS = [:browser, :clear_local_storage, :clear_session_storage]
 
   attr_reader :app, :options
 
   def browser
     unless @browser
-      @browser = Selenium::WebDriver.for(options[:browser], options.reject { |key,val| SPECIAL_OPTIONS.include?(key) })
+      if firefox?
+        options[:desired_capabilities] ||= {}
+        options[:desired_capabilities].merge!({ unexpectedAlertBehaviour: "ignore" })
+      end
 
+      @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...
@@ -24,16 +36,8 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
   end
 
   def initialize(app, options={})
-    begin
-      require 'selenium-webdriver'
-    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
-
+    load_selenium
+    @session = nil
     @app = app
     @browser = nil
     @exit_status = nil
@@ -45,6 +49,13 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
     browser.navigate.to(path)
   end
 
+  def refresh
+    accept_modal(nil, wait: 0.1) do
+      browser.navigate.refresh
+    end
+  rescue Capybara::ModalNotFound
+  end
+
   def go_back
     browser.navigate.back
   end
@@ -76,36 +87,72 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
   def wait?; true; end
   def needs_server?; true; end
 
-  def execute_script(script)
-    browser.execute_script script
+  def execute_script(script, *args)
+    browser.execute_script(script, *args.map { |arg| arg.is_a?(Capybara::Selenium::Node) ?  arg.native : arg} )
   end
 
-  def evaluate_script(script)
-    browser.execute_script "return #{script}"
+  def evaluate_script(script, *args)
+    result = execute_script("return #{script}", *args)
+    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
       begin
-        begin @browser.manage.delete_all_cookies
-        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 !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
+            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.
+          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
-        @browser.navigate.to("about:blank")
-      rescue Selenium::WebDriver::Error::UnhandledAlertError
+      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
-        rescue Selenium::WebDriver::Error::NoAlertPresentError
+          sleep 0.25 # allow time for the modal to be handled
+        rescue modal_error
           # The alert is now gone - nothing to do
         end
         # try cleaning up the browser again
@@ -114,35 +161,21 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
     end
   end
 
-  ##
-  #
-  # Webdriver supports frame name, id, index(zero-based) or {Capybara::Node::Element} to find iframe
-  #
-  # @overload within_frame(index)
-  #   @param [Integer] index                 index of a frame
-  # @overload within_frame(name_or_id)
-  #   @param [String] name_or_id             name or id of a frame
-  # @overload within_frame(element)
-  #   @param [Capybara::Node::Base] a_node   frame element
-  #
-  def within_frame(frame_handle)
-    frame_handle = frame_handle.native if frame_handle.is_a?(Capybara::Node::Base)
-    if !browser.switch_to.respond_to?(:parent_frame)
-      # Selenium Webdriver < 2.43 doesnt support moving back to the parent
-      @frame_handles[browser.window_handle] ||= []
-      @frame_handles[browser.window_handle] << frame_handle
-    end
-    browser.switch_to.frame(frame_handle)
-    yield
-  ensure
-    if browser.switch_to.respond_to?(:parent_frame)
-      browser.switch_to.parent_frame
-    else
-      # There doesnt appear to be any way in Selenium Webdriver < 2.43 to move back to a parent frame
-      # other than going back to the root and then reiterating down
+  def switch_to_frame(frame)
+    case frame
+    when :top
+      @frame_handles[browser.window_handle] = []
+      browser.switch_to.default_content
+    when :parent
+      # would love to use browser.switch_to.parent_frame here
+      # but it has an issue if the current frame is removed from within it
       @frame_handles[browser.window_handle].pop
       browser.switch_to.default_content
       @frame_handles[browser.window_handle].each { |fh| browser.switch_to.frame(fh) }
+    else
+      @frame_handles[browser.window_handle] ||= []
+      @frame_handles[browser.window_handle] << frame.native
+      browser.switch_to.frame(frame.native)
     end
   end
 
@@ -159,7 +192,12 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
 
   def resize_window_to(handle, width, height)
     within_given_window(handle) do
-      browser.manage.window.resize_to(width, height)
+      # Don't set the size if already set - See https://github.com/mozilla/geckodriver/issues/643
+      if marionette? && (window_size(handle) == [width, height])
+        {}
+      else
+        browser.manage.window.resize_to(width, height)
+      end
     end
   end
 
@@ -188,39 +226,23 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
     browser.switch_to.window handle
   end
 
-  # @api private
-  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
-      end
-    end
-    raise Capybara::ElementNotFound, "Could not find a window identified by #{locator}"
-  end
-
   def within_window(locator)
     handle = find_window(locator)
     browser.switch_to.window(handle) { yield }
   end
 
-  def accept_modal(type, options={}, &blk)
+  def accept_modal(_type, options={})
     yield if block_given?
     modal = find_modal(options)
+
     modal.send_keys options[:with] if options[:with]
+
     message = modal.text
     modal.accept
     message
   end
 
-  def dismiss_modal(type, options={}, &blk)
+  def dismiss_modal(_type, options={})
     yield if block_given?
     modal = find_modal(options)
     message = modal.text
@@ -230,29 +252,139 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
 
   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
+      # probably already gone but not sure - so warn
+      warn "Ignoring Selenium UnknownError during driver quit: #{e.message}"
+    end
   ensure
     @browser = nil
   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::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,
+    ]
   end
 
   def no_such_window_error
     Selenium::WebDriver::Error::NoSuchWindowError
   end
 
+  # @api private
+  def marionette?
+    firefox? && browser && @w3c
+  end
+
+  # @api private
+  def firefox?
+    browser_name == "firefox"
+  end
+
+  # @api private
+  def chrome?
+    browser_name == "chrome"
+  end
+
+  # @deprecated This method is being removed
   def browser_initialized?
-    !@browser.nil?
+    super && !@browser.nil?
   end
 
   private
 
+  # @api private
+  def browser_name
+    options[:browser].to_s
+  end
+
+  def modal_error
+    if defined?(Selenium::WebDriver::Error::NoSuchAlertError)
+      Selenium::WebDriver::Error::NoSuchAlertError
+    else
+      Selenium::WebDriver::Error::NoAlertPresentError
+    end
+  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
+      end
+    end
+    raise Capybara::ElementNotFound, "Could not find a window identified by #{locator}"
+  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 = {
+          modal_handlers: [],
+          current_modal_status: function() {
+            return [this.modal_handlers[0].called, this.modal_handlers[0].modal_text];
+          },
+          add_handler: function(handler) {
+            this.modal_handlers.unshift(handler);
+          },
+          remove_handler: function(handler) {
+            window.alert = handler.alert;
+            window.confirm = handler.confirm;
+            window.prompt = handler.prompt;
+          },
+          handler_called: function(handler, str) {
+            handler.called = true;
+            handler.modal_text = str;
+            this.remove_handler(handler);
+          }
+        };
+      };
+
+      var modal_handler = {
+        prompt: window.prompt,
+        confirm: window.confirm,
+        alert: window.alert,
+        called: false
+      }
+      window.capybara.add_handler(modal_handler);
+
+      window.alert = window.confirm = function(str = "") {
+        window.capybara.handler_called(modal_handler, str.toString());
+        return #{accept ? 'true' : 'false'};
+      }
+      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
     if handle == original_handle
@@ -269,8 +401,8 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
     # 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[:wait] || Capybara.default_max_wait_time),
-      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
@@ -282,4 +414,73 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
     end
   end
 
+  def find_headless_modal(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: 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)
+          if alert_text.match(regexp)
+            alert_text
+          else
+            raise Capybara::ModalNotFound.new("Unable to find modal dialog#{" with #{options[:text]}" if options[:text]}")
+          end
+        elsif called.nil?
+          # page changed so modal_handler data has gone away
+          warn "Can't verify modal text when page change occurs - ignoring" if options[:text]
+          ""
+        else
+          nil
+        end
+      end
+    rescue Selenium::WebDriver::Error::TimeOutError
+      raise Capybara::ModalNotFound.new("Unable to find modal dialog#{" with #{options[:text]}" if options[:text]}")
+    end
+  end
+
+  def silenced_unknown_error_message?(msg)
+    silenced_unknown_error_messages.any? { |r| msg =~ r }
+  end
+
+  def silenced_unknown_error_messages
+    [ /Error communicating with the remote browser/ ]
+  end
+
+  def unwrap_script_result(arg)
+    case arg
+    when Array
+      arg.map { |e| unwrap_script_result(e) }
+    when Hash
+      arg.each { |k, v| arg[k] = unwrap_script_result(v) }
+    when Selenium::WebDriver::Element
+      Capybara::Selenium::Node.new(self, arg)
+    else
+      arg
+    end
+  end
+
+  def load_selenium
+    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
+  end
 end