capybara 2.8.1 → 2.9.0

data/lib/capybara/selector/filter_set.rb

@@ -12,7 +12,9 @@ module Capybara
         instance_eval(&block)
       end
 
-      def filter(name, options={}, &block)
+      def filter(name, *types_and_options, &block)
+        options = types_and_options.last.is_a?(Hash) ? types_and_options.pop.dup : {}
+        types_and_options.each { |k| options[k] = true}
         filters[name] = Filter.new(name, block, options)
       end
 

data/lib/capybara/selector/selector.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+require 'capybara/selector/filter_set'
+require 'xpath'
+
+#Patch XPath to allow a nil condition in where
+module XPath
+  class Renderer
+    def where(on, condition)
+      condition = condition.to_s
+      if !condition.empty?
+        "#{on}[#{condition}]"
+      else
+        "#{on}"
+      end
+    end
+  end
+end
+
+module Capybara
+  class Selector
+
+    attr_reader :name, :format, :expression_filters
+
+    class << self
+      def all
+        @selectors ||= {}
+      end
+
+      def add(name, &block)
+        all[name.to_sym] = Capybara::Selector.new(name.to_sym, &block)
+      end
+
+      def update(name, &block)
+        all[name.to_sym].instance_eval(&block)
+      end
+
+      def remove(name)
+        all.delete(name.to_sym)
+      end
+    end
+
+    def initialize(name, &block)
+      @name = name
+      @filter_set = FilterSet.add(name){}
+      @match = nil
+      @label = nil
+      @failure_message = nil
+      @description = nil
+      @format = nil
+      @expression = nil
+      @expression_filters = []
+      instance_eval(&block)
+    end
+
+    def custom_filters
+      @filter_set.filters
+    end
+
+    ##
+    #
+    # Define a selector by an xpath expression
+    #
+    # @overload xpath(*expression_filters, &block)
+    #   @param [Array<Symbol>] expression_filters ([])  Names of filters that can be implemented via this expression
+    #   @yield [locator, options]                       The block to use to generate the XPath expression
+    #   @yieldparam [String] locator                    The locator string passed to the query
+    #   @yieldparam [Hash] options                      The options hash passed to the query
+    #   @yieldreturn [#to_xpath, #to_s]                 An object that can produce an xpath expression
+    #
+    # @overload xpath()
+    # @return [#call]                             The block that will be called to generate the XPath expression
+    #
+    def xpath(*expression_filters, &block)
+      @format, @expression_filters, @expression = :xpath, expression_filters.flatten, block if block
+      format == :xpath ? @expression : nil
+    end
+
+    ##
+    #
+    # Define a selector by a CSS selector
+    #
+    # @overload css(*expression_filters, &block)
+    #   @param [Array<Symbol>] expression_filters ([])  Names of filters that can be implemented via this CSS selector
+    #   @yield [locator, options]                   The block to use to generate the CSS selector
+    #   @yieldparam [String] locator               The locator string passed to the query
+    #   @yieldparam [Hash] options                 The options hash passed to the query
+    #   @yieldreturn [#to_s]                        An object that can produce a CSS selector
+    #
+    # @overload css()
+    # @return [#call]                             The block that will be called to generate the CSS selector
+    #
+    def css(*expression_filters, &block)
+      @format, @expression_filters, @expression = :css, expression_filters.flatten, block if block
+      format == :css ? @expression : nil
+    end
+
+    ##
+    #
+    # Automatic selector detection
+    #
+    # @yield [locator]                   This block takes the passed in locator string and returns whether or not it matches the selector
+    # @yieldparam [String], locator      The locator string used to determin if it matches the selector
+    # @yieldreturn [Boolean]             Whether this selector matches the locator string
+    # @return [#call]                    The block that will be used to detect selector match
+    #
+    def match(&block)
+      @match = block if block
+      @match
+    end
+
+    ##
+    #
+    # Set/get a descriptive label for the selector
+    #
+    # @overload label(label)
+    #   @param [String] label            A descriptive label for this selector - used in error messages
+    # @overload label()
+    # @return [String]                 The currently set label
+    #
+    def label(label=nil)
+      @label = label if label
+      @label
+    end
+
+    ##
+    #
+    # Description of the selector
+    #
+    # @param [Hash] options            The options of the query used to generate the description
+    # @return [String]                 Description of the selector when used with the options passed
+    #
+    def description(options={})
+      @filter_set.description(options)
+    end
+
+    def call(locator, options={})
+      if format
+        # @expression.call(locator, options.select {|k,v| @expression_filters.include?(k)})
+        @expression.call(locator, options)
+      else
+        warn "Selector has no format"
+      end
+    end
+
+    ##
+    #
+    #  Should this selector be used for the passed in locator
+    #
+    #  This is used by the automatic selector selection mechanism when no selector type is passed to a selector query
+    #
+    # @param [String] locator     The locator passed to the query
+    # @return [Boolean]           Whether or not to use this selector
+    #
+    def match?(locator)
+      @match and @match.call(locator)
+    end
+
+    ##
+    #
+    # Define a non-expression filter for use with this selector
+    #
+    # @overload filter(name, *types, options={}, &block)
+    #   @param [Symbol] name            The filter name
+    #   @param [Array<Symbol>] types    The types of the filter - currently valid types are [:boolean]
+    #   @param [Hash] options ({})      Options of the filter
+    #   @option options [Array<>] :valid_values Valid values for this filter
+    #   @option options :default        The default value of the filter (if any)
+    #   @option options :skip_if        Value of the filter that will cause it to be skipped
+    #
+    def filter(name, *types_and_options, &block)
+      options = types_and_options.last.is_a?(Hash) ? types_and_options.pop.dup : {}
+      types_and_options.each { |k| options[k] = true}
+      custom_filters[name] = Filter.new(name, block, options)
+    end
+
+    def filter_set(name, filters_to_use = nil)
+      f_set = FilterSet.all[name]
+      f_set.filters.each do | name, filter |
+        custom_filters[name] = filter if filters_to_use.nil? || filters_to_use.include?(name)
+      end
+      f_set.descriptions.each { |desc| @filter_set.describe &desc }
+    end
+
+    def describe &block
+      @filter_set.describe &block
+    end
+
+    private
+
+    def locate_field(xpath, locator, options={})
+      locate_xpath = xpath #need to save original xpath for the label wrap
+      if locator
+        locator = locator.to_s
+        attr_matchers =  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))
+        attr_matchers |= XPath.attr(:'aria-label').is(locator) if Capybara.enable_aria_label
+
+        locate_xpath = locate_xpath[attr_matchers]
+        locate_xpath += XPath.descendant(:label)[XPath.string.n.is(locator)].descendant(xpath)
+      end
+
+      locate_xpath = [:id, :name, :placeholder, :class].inject(locate_xpath) { |memo, ef| memo[find_by_attr(ef, options[ef])] }
+      locate_xpath
+    end
+
+    def find_by_attr(attribute, value)
+      finder_name = "find_by_#{attribute.to_s}_attr"
+      if respond_to?(finder_name, true)
+        send(finder_name, value)
+      else
+        value ? XPath.attr(attribute).equals(value) : nil
+      end
+    end
+
+    def find_by_class_attr(classes)
+      if classes
+        Array(classes).map do |klass|
+          "contains(concat(' ',normalize-space(@class),' '),' #{klass} ')"
+        end.join(" and ").to_sym
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/capybara/session.rb

@@ -439,7 +439,7 @@ module Capybara
         driver.switch_to_window(window.handle)
         window
       else
-        wait_time = Capybara::Queries::SelectorQuery.new(options).wait
+        wait_time = Capybara::Queries::BaseQuery.wait(options)
         document.synchronize(wait_time, errors: [Capybara::WindowError]) do
           original_window_handle = driver.current_window_handle
           begin
@@ -536,7 +536,7 @@ module Capybara
       old_handles = driver.window_handles
       block.call
 
-      wait_time = Capybara::Queries::SelectorQuery.new(options).wait
+      wait_time = Capybara::Queries::BaseQuery.wait(options)
       document.synchronize(wait_time, errors: [Capybara::WindowError]) do
         opened_handles = (driver.window_handles - old_handles)
         if opened_handles.size != 1

data/lib/capybara/spec/session/element/matches_selector_spec.rb

@@ -1,4 +1,4 @@
-Capybara::SpecHelper.spec '#match_xpath?' do
+Capybara::SpecHelper.spec '#match_selector?' do
   before do
     @session.visit('/with_html')
     @element = @session.find('//span', text: '42')
@@ -28,6 +28,20 @@ Capybara::SpecHelper.spec '#match_xpath?' do
       expect(@element).not_to match_selector("//span", :text => "Doesnotexist")
     end
   end
+
+  it "should have css sugar" do
+    expect(@element.matches_css?('span.number')).to be true
+    expect(@element.matches_css?('span.not_a_number')).to be false
+    expect(@element.matches_css?('span.number', text: "42")).to be true
+    expect(@element.matches_css?('span.number', text: "Nope")).to be false
+  end
+
+  it "should have xpath sugar" do
+    expect(@element.matches_xpath?("//span")).to be true
+    expect(@element.matches_xpath?("//div")).to be false
+    expect(@element.matches_xpath?("//span", text: '42')).to be true
+    expect(@element.matches_xpath?("//span", text: 'Nope')).to be false
+  end
 end
 
 Capybara::SpecHelper.spec '#not_matches_selector?' do
@@ -60,4 +74,18 @@ Capybara::SpecHelper.spec '#not_matches_selector?' do
       expect(@element).to not_match_selector(:css, "span.number", :text => "Doesnotexist")
     end
   end
+
+  it "should have CSS sugar" do
+    expect(@element.not_matches_css?("span.number")).to be false
+    expect(@element.not_matches_css?("p a#doesnotexist")).to be true
+    expect(@element.not_matches_css?("span.number", :text => "42")).to be false
+    expect(@element.not_matches_css?("span.number", :text => "Doesnotexist")).to be true
+  end
+
+  it "should have xpath sugar" do
+    expect(@element.not_matches_xpath?("//span")).to be false
+    expect(@element.not_matches_xpath?("//div")).to be true
+    expect(@element.not_matches_xpath?("//span", :text => "42")).to be false
+    expect(@element.not_matches_xpath?("//span", :text => "Doesnotexist")).to be true
+  end
 end if Gem::Version.new(RSpec::Expectations::Version::STRING) >= Gem::Version.new('3.1')

data/lib/capybara/spec/session/selectors_spec.rb

@@ -45,5 +45,17 @@ Capybara::SpecHelper.spec Capybara::Selector do
     it "can find specifically by placeholder" do
       expect(@session.find(:field, placeholder: 'FirstName')['id']).to eq "form_first_name"
     end
+
+    it "can find by type" do
+      expect(@session.find(:field, 'Confusion', type: 'checkbox')['id']).to eq 'confusion_checkbox'
+      expect(@session.find(:field, 'Confusion', type: 'text')['id']).to eq 'confusion_text'
+      expect(@session.find(:field, 'Confusion', type: 'textarea')['id']).to eq 'confusion_textarea'
+    end
+
+    it "can find by class" do
+      expect(@session.find(:field, class: 'confusion-checkbox')['id']).to eq 'confusion_checkbox'
+      expect(@session).to have_selector(:field, class: 'confusion', count: 3)
+      expect(@session.find(:field, class: ['confusion','confusion-textarea'])['id']).to eq 'confusion_textarea'
+    end
   end
 end

data/lib/capybara/spec/views/form.erb

@@ -526,4 +526,15 @@ New line after and before textarea tag
   </p>
 </form>
 
+<label>Confusion
+  <input type="checkbox" id="confusion_checkbox" class="confusion-checkbox confusion"/>
+</label>
+
+<label>Confusion
+  <input type="text" id="confusion_text" class="confusion-text confusion"/>
+</label>
+
+<label>Confusion
+  <textarea id="confusion_textarea" class="confusion confusion-textarea"/>
+</label>
 

data/lib/capybara/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Capybara
-  VERSION = '2.8.1'
+  VERSION = '2.9.0'
 end

data/spec/fixtures/capybara.csv

@@ -0,0 +1 @@
+test, mime-type, file

data/spec/fixtures/selenium_driver_rspec_failure.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 
 RSpec.describe Capybara::Selenium::Driver do
   it "should exit with a non-zero exit status" do
-    browser = Capybara::Selenium::Driver.new(TestApp).browser
+    browser = Capybara::Selenium::Driver.new(TestApp, browser: (ENV['SELENIUM_BROWSER'] || :firefox).to_sym).browser
     expect(true).to eq(false)
   end
 end

data/spec/fixtures/selenium_driver_rspec_success.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 
 RSpec.describe Capybara::Selenium::Driver do
   it "should exit with a zero exit status" do
-    browser = Capybara::Selenium::Driver.new(TestApp).browser
+    browser = Capybara::Selenium::Driver.new(TestApp, browser: (ENV['SELENIUM_BROWSER'] || :firefox).to_sym).browser
     expect(true).to eq(true)
   end
 end

data/spec/rack_test_spec.rb

@@ -79,6 +79,14 @@ RSpec.describe Capybara::Session do
           expect(@session.html).to include('Successfully ignored empty file field.')
         end
       end
+
+      it "should not submit an obsolete mime type" do
+        @test_jpg_file_path = File.expand_path('fixtures/capybara.csv', File.dirname(__FILE__))
+        @session.visit("/form")
+        @session.attach_file "form_document", @test_jpg_file_path
+        @session.click_button('Upload Single')
+        expect(@session).to have_content("Content-type: text/csv")
+      end
     end
 
     describe "#click" do

data/spec/result_spec.rb

@@ -81,6 +81,9 @@ RSpec.describe Capybara::Result do
     expect(result.instance_variable_get('@result_cache').size).to be 1
 
     #works for indexed access
+    result[0]
+    expect(result.instance_variable_get('@result_cache').size).to be 1
+
     result[2]
     expect(result.instance_variable_get('@result_cache').size).to be 3
 

data/spec/selenium_firefox_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+require 'spec_helper'
+require "selenium-webdriver"
+require 'shared_selenium_session'
+
+Capybara.register_driver :selenium_focus do |app|
+  # profile = Selenium::WebDriver::Firefox::Profile.new
+  # profile["focusmanager.testmode"] = true
+  # Capybara::Selenium::Driver.new(app, browser: :firefox, profile: profile)
+  Capybara::Selenium::Driver.new(app, browser: :firefox)
+end
+
+module TestSessions
+  Selenium = Capybara::Session.new(:selenium_focus, TestApp)
+end
+
+skipped_tests = [
+  :response_headers,
+  :status_code,
+  :trigger
+]
+skipped_tests << :windows if ENV['TRAVIS'] && !ENV['WINDOW_TEST']
+
+Capybara::SpecHelper.run_specs TestSessions::Selenium, "selenium", :capybara_skip => skipped_tests
+
+RSpec.describe "Capybara::Session with firefox" do
+  include_examples  "Capybara::Session", TestSessions::Selenium, :selenium_focus
+end
+
+RSpec.describe Capybara::Selenium::Driver do
+  before do
+    @driver = Capybara::Selenium::Driver.new(TestApp, browser: :firefox)
+  end
+
+  describe '#quit' do
+    it "should reset browser when quit" do
+      expect(@driver.browser).to be
+      @driver.quit
+      #access instance variable directly so we don't create a new browser instance
+      expect(@driver.instance_variable_get(:@browser)).to be_nil
+    end
+  end
+end
+

data/spec/selenium_spec_chrome.rb

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 require 'spec_helper'
 require 'selenium-webdriver'
-
-Selenium::WebDriver::Chrome.driver_path = '/home/travis/chromedriver' if ENV['TRAVIS']
+require 'shared_selenium_session'
 
 Capybara.register_driver :selenium_chrome do |app|
   args = ENV['TRAVIS'] ? ['no-sandbox' ] : []
@@ -18,3 +17,7 @@ Capybara::SpecHelper.run_specs TestSessions::Chrome, "selenium_chrome", :capybar
   :status_code,
   :trigger
   ] unless ENV['TRAVIS'] && (RUBY_PLATFORM == 'java')
+
+RSpec.describe "Capybara::Session with chrome" do
+  include_examples  "Capybara::Session", TestSessions::Chrome, :selenium_chrome
+end