capybara 2.5.0 → 2.18.0

data/lib/capybara/selenium/node.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
 class Capybara::Selenium::Node < Capybara::Driver::Node
+
   def visible_text
     # Selenium doesn't normalize Unicode whitespace.
     Capybara::Helpers.normalize_whitespace(native.text)
   end
 
   def all_text
-    text = driver.browser.execute_script("return arguments[0].textContent", native)
+    text = driver.execute_script("return arguments[0].textContent", self)
     Capybara::Helpers.normalize_whitespace(text)
   end
 
@@ -16,77 +18,110 @@ class Capybara::Selenium::Node < Capybara::Driver::Node
   end
 
   def value
-    if tag_name == "select" and self[:multiple] and not self[:multiple] == "false"
-      native.find_elements(:xpath, ".//option").select { |n| n.selected? }.map { |n| n[:value] || n.text }
+    if tag_name == "select" and multiple?
+      native.find_elements(:css, "option:checked").map { |n| n[:value] || n.text }
     else
       native[:value]
     end
   end
 
-  def set(value, fill_options={})
+  ##
+  #
+  # Set the value of the form element to the given value.
+  #
+  # @param [String] value    The new value
+  # @param [Hash{}] options  Driver specific options for how to set the value
+  # @option options [Symbol,Array] :clear (nil) The method used to clear the previous value <br/>
+  #   nil => clear via javascript <br/>
+  #   :none =>  append the new value to the existing value <br/>
+  #   :backspace => send backspace keystrokes to clear the field <br/>
+  #   Array => an array of keys to send before the value being set, e.g. [[:command, 'a'], :backspace]
+  def set(value, options={})
     tag_name = self.tag_name
     type = self[:type]
-    if (Array === value) && !self[:multiple]
+
+    if (Array === value) && !multiple?
       raise ArgumentError.new "Value cannot be an Array when 'multiple' attribute is not present. Not a #{value.class}"
     end
-    if tag_name == 'input' and type == 'radio'
-      click
-    elsif tag_name == 'input' and type == 'checkbox'
-      click if value ^ native.attribute('checked').to_s.eql?("true")
-    elsif tag_name == 'input' and type == 'file'
-      path_names = value.to_s.empty? ? [] : value
-      native.send_keys(*path_names)
-    elsif tag_name == 'textarea' or tag_name == 'input'
-      if self[:readonly]
-        warn "Attempt to set readonly element with value: #{value} \n *This will raise an exception in a future version of Capybara"
-      elsif value.to_s.empty?
-        native.clear
+
+    case tag_name
+    when 'input'
+      case type
+      when 'radio'
+        click
+      when 'checkbox'
+        click if value ^ native.attribute('checked').to_s.eql?("true")
+      when 'file'
+        path_names = value.to_s.empty? ? [] : value
+        if driver.chrome?
+          native.send_keys(Array(path_names).join("\n"))
+        else
+          native.send_keys(*path_names)
+        end
       else
-        if fill_options[:clear] == :backspace
-          # Clear field by sending the correct number of backspace keys.
-          backspaces = [:backspace] * self.value.to_s.length
-          native.send_keys(*(backspaces + [value.to_s]))
+        set_text(value, options)
+      end
+    when 'textarea'
+      set_text(value, options)
+    else
+      if content_editable?
+        #ensure we are focused on the element
+        click
+
+        script = <<-JS
+          var range = document.createRange();
+          var sel = window.getSelection();
+          arguments[0].focus();
+          range.selectNodeContents(arguments[0]);
+          sel.removeAllRanges();
+          sel.addRange(range);
+        JS
+        driver.execute_script script, self
+
+        if driver.chrome? || driver.firefox?
+          # chromedriver raises a can't focus element for child elements if we use native.send_keys
+          # we've already focused it so just use action api
+          driver.browser.action.send_keys(value.to_s).perform
         else
-          # Clear field by JavaScript assignment of the value property.
-          # Script can change a readonly element which user input cannot, so
-          # don't execute if readonly.
-          driver.browser.execute_script "arguments[0].value = ''", native
+          # action api is really slow here just use native.send_keys
           native.send_keys(value.to_s)
         end
       end
-    elsif native.attribute('isContentEditable')
-      #ensure we are focused on the element
-      script = <<-JS
-        var range = document.createRange();
-        range.selectNodeContents(arguments[0]);
-        window.getSelection().addRange(range);
-      JS
-      driver.browser.execute_script script, native
-      native.send_keys(value.to_s)
     end
   end
 
   def select_option
-    native.click unless selected?
+    native.click unless selected? || disabled?
   end
 
   def unselect_option
-    if select_node['multiple'] != 'multiple' and select_node['multiple'] != 'true'
-      raise Capybara::UnselectNotAllowed, "Cannot unselect option from single select box."
-    end
+    raise Capybara::UnselectNotAllowed, "Cannot unselect option from single select box." if !select_node.multiple?
     native.click if selected?
   end
 
   def click
     native.click
+  rescue => e
+    if e.is_a?(::Selenium::WebDriver::Error::ElementClickInterceptedError) ||
+       e.message =~ /Other element would receive the click/
+      begin
+        driver.execute_script("arguments[0].scrollIntoView({behavior: 'instant', block: 'center', inline: 'center'})", self)
+      rescue
+      end
+    end
+    raise e
   end
 
   def right_click
-    driver.browser.action.context_click(native).perform
+    scroll_if_needed do
+      driver.browser.action.context_click(native).perform
+    end
   end
 
   def double_click
-    driver.browser.action.double_click(native).perform
+    scroll_if_needed do
+      driver.browser.action.double_click(native).perform
+    end
   end
 
   def send_keys(*args)
@@ -94,11 +129,15 @@ class Capybara::Selenium::Node < Capybara::Driver::Node
   end
 
   def hover
-    driver.browser.action.move_to(native).perform
+    scroll_if_needed do
+      driver.browser.action.move_to(native).perform
+    end
   end
 
   def drag_to(element)
-    driver.browser.action.drag_and_drop(native, element.native).perform
+    scroll_if_needed do
+      driver.browser.action.drag_and_drop(native, element.native).perform
+    end
   end
 
   def tag_name
@@ -114,12 +153,34 @@ class Capybara::Selenium::Node < Capybara::Driver::Node
     selected = native.selected?
     selected and selected != "false"
   end
+  alias :checked? :selected?
 
   def disabled?
-    !native.enabled?
+    # workaround for selenium-webdriver/geckodriver reporting elements as enabled when they are nested in disabling elements
+    if driver.marionette?
+      if %w(option optgroup).include? tag_name
+        !native.enabled? || find_xpath("parent::*[self::optgroup or self::select]")[0].disabled?
+      else
+        !native.enabled? || !find_xpath("parent::fieldset[@disabled] | ancestor::*[not(self::legend) or preceding-sibling::legend][parent::fieldset[@disabled]]").empty?
+      end
+    else
+      !native.enabled?
+    end
   end
 
-  alias :checked? :selected?
+  def readonly?
+    readonly = self[:readonly]
+    readonly and readonly != "false"
+  end
+
+  def multiple?
+    multiple = self[:multiple]
+    multiple and multiple != "false"
+  end
+
+  def content_editable?
+    native.attribute('isContentEditable')
+  end
 
   def find_xpath(locator)
     native.find_elements(:xpath, locator).map { |n| self.class.new(driver, n) }
@@ -158,9 +219,46 @@ class Capybara::Selenium::Node < Capybara::Driver::Node
   end
 
 private
-
   # a reference to the select node if this is an option node
   def select_node
-    find_xpath('./ancestor::select').first
+    find_xpath('./ancestor::select[1]').first
+  end
+
+  def set_text(value, options)
+    if readonly?
+      warn "Attempt to set readonly element with value: #{value} \n *This will raise an exception in a future version of Capybara"
+    elsif value.to_s.empty? && options[:clear].nil?
+      native.clear
+    else
+      if options[:clear] == :backspace
+        # Clear field by sending the correct number of backspace keys.
+        backspaces = [:backspace] * self.value.to_s.length
+        native.send_keys(*(backspaces + [value.to_s]))
+      elsif options[:clear] == :none
+        native.send_keys(value.to_s)
+      elsif options[:clear].is_a? Array
+        native.send_keys(*options[:clear], value.to_s)
+      else
+        # Clear field by JavaScript assignment of the value property.
+        # Script can change a readonly element which user input cannot, so
+        # don't execute if readonly.
+        driver.execute_script "arguments[0].value = ''", self
+        native.send_keys(value.to_s)
+      end
+    end
+  end
+
+  def scroll_if_needed(&block)
+    block.call
+  rescue ::Selenium::WebDriver::Error::MoveTargetOutOfBoundsError
+    script = <<-JS
+      try {
+        arguments[0].scrollIntoView({behavior: 'instant', block: 'center', inline: 'center'});
+      } catch(e) {
+        arguments[0].scrollIntoView(true);
+      }
+    JS
+    driver.execute_script(script, self)
+    block.call
   end
 end

data/lib/capybara/server.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'uri'
 require 'net/http'
 require 'rack'
@@ -5,21 +6,47 @@ require 'rack'
 module Capybara
   class Server
     class Middleware
+      class Counter
+        attr_reader :value
+
+        def initialize
+          @value = 0
+          @mutex = Mutex.new
+        end
+
+        def increment
+          @mutex.synchronize { @value += 1 }
+        end
+
+        def decrement
+          @mutex.synchronize { @value -= 1 }
+        end
+      end
+
       attr_accessor :error
 
-      def initialize(app)
+      def initialize(app, server_errors)
         @app = app
+        @counter = Counter.new
+        @server_errors = server_errors
+      end
+
+      def pending_requests?
+        @counter.value > 0
       end
 
       def call(env)
         if env["PATH_INFO"] == "/__identify__"
           [200, {}, [@app.object_id.to_s]]
         else
+          @counter.increment
           begin
             @app.call(env)
-          rescue *Capybara.server_errors => e
+          rescue *@server_errors => e
             @error = e unless @error
             raise e
+          ensure
+            @counter.decrement
           end
         end
       end
@@ -33,41 +60,46 @@ module Capybara
 
     attr_reader :app, :port, :host
 
-    def initialize(app, port=Capybara.server_port, host=Capybara.server_host)
+    def initialize(app, port=Capybara.server_port, host=Capybara.server_host, server_errors=Capybara.server_errors)
       @app = app
-      @middleware = Middleware.new(@app)
       @server_thread = nil # suppress warnings
-      @host, @port = host, port
-      @port ||= Capybara::Server.ports[@app.object_id]
-      @port ||= find_available_port
+      @host, @port, @server_errors = host, port, server_errors
+      @port ||= Capybara::Server.ports[port_key]
+      @port ||= find_available_port(host)
     end
 
     def reset_error!
-      @middleware.error = nil
+      middleware.error = nil
     end
 
     def error
-      @middleware.error
+      middleware.error
     end
 
     def responsive?
       return false if @server_thread && @server_thread.join(0)
 
-      res = Net::HTTP.start(host, @port) { |http| http.get('/__identify__') }
+      res = Net::HTTP.start(host, port) { |http| http.get('/__identify__') }
 
       if res.is_a?(Net::HTTPSuccess) or res.is_a?(Net::HTTPRedirection)
-        return res.body == @app.object_id.to_s
+        return res.body == app.object_id.to_s
       end
     rescue SystemCallError
       return false
     end
 
+    def wait_for_pending_requests
+      Timeout.timeout(60) { sleep(0.01) while pending_requests? }
+    rescue Timeout::Error
+      raise "Requests did not finish in 60 seconds"
+    end
+
     def boot
       unless responsive?
-        Capybara::Server.ports[@app.object_id] = @port
+        Capybara::Server.ports[port_key] = port
 
         @server_thread = Thread.new do
-          Capybara.server.call(@middleware, @port)
+          Capybara.server.call(middleware, port, host)
         end
 
         Timeout.timeout(60) { @server_thread.join(0.1) until responsive? }
@@ -80,12 +112,23 @@ module Capybara
 
   private
 
-    def find_available_port
-      server = TCPServer.new('127.0.0.1', 0)
+    def middleware
+      @middleware ||= Middleware.new(app, @server_errors)
+    end
+
+    def port_key
+      Capybara.reuse_server ? app.object_id : middleware.object_id
+    end
+
+    def pending_requests?
+      middleware.pending_requests?
+    end
+
+    def find_available_port(host)
+      server = TCPServer.new(host, 0)
       server.addr[1]
     ensure
       server.close if server
     end
-
   end
 end

data/lib/capybara/session/config.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+require 'delegate'
+
+module Capybara
+  class SessionConfig
+    OPTIONS = [:always_include_port, :run_server, :default_selector, :default_max_wait_time, :ignore_hidden_elements,
+               :automatic_reload, :match, :exact, :exact_text, :raise_server_errors, :visible_text_only, :wait_on_first_by_default,
+               :automatic_label_click, :enable_aria_label, :save_path, :exact_options, :asset_host, :default_host, :app_host,
+               :save_and_open_page_path, :server_host, :server_port, :server_errors]
+
+    attr_accessor(*OPTIONS)
+
+    ##
+    #@!method always_include_port
+    #  See {Capybara.configure}
+    #@!method run_server
+    #  See {Capybara.configure}
+    #@!method default_selector
+    #  See {Capybara.configure}
+    #@!method default_max_wait_time
+    #  See {Capybara.configure}
+    #@!method ignore_hidden_elements
+    #  See {Capybara.configure}
+    #@!method automatic_reload
+    #  See {Capybara.configure}
+    #@!method match
+    #  See {Capybara.configure}
+    #@!method exact
+    #  See {Capybara.configure}
+    #@!method raise_server_errors
+    #  See {Capybara.configure}
+    #@!method visible_text_only
+    #  See {Capybara.configure}
+    #@!method wait_on_first_by_default
+    #  See {Capybara.configure}
+    #@!method automatic_label_click
+    #  See {Capybara.configure}
+    #@!method enable_aria_label
+    #  See {Capybara.configure}
+    #@!method save_path
+    #  See {Capybara.configure}
+    #@deprecated
+    #@!method exact_options
+    #  See {Capybara.configure}
+    #@!method asset_host
+    #  See {Capybara.configure}
+    #@!method default_host
+    #  See {Capybara.configure}
+    #@!method app_host
+    #  See {Capybara.configure}
+    #@!method save_and_open_page_path
+    #  See {Capybara.configure}
+    #@!method server_host
+    #  See {Capybara.configure}
+    #@!method server_port
+    #  See {Capybara.configure}
+    #@!method server_errors
+    #  See {Capybara.configure}
+
+    remove_method :server_host
+
+    ##
+    #
+    # @return [String]    The IP address bound by default server
+    #
+    def server_host
+      @server_host || '127.0.0.1'
+    end
+
+    remove_method :server_errors=
+    def server_errors=(errors)
+      (@server_errors ||= []).replace(errors.dup)
+    end
+
+    remove_method :app_host=
+    def app_host=(url)
+      raise ArgumentError.new("Capybara.app_host should be set to a url (http://www.example.com)") unless url.nil? || (url =~ URI::Parser.new.make_regexp)
+      @app_host = url
+    end
+
+    remove_method :default_host=
+    def default_host=(url)
+      raise ArgumentError.new("Capybara.default_host should be set to a url (http://www.example.com)") unless url.nil? || (url =~ URI::Parser.new.make_regexp)
+      @default_host = url
+    end
+
+    remove_method :save_and_open_page_path=
+    def save_and_open_page_path=(path)
+      warn "DEPRECATED: #save_and_open_page_path is deprecated, please use #save_path instead. \n"\
+           "Note: Behavior is slightly different with relative paths - see documentation" unless path.nil?
+      @save_and_open_page_path = path
+    end
+
+    remove_method :exact_options=
+    def exact_options=(opt)
+      @exact_options = opt
+      warn "DEPRECATED: #exact_options is deprecated, please scope your findes/actions and use the `:exact` "\
+           "option if similar functionality is needed."
+    end
+
+    def initialize_copy(other)
+      super
+      @server_errors = @server_errors.dup
+    end
+  end
+
+  class ReadOnlySessionConfig < SimpleDelegator
+    SessionConfig::OPTIONS.each do |m|
+      define_method "#{m}=" do |val|
+        raise "Per session settings are only supported when Capybara.threadsafe == true"
+      end
+    end
+  end
+end

data/lib/capybara/session/matchers.rb

@@ -1,49 +1,46 @@
+# frozen_string_literal: true
 module Capybara
   module SessionMatchers
     ##
     # Asserts that the page has the given path.
-    # By default this will compare against the path+query portion of the full url
+    # By default, if passed a full url this will compare against the full url,
+    # if passed a path only the path+query portion will be compared, if passed a regexp
+    # the comparison will depend on the :url option
     #
     # @!macro current_path_query_params
     #   @overload $0(string, options = {})
     #     @param string [String]           The string that the current 'path' should equal
     #   @overload $0(regexp, options = {})
     #     @param regexp [Regexp]           The regexp that the current 'path' should match to
-    #   @option options [Numeric] :wait (Capybara.default_max_wait_time) Maximum time that Capybara will wait for the current path to eq/match given string/regexp argument
-    #   @option options [Boolean] :url  (false)  Whether the compare should be done against the full url
-    #   @option options [Boolean] :only_path (false)  Whether the compare should be done against just the path protion of the url
+    #   @option options [Boolean] :url (true if `string` ia a full url, otherwise false) Whether the compare should be done against the full current url or just the path
+    #   @option options [Boolean] :ignore_query (false)  Whether the query portion of the current url/path should be ignored
+    #   @option options [Numeric] :wait (Capybara.default_max_wait_time) Maximum time that Capybara will wait for the current url/path to eq/match given string/regexp argument
     # @raise [Capybara::ExpectationNotMet] if the assertion hasn't succeeded during wait time
     # @return [true]
     #
     def assert_current_path(path, options={})
-      query = Capybara::Queries::CurrentPathQuery.new(path, options)
-      document.synchronize(query.wait) do
-        unless query.resolves_for?(self)
-          raise Capybara::ExpectationNotMet, query.failure_message
-        end
-      end
-      return true
+      _verify_current_path(path,options) { |query| raise Capybara::ExpectationNotMet, query.failure_message unless query.resolves_for?(self) }
     end
 
     ##
     # Asserts that the page doesn't have the given path.
+    # By default, if passed a full url this will compare against the full url,
+    # if passed a path only the path+query portion will be compared, if passed a regexp
+    # the comparison will depend on the :url option
     #
     # @macro current_path_query_params
     # @raise [Capybara::ExpectationNotMet] if the assertion hasn't succeeded during wait time
     # @return [true]
     #
     def assert_no_current_path(path, options={})
-      query = Capybara::Queries::CurrentPathQuery.new(path, options)
-      document.synchronize(query.wait) do
-        if query.resolves_for?(self)
-          raise Capybara::ExpectationNotMet, query.negative_failure_message
-        end
-      end
-      return true
+      _verify_current_path(path,options) { |query| raise Capybara::ExpectationNotMet, query.negative_failure_message if query.resolves_for?(self) }
     end
 
     ##
     # Checks if the page has the given path.
+    # By default, if passed a full url this will compare against the full url,
+    # if passed a path only the path+query portion will be compared, if passed a regexp
+    # the comparison will depend on the :url option
     #
     # @macro current_path_query_params
     # @return [Boolean]
@@ -56,6 +53,9 @@ module Capybara
 
     ##
     # Checks if the page doesn't have the given path.
+    # By default, if passed a full url this will compare against the full url,
+    # if passed a path only the path+query portion will be compared, if passed a regexp
+    # the comparison will depend on the :url option
     #
     # @macro current_path_query_params
     # @return [Boolean]
@@ -65,5 +65,15 @@ module Capybara
     rescue Capybara::ExpectationNotMet
       return false
     end
+
+    private
+
+    def _verify_current_path(path, options)
+      query = Capybara::Queries::CurrentPathQuery.new(path, options)
+      document.synchronize(query.wait) do
+        yield(query)
+      end
+      return true
+    end
   end
-end
+end