capybara 2.14.0 → 2.14.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 95059b9953d4a957739d739dadd55c294e39046b
-  data.tar.gz: fd4c944ff4a42c21661a1b6d39a243032b4ea7a8
+  metadata.gz: f26eecbab15830d1234ded90963559b1bcc5a189
+  data.tar.gz: 1c53aa8f1da2909f235f41c778b48c0633749025
 SHA512:
-  metadata.gz: b3bfd9f5c365c483b058461d58abe63e58f162b051e739794d30f69ea84e93ed7993245dfffc9ca48f96270022aa40df5e32a60bb6df29bbc93d85c0a7f714d3
-  data.tar.gz: bdb337934a2477819f03e9cfbbd683832a4d69775f6a688e5098079b48fc0ef630de10a8a5e7e78198ac9144cc2afe063dfeb9b73a15d73204688b789358d4a8
+  metadata.gz: 5d610898b0ab9dd9d8cdddc43de6e4933d041bc48bf38882865537986d5851e1ee24de44bbc172ea825a69dfe1ae4e98acc42269c0f86869cf54cc213da825b7
+  data.tar.gz: 6c7cc0c84a10b0b10f3990ab570cd065cdb329ec0ef3f55304d4fb6f66fa53e6e4498239e4c364fb80d9fedcf3c52bf5712f7d4131169c74e95b586c02c569f7

data/History.md

@@ -1,3 +1,15 @@
+# Version 2.14.1
+
+Release date: 2017-06-07
+
+### Fixed
+
+* Catch correct error when unexpected system modals are discovered in latest selenium [Thomas Walpole]
+* Update default `puma` server registration to encourage it to run in single mode [Thomas Walpole]
+* Suppress invalid element errors raised while lazily evaluating the results of `all` [Thomas Walpole]
+* Added missing `with_selected` option to the :select selector to match `options`/`with_options` options - Issue #1865 [Bartosz Nowak]
+* Workaround broken system modals when using selenium with headless Chrome
+
 # Version 2.14.0
 
 Release date: 2017-05-01

data/README.md

@@ -1071,7 +1071,7 @@ behaviors of Capybara change
       my_session.config.default_max_wait_time = 10 # only set for my_session
       Capybara.default_max_wait_time = 2 # will not change the default_max_wait in my_session
 
-* `current_driver` and `session_name` are thread specific.  This means that `using_session' and
+* `current_driver` and `session_name` are thread specific.  This means that `using_session` and
   `using_driver` also only affect the current thread.
 
 ## <a name="development"></a>Development

data/lib/capybara.rb

@@ -27,32 +27,32 @@ module Capybara
 
     # DelegateCapybara global configurations
     # @!method app
-    #   See {Capybara#configure}
+    #   See {Capybara.configure}
     # @!method reuse_server
-    #   See {Capybara#configure}
+    #   See {Capybara.configure}
     # @!method threadsafe
-    #   See {Capybara#configure}
+    #   See {Capybara.configure}
     # @!method server
-    #   See {Capybara#configure}
+    #   See {Capybara.configure}
     # @!method default_driver
-    #   See {Capybara#configure}
+    #   See {Capybara.configure}
     # @!method javascript_driver
-    #   See {Capybara#configure}
+    #   See {Capybara.configure}
     Config::OPTIONS.each do |method|
       def_delegators :config, method, "#{method}="
     end
 
     # Delegate Capybara global configurations
     # @!method default_selector
-    #   See {Capybara#configure}
+    #   See {Capybara.configure}
     # @!method default_max_wait_time
-    #   See {Capybara#configure}
+    #   See {Capybara.configure}
     # @!method app_host
-    #   See {Capybara#configure}
+    #   See {Capybara.configure}
     # @!method always_include_port
-    #   See {Capybara#configure}
+    #   See {Capybara.configure}
     # @!method wait_on_first_by_default
-    #   See {Capybara#configure}
+    #   See {Capybara.configure}
     SessionConfig::OPTIONS.each do |method|
       def_delegators :config, method, "#{method}="
     end
@@ -169,13 +169,14 @@ module Capybara
     ##
     #
     # Modify a selector previously created by {Capybara.add_selector}.
-    # For example modifying the :button selector to also find divs styled
-    # to look like buttons might look like this
+    # For example, adding a new filter to the :button selector to filter based on
+    # button style (a class) might look like this
     #
     #     Capybara.modify_selector(:button) do
-    #       xpath { |locator| XPath::HTML.button(locator).or(XPath::css('div.btn')[XPath::string.n.is(locator)]) }
+    #       filter (:style, valid_values: [:primary, :secondary]) { |node, style| node[:class].split.include? "btn-#{style}" }
     #     end
     #
+    #
     # @param [Symbol] name    The name of the selector to modify
     # @yield                  A block executed in the context of the existing {Capybara::Selector}
     #
@@ -447,7 +448,7 @@ end
 
 Capybara.register_server :puma do |app, port, host|
   require 'rack/handler/puma'
-  Rack::Handler::Puma.run(app, Host: host, Port: port, Threads: "0:4")
+  Rack::Handler::Puma.run(app, Host: host, Port: port, Threads: "0:4", workers: 0, daemon: false)
 end
 
 Capybara.configure do |config|

data/lib/capybara/minitest.rb

@@ -6,141 +6,140 @@ module Capybara
   module Minitest
     module Assertions
       ## Assert text exists
+      #
+      # @!method assert_text
       #  see {Capybara::Node::Matchers#assert_text}
-      def assert_text(*args)
-        self.assertions += 1
-        subject, *args = determine_subject(args)
-        subject.assert_text(*args)
-      rescue Capybara::ExpectationNotMet => e
-        raise ::Minitest::Assertion, e.message
-      end
-      alias_method :assert_content, :assert_text
 
       ## Assert text does not exist
+      #
+      # @!method assert_no_text
       #  see {Capybara::Node::Matchers#assert_no_text}
-      def assert_no_text(*args)
-        self.assertions += 1
-        subject, *args = determine_subject(args)
-        subject.assert_no_text(*args)
-      rescue Capybara::ExpectationNotMet => e
-        raise ::Minitest::Assertion, e.message
+
+      ##
+      # Assertion that page title does match
+      #
+      # @!method assert_title
+      #   see {Capybara::Node::DocumentMatchers#assert_title}
+
+      ##
+      # Assertion that page title does not match
+      #
+      # @!method refute_title
+      # @!method assert_no_title
+      #   see {Capybara::Node::DocumentMatchers#assert_no_title}
+
+      ##
+      # Assertion that current path matches
+      #
+      # @!method assert_current_path
+      #   see {Capybara::SessionMatchers#assert_current_path}
+
+      ##
+      # Assertion that current page does not match
+      #
+      # @!method refute_current_path
+      # @!method assert_no_current_path
+      #   see {Capybara::SessionMatchers#assert_no_current_path}
+
+
+      %w(assert_text assert_no_text assert_title assert_no_title assert_current_path assert_no_current_path).each do |assertion_name|
+        self.class_eval <<-EOM, __FILE__, __LINE__ + 1
+          def #{assertion_name} *args
+            self.assertions +=1
+            subject, *args = determine_subject(args)
+            subject.#{assertion_name}(*args)
+          rescue Capybara::ExpectationNotMet => e
+            raise ::Minitest::Assertions, e.message
+          end
+        EOM
       end
+
+      alias_method :refute_title, :assert_no_title
       alias_method :refute_text, :assert_no_text
       alias_method :refute_content, :refute_text
+      alias_method :refute_current_path, :assert_no_current_path
+      alias_method :assert_content, :assert_text
       alias_method :assert_no_content, :refute_text
 
       ## Assert selector exists on page
-      #  see {Capybara::Node::Matchers#assert_selector}
-      def assert_selector(*args, &optional_filter_block)
-        self.assertions +=1
-        subject, *args = determine_subject(args)
-        subject.assert_selector(*args, &optional_filter_block)
-      rescue Capybara::ExpectationNotMet => e
-        raise ::Minitest::Assertion, e.message
-      end
+      #
+      # @!method assert_selector
+      #   see {Capybara::Node::Matchers#assert_selector}
 
       ## Assert selector does not exist on page
-      #  see {Capybara::Node::Matchers#assert_no_selector}
-      def assert_no_selector(*args, &optional_filter_block)
-        self.assertions +=1
-        subject, *args = determine_subject(args)
-        subject.assert_no_selector(*args, &optional_filter_block)
-      rescue Capybara::ExpectationNotMet => e
-        raise ::Minitest::Assertion, e.message
-      end
-      alias_method :refute_selector, :assert_no_selector
+      #
+      # @!method assert_no_selector
+      #   see {Capybara::Node::Matchers#assert_no_selector}
 
       ## Assert element matches selector
-      #  see {Capybara::Node::Matchers#assert_matches_selector}
-      def assert_matches_selector(*args, &optional_filter_block)
-        self.assertions += 1
-        subject, *args = determine_subject(args)
-        subject.assert_matches_selector(*args, &optional_filter_block)
-      rescue Capybara::ExpectationNotMet => e
-        raise ::Minitest::Assertion, e.message
-      end
+      #
+      # @!method assert_matches_selector
+      #   see {Capybara::Node::Matchers#assert_matches_selector}
 
       ## Assert element does not match selector
-      #  see {Capybara::Node::Matchers#assert_not_matches_selector}
-      def assert_not_matches_selector(*args, &optional_filter_block)
-        self.assertions += 1
-        subject, *args = determine_subject(args)
-        subject.assert_not_matches_selector(*args, &optional_filter_block)
-      rescue Capybara::ExpectationNotMet => e
-        raise ::Minitest::Assertion, e.message
-      end
-      alias_method :refute_matches_selector, :assert_not_matches_selector
-
-      %w(title current_path).each do |selector_type|
-        define_method "assert_#{selector_type}" do |*args|
-          begin
-            self.assertions += 1
-            subject, *args = determine_subject(args)
-            subject.public_send("assert_#{selector_type}",*args)
-          rescue Capybara::ExpectationNotMet => e
-            raise ::Minitest::Assertion, e.message
-          end
-        end
+      #
+      # @!method assert_xpath
+      #   see {Capybara::Node::Matchers#assert_not_matches_selector}
 
-        define_method "assert_no_#{selector_type}" do |*args|
-          begin
-            self.assertions += 1
+      %w(assert_selector assert_no_selector assert_matches_selector assert_not_matches_selector).each do |assertion_name|
+        self.class_eval <<-EOM, __FILE__, __LINE__ + 1
+          def #{assertion_name} *args, &optional_filter_block
+            self.assertions +=1
             subject, *args = determine_subject(args)
-            subject.public_send("assert_no_#{selector_type}",*args)
+            subject.#{assertion_name}(*args, &optional_filter_block)
           rescue Capybara::ExpectationNotMet => e
-            raise ::Minitest::Assertion, e.message
+            raise ::Minitest::Assertions, e.message
           end
-        end
-        alias_method "refute_#{selector_type}", "assert_no_#{selector_type}"
+        EOM
       end
 
+      alias_method :refute_selector, :assert_no_selector
+      alias_method :refute_matches_selector, :assert_not_matches_selector
+
       %w(xpath css link button field select table).each do |selector_type|
         define_method "assert_#{selector_type}" do |*args, &optional_filter_block|
           subject, *args = determine_subject(args)
-          locator, options = *args, {}
-          locator, options = nil, locator if locator.is_a? Hash
+          locator, options = extract_locator(args)
           assert_selector(subject, selector_type.to_sym, locator, options, &optional_filter_block)
         end
 
         define_method "assert_no_#{selector_type}" do |*args, &optional_filter_block|
           subject, *args = determine_subject(args)
-          locator, options = *args, {}
-          locator, options = nil, locator if locator.is_a? Hash
+          locator, options = extract_locator(args)
           assert_no_selector(subject, selector_type.to_sym, locator, options, &optional_filter_block)
         end
         alias_method "refute_#{selector_type}", "assert_no_#{selector_type}"
       end
 
-      %w(xpath css).each do |selector_type|
-        define_method "assert_matches_#{selector_type}" do |*args, &optional_filter_block|
+      %w(checked unchecked).each do |field_type|
+        define_method "assert_#{field_type}_field" do |*args, &optional_filter_block|
           subject, *args = determine_subject(args)
-          assert_matches_selector(subject, selector_type.to_sym, *args, &optional_filter_block)
+          locator, options = extract_locator(args)
+          assert_selector(subject, :field, locator, options.merge(field_type.to_sym => true), &optional_filter_block)
         end
 
-        define_method "assert_not_matches_#{selector_type}" do |*args, &optional_filter_block|
+        define_method "assert_no_#{field_type}_field" do |*args, &optional_filter_block|
           subject, *args = determine_subject(args)
-          assert_not_matches_selector(subject, selector_type.to_sym, *args, &optional_filter_block)
+          locator, options = extract_locator(args)
+          assert_no_selector(subject, :field, locator, options.merge(field_type.to_sym => true), &optional_filter_block)
         end
-        alias_method "refute_matches_#{selector_type}", "assert_not_matches_#{selector_type}"
+        alias_method "refute_#{field_type}_field", "assert_no_#{field_type}_field"
       end
 
-      %w(checked unchecked).each do |field_type|
-        define_method "assert_#{field_type}_field" do |*args, &optional_filter_block|
+      %w(xpath css).each do |selector_type|
+        define_method "assert_matches_#{selector_type}" do |*args, &optional_filter_block|
           subject, *args = determine_subject(args)
-          locator, options = *args, {}
-          locator, options = nil, locator if locator.is_a? Hash
-          assert_selector(subject, :field, locator, options.merge(field_type.to_sym => true), &optional_filter_block)
+          assert_matches_selector(subject, selector_type.to_sym, *args, &optional_filter_block)
         end
 
-        define_method "assert_no_#{field_type}_field" do |*args, &optional_filter_block|
+        define_method "assert_not_matches_#{selector_type}" do |*args, &optional_filter_block|
           subject, *args = determine_subject(args)
-          locator, options = *args, {}
-          locator, options = nil, locator if locator.is_a? Hash
-          assert_no_selector(subject, :field, locator, options.merge(field_type.to_sym => true), &optional_filter_block)
+          assert_not_matches_selector(subject, selector_type.to_sym, *args, &optional_filter_block)
         end
-        alias_method "refute_#{field_type}_field", "assert_no_#{field_type}_field"
+        alias_method "refute_matches_#{selector_type}", "assert_not_matches_#{selector_type}"
       end
 
+
       ##
       # Assertion that there is xpath
       #
@@ -228,7 +227,7 @@ module Capybara
       # Assertion that there is no unchecked_field
       #
       # @!method assert_no_unchecked_field
-      # @!method refute_unchceked_field
+      # @!method refute_unchecked_field
 
       ##
       # Assertion that there is select
@@ -256,32 +255,6 @@ module Capybara
       # @!method assert_no_table
       #   see {Capybara::Node::Matchers#has_no_table?}
 
-      ##
-      # Assertion that page title does match
-      #
-      # @!method assert_title
-      #   see {Capybara::Node::DocumentMatchers#assert_title}
-
-      ##
-      # Assertion that page title does not match
-      #
-      # @!method refute_title
-      # @!method assert_no_title
-      #   see {Capybara::Node::DocumentMatchers#assert_no_title}
-
-      ##
-      # Assertion that current path matches
-      #
-      # @!method assert_current_path
-      #   see {Capybara::SessionMatchers#assert_current_path}
-
-      ##
-      # Assertion that current page does not match
-      #
-      # @!method refute_current_path
-      # @!method assert_no_current_path
-      #   see {Capybara::SessionMatchers#assert_no_current_path}
-
       private
 
       def determine_subject(args)
@@ -292,6 +265,12 @@ module Capybara
           [page, *args]
         end
       end
+
+      def extract_locator(args)
+        locator, options = *args, {}
+        locator, options = nil, locator if locator.is_a? Hash
+        [locator, options]
+      end
     end
   end
 end

data/lib/capybara/minitest/spec.rb

@@ -8,47 +8,22 @@ module Capybara
         infect_an_assertion "refute_#{assertion}", "wont_have_#{assertion}", :reverse
       end
 
-      # Unfortunately infect_an_assertion doesn't pass through the optional filter block so we can't use it for these
-      %w(selector xpath css link button field select table checked_field unchecked_field).each do |assertion|
-        self.class_eval <<-EOM
-          def must_have_#{assertion} *args, &optional_filter_block
-            ::Minitest::Expectation.new(self, ::Minitest::Spec.current).must_have_#{assertion}(*args, &optional_filter_block)
-          end
-
-          def wont_have_#{assertion} *args, &optional_filter_block
-            ::Minitest::Expectation.new(self, ::Minitest::Spec.current).wont_have_#{assertion}(*args, &optional_filter_block)
-          end
-        EOM
-
-        ::Minitest::Expectation.class_eval <<-EOM, __FILE__, __LINE__ + 1
-          def must_have_#{assertion} *args, &optional_filter_block
-            ctx.assert_#{assertion}(target, *args, &optional_filter_block)
-          end
-
-          def wont_have_#{assertion} *args, &optional_filter_block
-            ctx.refute_#{assertion}(target, *args, &optional_filter_block)
-          end
-        EOM
-      end
-
-      %w(selector xpath css).each do |assertion|
-        self.class_eval <<-EOM
-          def must_match_#{assertion} *args, &optional_filter_block
-            ::Minitest::Expectation.new(self, ::Minitest::Spec.current).must_match_#{assertion}(*args, &optional_filter_block)
-          end
-
-          def wont_match_#{assertion} *args, &optional_filter_block
-            ::Minitest::Expectation.new(self, ::Minitest::Spec.current).wont_match_#{assertion}(*args, &optional_filter_block)
+      (%w(selector xpath css link button field select table checked_field unchecked_field).map do |assertion|
+        [["assert_#{assertion}", "must_have_#{assertion}"],
+         ["refute_#{assertion}", "wont_have_#{assertion}"]]
+      end.flatten(1) + %w(selector xpath css).map do |assertion|
+        [["assert_matches_#{assertion}", "must_match_#{assertion}"],
+         ["refute_matches_#{assertion}", "wont_match_#{assertion}"]]
+      end.flatten(1)).each do |(meth, new_name)|
+        self.class_eval <<-EOM, __FILE__, __LINE__ + 1
+          def #{new_name} *args, &block
+            ::Minitest::Expectation.new(self, ::Minitest::Spec.current).#{new_name}(*args, &block)
           end
         EOM
 
         ::Minitest::Expectation.class_eval <<-EOM, __FILE__, __LINE__ + 1
-          def must_match_#{assertion} *args, &optional_filter_block
-            ctx.assert_matches_#{assertion}(target, *args, &optional_filter_block)
-          end
-
-          def wont_match_#{assertion} *args, &optional_filter_block
-            ctx.refute_matches_#{assertion}(target, *args, &optional_filter_block)
+          def #{new_name} *args, &block
+            ctx.#{meth}(target, *args, &block)
           end
         EOM
       end

data/lib/capybara/node/matchers.rb

@@ -432,11 +432,12 @@ module Capybara
       #
       #     page.has_select?('Language', with_options: ['English', 'German'])
       #
-      # @param [String] locator                      The label, name or id of a select box
-      # @option options [Array] :options             Options which should be contained in this select box
-      # @option options [Array] :with_options        Partial set of options which should be contained in this select box
-      # @option options [String, Array] :selected    Options which should be selected
-      # @return [Boolean]                            Whether it exists
+      # @param [String] locator                         The label, name or id of a select box
+      # @option options [Array] :options                Options which should be contained in this select box
+      # @option options [Array] :with_options           Partial set of options which should be contained in this select box
+      # @option options [String, Array] :selected       Options which should be selected
+      # @option options [String, Array] :with_selected  Partial set of options which should minimally be selected
+      # @return [Boolean]                               Whether it exists
       #
       def has_select?(locator=nil, options={}, &optional_filter_block)
         locator, options = nil, locator if locator.is_a? Hash