capybara 2.6.1 → 2.7.0

data/lib/capybara/selector/filter.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+module Capybara
+  class Selector
+    class Filter
+      def initialize(name, block, options={})
+        @name = name
+        @block = block
+        @options = options
+        @options[:valid_values] = [true,false] if options[:boolean]
+      end
+
+      def default?
+        @options.has_key?(:default)
+      end
+
+      def default
+        @options[:default]
+      end
+
+      def matches?(node, value)
+        return true if skip?(value)
+
+        if !valid_value?(value)
+          msg = "Invalid value #{value.inspect} passed to filter #{@name} - "
+          if default?
+            warn msg + "defaulting to #{default}"
+            value = default
+          else
+            warn msg + "skipping"
+            return true
+          end
+        end
+
+        @block.call(node, value)
+      end
+
+      def skip?(value)
+        @options.has_key?(:skip_if) && value == @options[:skip_if]
+      end
+
+      private
+
+      def valid_value?(value)
+        !@options.has_key?(:valid_values) || Array(@options[:valid_values]).include?(value)
+      end
+    end
+  end
+end

data/lib/capybara/selector.rb

@@ -1,42 +1,8 @@
+# frozen_string_literal: true
+require 'capybara/selector/filter'
+
 module Capybara
   class Selector
-    class Filter
-      def initialize(name, block, options={})
-        @name = name
-        @block = block
-        @options = options
-        @options[:valid_values] = [true,false] if options[:boolean]
-      end
-
-      def default?
-        @options.has_key?(:default)
-      end
-
-      def default
-        @options[:default]
-      end
-
-      def matches?(node, value)
-        return true if skip?(value)
-
-        if @options.has_key?(:valid_values) && !Array(@options[:valid_values]).include?(value)
-          msg = "Invalid value #{value.inspect} passed to filter #{@name} - "
-          if default?
-            warn msg + "defaulting to #{default}"
-            value = default
-          else
-            warn msg + "skipping"
-            return true
-          end
-        end
-
-        @block.call(node, value)
-      end
-
-      def skip?(value)
-        @options.has_key?(:skip_if) && value == @options[:skip_if]
-      end
-    end
 
     attr_reader :name, :custom_filters, :format
 
@@ -65,24 +31,19 @@ module Capybara
       @label = nil
       @failure_message = nil
       @description = nil
+      @format = nil
+      @expression = nil
       instance_eval(&block)
     end
 
     def xpath(&block)
-      if block
-        @format = :xpath
-        @xpath, @css = block, nil
-      end
-      @xpath
+      @format, @expression = :xpath, block if block
+      format == :xpath ? @expression : nil
     end
 
-    # Same as xpath, but wrap in XPath.css().
     def css(&block)
-      if block
-        @format = :css
-        @css, @xpath = block, nil
-      end
-      @css
+      @format, @expression = :css, block if block
+      format == :css ? @expression : nil
     end
 
     def match(&block)
@@ -100,10 +61,10 @@ module Capybara
     end
 
     def call(locator)
-      if @format==:css
-        @css.call(locator)
+      if format
+        @expression.call(locator)
       else
-        @xpath.call(locator)
+        warn "Selector has no format"
       end
     end
 
@@ -118,6 +79,17 @@ module Capybara
     def describe &block
       @description = block
     end
+
+    private
+
+    def locate_field(xpath, locator)
+      locate_field = xpath[XPath.attr(:id).equals(locator) |
+                           XPath.attr(:name).equals(locator) |
+                           XPath.attr(:placeholder).equals(locator) |
+                           XPath.attr(:id).equals(XPath.anywhere(:label)[XPath.string.n.is(locator)].attr(:for))]
+      locate_field += XPath.descendant(:label)[XPath.string.n.is(locator)].descendant(xpath)
+      locate_field
+    end
   end
 end
 
@@ -134,7 +106,11 @@ Capybara.add_selector(:id) do
 end
 
 Capybara.add_selector(:field) do
-  xpath { |locator| XPath::HTML.field(locator) }
+  xpath do |locator|
+    xpath = XPath.descendant(:input, :textarea, :select)[~XPath.attr(:type).one_of('submit', 'image', 'hidden')]
+    xpath = locate_field(xpath, locator.to_s) unless locator.nil?
+    xpath
+  end
   filter(:checked, boolean: true) { |node, value| not(value ^ node.checked?) }
   filter(:unchecked, boolean: true) { |node, value| (value ^ node.checked?) }
   filter(:disabled, default: false, boolean: true, skip_if: :all) { |node, value| not(value ^ node.disabled?) }
@@ -147,31 +123,42 @@ Capybara.add_selector(:field) do
       node[:type] == type
     end
   end
+  filter(:multiple, boolean: true) { |node, value| !(value ^ node[:multiple]) }
   describe do |options|
-    desc, states = "", []
+    desc, states = String.new, []
     desc << " of type #{options[:type].inspect}" if options[:type]
     desc << " with value #{options[:with].to_s.inspect}" if options.has_key?(:with)
     states << 'checked' if options[:checked] || (options.has_key?(:unchecked) && !options[:unchecked])
     states << 'not checked' if options[:unchecked] || (options.has_key?(:checked) && !options[:checked])
     states << 'disabled' if options[:disabled] == true
     desc << " that is #{states.join(' and ')}" unless states.empty?
+    desc << " with the multiple attribute" if options[:multiple] == true
+    desc << " without the multiple attribute" if options[:multiple] === false
     desc
   end
 end
 
 Capybara.add_selector(:fieldset) do
-  xpath { |locator| XPath::HTML.fieldset(locator) }
-end
-
-Capybara.add_selector(:link_or_button) do
-  label "link or button"
-  xpath { |locator| XPath::HTML.link_or_button(locator) }
-  filter(:disabled, default: false, boolean: true) { |node, value| node.tag_name == "a" or not(value ^ node.disabled?) }
-  describe { |options| " that is disabled" if options[:disabled] }
+  xpath do |locator|
+    xpath = XPath.descendant(:fieldset)
+    xpath = xpath[XPath.attr(:id).equals(locator.to_s) | XPath.child(:legend)[XPath.string.n.is(locator.to_s)]] unless locator.nil?
+    xpath
+  end
 end
 
 Capybara.add_selector(:link) do
-  xpath { |locator| XPath::HTML.link(locator) }
+  xpath do |locator|
+    xpath = XPath.descendant(:a)[XPath.attr(:href)]
+    unless locator.nil?
+      locator = locator.to_s
+      xpath = xpath[XPath.attr(:id).equals(locator) |
+                    XPath.string.n.is(locator) |
+                    XPath.attr(:title).is(locator) |
+                    XPath.descendant(:img)[XPath.attr(:alt).is(locator)]]
+    end
+    xpath
+  end
+
   filter(:href) do |node, href|
     if href.is_a? Regexp
       node[:href].match href
@@ -179,31 +166,77 @@ Capybara.add_selector(:link) do
       node.first(:xpath, XPath.axis(:self)[XPath.attr(:href).equals(href.to_s)], minimum: 0)
     end
   end
+
   describe { |options| " with href #{options[:href].inspect}" if options[:href] }
 end
 
 Capybara.add_selector(:button) do
-  xpath { |locator| XPath::HTML.button(locator) }
+  xpath do |locator|
+    input_btn_xpath = XPath.descendant(:input)[XPath.attr(:type).one_of('submit', 'reset', 'image', 'button')]
+    btn_xpath = XPath.descendant(:button)
+    image_btn_xpath = XPath.descendant(:input)[XPath.attr(:type).equals('image')]
+
+    unless locator.nil?
+      locator = locator.to_s
+      input_btn_xpath = input_btn_xpath[XPath.attr(:id).equals(locator) | XPath.attr(:value).is(locator) | XPath.attr(:title).is(locator)]
+      btn_xpath = btn_xpath[XPath.attr(:id).equals(locator) | XPath.attr(:value).is(locator) | XPath.string.n.is(locator) | XPath.attr(:title).is(locator)]
+      image_btn_xpath = image_btn_xpath[XPath.attr(:alt).is(locator)]
+    end
+
+    input_btn_xpath + btn_xpath + image_btn_xpath
+  end
+
   filter(:disabled, default: false, boolean: true, skip_if: :all) { |node, value| not(value ^ node.disabled?) }
+
   describe { |options| " that is disabled" if options[:disabled] == true }
 end
 
+Capybara.add_selector(:link_or_button) do
+  label "link or button"
+  xpath do |locator|
+    self.class.all.values_at(:link, :button).map {|selector| selector.xpath.call(locator)}.reduce(:+)
+  end
+
+  filter(:disabled, default: false, boolean: true) { |node, value| node.tag_name == "a" or not(value ^ node.disabled?) }
+
+  describe { |options| " that is disabled" if options[:disabled] }
+end
+
 Capybara.add_selector(:fillable_field) do
   label "field"
-  xpath { |locator| XPath::HTML.fillable_field(locator) }
+  xpath do |locator|
+    xpath = XPath.descendant(:input, :textarea)[~XPath.attr(:type).one_of('submit', 'image', 'radio', 'checkbox', 'hidden', 'file')]
+    xpath = locate_field(xpath, locator.to_s) unless locator.nil?
+    xpath
+  end
+
   filter(:disabled, default: false, boolean: true, skip_if: :all) { |node, value| not(value ^ node.disabled?) }
-  describe { |options| " that is disabled" if options[:disabled] == true }
+  filter(:multiple, boolean: true) { |node, value| !(value ^ node[:multiple]) }
+
+  describe do |options|
+    desc = String.new
+    desc << " that is disabled" if options[:disabled] == true
+    desc << " with the multiple attribute" if options[:multiple] == true
+    desc << " without the multiple attribute" if options[:multiple] === false
+    desc
+  end
 end
 
 Capybara.add_selector(:radio_button) do
   label "radio button"
-  xpath { |locator| XPath::HTML.radio_button(locator) }
+  xpath do |locator|
+    xpath = XPath.descendant(:input)[XPath.attr(:type).equals('radio')]
+    xpath = locate_field(xpath, locator.to_s) unless locator.nil?
+    xpath
+  end
+
   filter(:checked, boolean: true) { |node, value| not(value ^ node.checked?) }
   filter(:unchecked, boolean: true) { |node, value| (value ^ node.checked?) }
   filter(:option)  { |node, value|  node.value == value.to_s }
   filter(:disabled, default: false, boolean: true, skip_if: :all) { |node, value| not(value ^ node.disabled?) }
+
   describe do |options|
-    desc, states = "", []
+    desc, states = String.new, []
     desc << " with value #{options[:option].inspect}" if options[:option]
     states << 'checked' if options[:checked] || (options.has_key?(:unchecked) && !options[:unchecked])
     states << 'not checked' if options[:unchecked] || (options.has_key?(:checked) && !options[:checked])
@@ -214,13 +247,19 @@ Capybara.add_selector(:radio_button) do
 end
 
 Capybara.add_selector(:checkbox) do
-  xpath { |locator| XPath::HTML.checkbox(locator) }
+  xpath do |locator|
+    xpath = XPath.descendant(:input)[XPath.attr(:type).equals('checkbox')]
+    xpath = locate_field(xpath, locator.to_s) unless locator.nil?
+    xpath
+  end
+
   filter(:checked, boolean: true) { |node, value| not(value ^ node.checked?) }
   filter(:unchecked, boolean: true) { |node, value| (value ^ node.checked?) }
   filter(:option)  { |node, value|  node.value == value.to_s }
   filter(:disabled, default: false, boolean: true, skip_if: :all) { |node, value| not(value ^ node.disabled?) }
+
   describe do |options|
-    desc, states = "", []
+    desc, states = String.new, []
     desc << " with value #{options[:option].inspect}" if options[:option]
     states << 'checked' if options[:checked] || (options.has_key?(:unchecked) && !options[:unchecked])
     states << 'not checked' if options[:unchecked] || (options.has_key?(:checked) && !options[:checked])
@@ -232,7 +271,12 @@ end
 
 Capybara.add_selector(:select) do
   label "select box"
-  xpath { |locator| XPath::HTML.select(locator) }
+  xpath do |locator|
+    xpath = XPath.descendant(:select)
+    xpath = locate_field(xpath, locator.to_s) unless locator.nil?
+    xpath
+  end
+
   filter(:options) do |node, options|
     if node.visible?
       actual = node.all(:xpath, './/option').map { |option| option.text }
@@ -253,27 +297,83 @@ Capybara.add_selector(:select) do
     [selected].flatten.sort == actual.sort
   end
   filter(:disabled, default: false, boolean: true, skip_if: :all) { |node, value| not(value ^ node.disabled?) }
+  filter(:multiple, boolean: true) { |node, value| !(value ^ node[:multiple]) }
+
   describe do |options|
-    desc = ""
+    desc = String.new
     desc << " with options #{options[:options].inspect}" if options[:options]
     desc << " with at least options #{options[:with_options].inspect}" if options[:with_options]
     desc << " with #{options[:selected].inspect} selected" if options[:selected]
     desc << " that is disabled" if options[:disabled] == true
+    desc << " that allows multiple selection" if options[:multiple] == true
+    desc << " that only allows single selection" if options[:multiple] === false
     desc
   end
 end
 
 Capybara.add_selector(:option) do
-  xpath { |locator| XPath::HTML.option(locator) }
+  xpath do |locator|
+    xpath = XPath.descendant(:option)
+    xpath = xpath[XPath.string.n.is(locator.to_s)] unless locator.nil?
+    xpath
+  end
+
+  filter(:disabled, boolean: true) { |node, value| not(value ^ node.disabled?) }
+  filter(:selected, boolean: true) { |node, value| not(value ^ node.selected?) }
+
+  describe do |options|
+    desc = String.new
+    desc << " that is#{' not' unless options[:disabled]} disabled" if options.has_key?(:disabled)
+    desc << " that is#{' not' unless options[:selected]} selected" if options.has_key?(:selected)
+    desc
+  end
 end
 
 Capybara.add_selector(:file_field) do
   label "file field"
-  xpath { |locator| XPath::HTML.file_field(locator) }
+  xpath do |locator|
+    xpath = XPath.descendant(:input)[XPath.attr(:type).equals('file')]
+    xpath = locate_field(xpath, locator.to_s) unless locator.nil?
+    xpath
+  end
+
   filter(:disabled, default: false, boolean: true, skip_if: :all) { |node, value| not(value ^ node.disabled?) }
-  describe { |options| " that is disabled" if options[:disabled] == true}
+  filter(:multiple, boolean: true) { |node, value| !(value ^ node[:multiple]) }
+
+  describe do |options|
+    desc = String.new
+    desc << " that is disabled" if options[:disabled] == true
+    desc << " that allows multiple files" if options[:multiple] == true
+    desc << " that only allows a single file" if options[:multiple] === false
+    desc
+  end
+end
+
+Capybara.add_selector(:label) do
+  label "label"
+  xpath do |locator|
+    xpath = XPath.descendant(:label)
+    xpath = xpath[XPath.string.n.is(locator.to_s) | XPath.attr(:id).equals(locator.to_s)] unless locator.nil?
+    xpath
+  end
+
+  filter(:for) do |node, field_or_value|
+    if field_or_value.is_a? Capybara::Node::Element
+      if field_or_value[:id] && (field_or_value[:id] == node[:for])
+        true
+      else
+        field_or_value.find_xpath('./ancestor::label[1]').include? node.base
+      end
+    else
+      node[:for] == field_or_value.to_s
+    end
+  end
 end
 
 Capybara.add_selector(:table) do
-  xpath { |locator| XPath::HTML.table(locator) }
+  xpath do |locator|
+    xpath = XPath.descendant(:table)
+    xpath = xpath[XPath.attr(:id).equals(locator.to_s) | XPath.descendant(:caption).is(locator.to_s)] unless locator.nil?
+    xpath
+  end
 end

data/lib/capybara/selenium/driver.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "uri"
 
 class Capybara::Selenium::Driver < Capybara::Driver::Base
@@ -91,20 +92,35 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
   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
+          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
         # 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
@@ -247,8 +263,9 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
     Selenium::WebDriver::Error::NoSuchWindowError
   end
 
+  # @deprecated This method is being removed
   def browser_initialized?
-    !@browser.nil?
+    super && !@browser.nil?
   end
 
   private

data/lib/capybara/selenium/node.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 class Capybara::Selenium::Node < Capybara::Driver::Node
   def visible_text
     # Selenium doesn't normalize Unicode whitespace.

data/lib/capybara/server.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'uri'
 require 'net/http'
 require 'rack'
@@ -5,21 +6,46 @@ 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)
         @app = app
+        @counter = Counter.new
+      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
             @error = e unless @error
             raise e
+          ensure
+            @counter.decrement
           end
         end
       end
@@ -38,8 +64,8 @@ module Capybara
       @middleware = Middleware.new(@app)
       @server_thread = nil # suppress warnings
       @host, @port = host, port
-      @port ||= Capybara::Server.ports[@app.object_id]
-      @port ||= find_available_port
+      @port ||= Capybara::Server.ports[Capybara.reuse_server ? @app.object_id : @middleware.object_id]
+      @port ||= find_available_port(host)
     end
 
     def reset_error!
@@ -62,12 +88,18 @@ module Capybara
       return false
     end
 
+    def wait_for_pending_requests
+      Timeout.timeout(60) { sleep(0.01) while @middleware.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[Capybara.reuse_server ? @app.object_id : @middleware.object_id] = @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,8 +112,8 @@ module Capybara
 
   private
 
-    def find_available_port
-      server = TCPServer.new('127.0.0.1', 0)
+    def find_available_port(host)
+      server = TCPServer.new(host, 0)
       server.addr[1]
     ensure
       server.close if server

data/lib/capybara/session/matchers.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Capybara
   module SessionMatchers
     ##
@@ -66,4 +67,4 @@ module Capybara
       return false
     end
   end
-end
+end