rails-dom-testing 2.0.3 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 0af31466148a2f967def0233933062ca454b1bcb
-  data.tar.gz: 825ff206fc31a115d41c567614331e779ccc8d92
+SHA256:
+  metadata.gz: dc48c3a21ae3839cf5bbde901d06210fe2a4d1d58e6aae4048a26c19a6baf577
+  data.tar.gz: b082464768d961ef20cc41ec1da545691bd7e0caac93a16b8668128818855885
 SHA512:
-  metadata.gz: 51291b7d5bf443fa4df3b9fa38ef92b84ecef5e434a77b9681f2b63bd3188aaf59d13b722e08a27e1f3a21fb1a2872d42a05a92e838c072d0059983edc4b6878
-  data.tar.gz: af4705e0a6acb6d1009ad3cdec42ab3dfc3eedb9e4a8ec28a4b112bbd0f1e53badfd8fa853a7146644d445c876b71b89fb4dd269e875e366c5d33f5850c55767
+  metadata.gz: 51f291660cac9014e810adbf636c5dfbf7da80db478c062191eecedebe5b77b4f795a12259b1b427fd04b548e0a9b1b524d550e514b8e8b561ae566c36471182
+  data.tar.gz: d5ac742ae523c62d565627f9c95553780286de17ba7a43f32972a5dcf2458d316b79c80edcfd3f4361b2d77a4dcfa541976f14cbb09b249bf681bfabf2c5696e

data/README.md

@@ -2,7 +2,7 @@
 
 This gem is responsible for comparing HTML doms and asserting that DOM elements are present in Rails applications.
 Doms are compared via `assert_dom_equal` and `assert_dom_not_equal`.
-Elements are asserted via `assert_select`, `assert_select_encoded`, `assert_select_email` and a subset of the dom can be selected with `css_select`.
+Elements are asserted via `assert_dom`, `assert_dom_encoded`, `assert_dom_email` and a subset of the dom can be selected with `css_select`.
 The gem is developed for Rails 4.2 and above, and will not work on previous versions.
 
 ## Nokogiri::CSS::SyntaxError exceptions when upgrading to Rails 4.2:
@@ -41,21 +41,21 @@ assert_dom_not_equal '<h1>Portuguese</h1>', '<h1>Danish</h1>'
 # implicitly selects from the document_root_element
 css_select '.hello' # => Nokogiri::XML::NodeSet of elements with hello class
 
-# select from a supplied node. assert_select asserts elements exist.
-assert_select document_root_element.at('.hello'), '.goodbye'
+# select from a supplied node. assert_dom asserts elements exist.
+assert_dom document_root_element.at('.hello'), '.goodbye'
 
 # elements in CDATA encoded sections can also be selected
-assert_select_encoded '#out-of-your-element'
+assert_dom_encoded '#out-of-your-element'
 
 # assert elements within an html email exists
-assert_select_email '#you-got-mail'
+assert_dom_email '#you-got-mail'
 ```
 
 The documentation in [selector_assertions.rb](https://github.com/rails/rails-dom-testing/blob/master/lib/rails/dom/testing/assertions/selector_assertions.rb) goes into a lot more detail of how selector assertions can be used.
 
 ## Read more
 
-Under the hood the doms are parsed with Nokogiri and you'll generally be working with these two classes:
+Under the hood the doms are parsed with Nokogiri, and you'll generally be working with these two classes:
 - [`Nokogiri::XML::Node`](http://www.rubydoc.info/github/sparklemotion/nokogiri/Nokogiri/XML/Node)
 - [`Nokogiri::XML::NodeSet`](http://www.rubydoc.info/github/sparklemotion/nokogiri/Nokogiri/XML/NodeSet)
 

data/lib/rails/dom/testing/assertions/dom_assertions.rb

@@ -7,43 +7,61 @@ module Rails
           #
           #   # assert that the referenced method generates the appropriate HTML string
           #   assert_dom_equal '<a href="http://www.example.com">Apples</a>', link_to("Apples", "http://www.example.com")
-          def assert_dom_equal(expected, actual, message = nil)
+          def assert_dom_equal(expected, actual, message = nil, strict: false)
             expected_dom, actual_dom = fragment(expected), fragment(actual)
             message ||= "Expected: #{expected}\nActual: #{actual}"
-            assert compare_doms(expected_dom, actual_dom), message
+            assert compare_doms(expected_dom, actual_dom, strict), message
           end
 
           # The negated form of +assert_dom_equal+.
           #
           #   # assert that the referenced method does not generate the specified HTML string
           #   assert_dom_not_equal '<a href="http://www.example.com">Apples</a>', link_to("Oranges", "http://www.example.com")
-          def assert_dom_not_equal(expected, actual, message = nil)
+          def assert_dom_not_equal(expected, actual, message = nil, strict: false)
             expected_dom, actual_dom = fragment(expected), fragment(actual)
             message ||= "Expected: #{expected}\nActual: #{actual}"
-            assert_not compare_doms(expected_dom, actual_dom), message
+            assert_not compare_doms(expected_dom, actual_dom, strict), message
           end
 
           protected
 
-            def compare_doms(expected, actual)
-              return false unless expected.children.size == actual.children.size
+            def compare_doms(expected, actual, strict)
+              expected_children = extract_children(expected, strict)
+              actual_children   = extract_children(actual, strict)
+              return false unless expected_children.size == actual_children.size
 
-              expected.children.each_with_index do |child, i|
-                return false unless equal_children?(child, actual.children[i])
+              expected_children.each_with_index do |child, i|
+                return false unless equal_children?(child, actual_children[i], strict)
               end
 
               true
             end
 
-            def equal_children?(child, other_child)
+            def extract_children(node, strict)
+              if strict
+                node.children
+              else
+                node.children.reject{|n| n.text? && n.text.blank?}
+              end
+            end
+
+            def equal_children?(child, other_child, strict)
               return false unless child.type == other_child.type
 
               if child.element?
                 child.name == other_child.name &&
                     equal_attribute_nodes?(child.attribute_nodes, other_child.attribute_nodes) &&
-                    compare_doms(child, other_child)
+                    compare_doms(child, other_child, strict)
               else
+                equal_child?(child, other_child, strict)
+              end
+            end
+
+            def equal_child?(child, other_child, strict)
+              if strict
                 child.to_s == other_child.to_s
+              else
+                child.to_s.split == other_child.to_s.split
               end
             end
 

data/lib/rails/dom/testing/assertions/selector_assertions/count_describable.rb

@@ -1,13 +1,9 @@
-require 'active_support/concern'
-
 module Rails
   module Dom
     module Testing
       module Assertions
         module SelectorAssertions
           module CountDescribable
-            extend ActiveSupport::Concern
-
             private
               def count_description(min, max, count) #:nodoc:
                 if min && max && (max != min)

data/lib/rails/dom/testing/assertions/selector_assertions/html_selector.rb

@@ -1,9 +1,13 @@
+require 'minitest'
+require 'active_support'
 require 'active_support/core_ext/module/attribute_accessors'
 require_relative 'substitution_context'
 
 class HTMLSelector #:nodoc:
   attr_reader :css_selector, :tests, :message
 
+  include Minitest::Assertions
+
   def initialize(values, previous_selection = nil, &root_fallback)
     @values = values
     @root = extract_root(previous_selection, root_fallback)
@@ -11,6 +15,10 @@ class HTMLSelector #:nodoc:
     @tests = extract_equality_tests
     @message = @values.shift
 
+    if @message.is_a?(Hash)
+      raise ArgumentError, "Last argument was a Hash, which would be used for the assertion message. You probably want this to be a String, or you have the wrong type of arguments."
+    end
+
     if @values.shift
       raise ArgumentError, "Not expecting that last argument, you either have too many arguments, or they're the wrong type"
     end
@@ -48,7 +56,7 @@ class HTMLSelector #:nodoc:
       content.sub!(/\A\n/, '') if text_matches && match.name == "textarea"
 
       next if regex_matching ? (content =~ match_with) : (content == match_with)
-      content_mismatch ||= sprintf("<%s> expected but was\n<%s>.", match_with, content)
+      content_mismatch ||= diff(match_with, content)
       true
     end
 
@@ -61,7 +69,7 @@ class HTMLSelector #:nodoc:
 
     if possible_root == nil
       raise ArgumentError, 'First argument is either selector or element ' \
-        'to select, but nil found. Perhaps you called assert_select with ' \
+        'to select, but nil found. Perhaps you called assert_dom with ' \
         'an element that does not exist?'
     elsif possible_root.respond_to?(:css)
       @values.shift # remove the root, so selector is the first argument
@@ -87,20 +95,20 @@ class HTMLSelector #:nodoc:
   def extract_equality_tests
     comparisons = {}
     case comparator = @values.shift
-      when Hash
-        comparisons = comparator
-      when String, Regexp
-        comparisons[:text] = comparator
-      when Integer
-        comparisons[:count] = comparator
-      when Range
-        comparisons[:minimum] = comparator.begin
-        comparisons[:maximum] = comparator.end
-      when FalseClass
-        comparisons[:count] = 0
-      when NilClass, TrueClass
-        comparisons[:minimum] = 1
-      else raise ArgumentError, "I don't understand what you're trying to match"
+    when Hash
+      comparisons = comparator
+    when String, Regexp
+      comparisons[:text] = comparator
+    when Integer
+      comparisons[:count] = comparator
+    when Range
+      comparisons[:minimum] = comparator.begin
+      comparisons[:maximum] = comparator.end
+    when FalseClass
+      comparisons[:count] = 0
+    when NilClass, TrueClass
+      comparisons[:minimum] = 1
+    else raise ArgumentError, "I don't understand what you're trying to match"
     end
 
     # By default we're looking for at least one match.

data/lib/rails/dom/testing/assertions/selector_assertions/substitution_context.rb

@@ -4,13 +4,10 @@ class SubstitutionContext
   end
 
   def substitute!(selector, values, format_for_presentation = false)
-    selector = selector.dup
-
-    while !values.empty? && substitutable?(values.first) && selector.index(@substitute)
-      selector.sub! @substitute, matcher_for(values.shift, format_for_presentation)
+    selector.gsub @substitute do |match|
+      next match[0] if values.empty? || !substitutable?(values.first)
+      matcher_for(values.shift, format_for_presentation)
     end
-
-    selector
   end
 
   def match(matches, attribute, matcher)
@@ -23,11 +20,11 @@ class SubstitutionContext
       if format_for_presentation
         value.inspect # Avoid to_s so Regexps aren't put in quotes.
       else
-        value.to_s.inspect
+        "\"#{value}\""
       end
     end
 
     def substitutable?(value)
-      value.is_a?(String) || value.is_a?(Regexp)
+      [ Symbol, Numeric, String, Regexp ].any? { |type| value.is_a? type }
     end
 end

data/lib/rails/dom/testing/assertions/selector_assertions.rb

@@ -1,4 +1,3 @@
-require 'active_support/deprecation'
 require_relative 'selector_assertions/count_describable'
 require_relative 'selector_assertions/html_selector'
 
@@ -6,9 +5,9 @@ module Rails
   module Dom
     module Testing
       module Assertions
-        # Adds the +assert_select+ method for use in Rails functional
+        # Adds the +assert_dom+ method for use in Rails functional
         # test cases, which can be used to make assertions on the response HTML of a controller
-        # action. You can also call +assert_select+ within another +assert_select+ to
+        # action. You can also call +assert_dom+ within another +assert_dom+ to
         # make assertions on elements selected by the enclosing assertion.
         #
         # Use +css_select+ to select elements without making an assertions, either
@@ -16,8 +15,8 @@ module Rails
         #
         # In addition to HTML responses, you can make the following assertions:
         #
-        # * +assert_select_encoded+ - Assertions on HTML encoded inside XML, for example for dealing with feed item descriptions.
-        # * +assert_select_email+ - Assertions on the HTML body of an e-mail.
+        # * +assert_dom_encoded+ - Assertions on HTML encoded inside XML, for example for dealing with feed item descriptions.
+        # * +assert_dom_email+ - Assertions on the HTML body of an e-mail.
         module SelectorAssertions
 
         # Select and return all matching elements.
@@ -70,38 +69,41 @@ module Rails
         # starting from (and including) that element and all its children in
         # depth-first order.
         #
-        # If no element is specified +assert_select+ selects from
+        # If no element is specified +assert_dom+ selects from
         # the element returned in +document_root_element+
-        # unless +assert_select+ is called from within an +assert_select+ block.
-        # Override +document_root_element+ to tell +assert_select+ what to select from.
+        # unless +assert_dom+ is called from within an +assert_dom+ block.
+        # Override +document_root_element+ to tell +assert_dom+ what to select from.
         # The default implementation raises an exception explaining this.
         #
-        # When called with a block +assert_select+ passes an array of selected elements
-        # to the block. Calling +assert_select+ from the block, with no element specified,
+        # When called with a block +assert_dom+ passes an array of selected elements
+        # to the block. Calling +assert_dom+ from the block, with no element specified,
         # runs the assertion on the complete set of elements selected by the enclosing assertion.
-        # Alternatively the array may be iterated through so that +assert_select+ can be called
+        # Alternatively the array may be iterated through so that +assert_dom+ can be called
         # separately for each element.
         #
         #
         # ==== Example
         # If the response contains two ordered lists, each with four list elements then:
-        #   assert_select "ol" do |elements|
+        #   assert_dom "ol" do |elements|
         #     elements.each do |element|
-        #       assert_select element, "li", 4
+        #       assert_dom element, "li", 4
         #     end
         #   end
         #
         # will pass, as will:
-        #   assert_select "ol" do
-        #     assert_select "li", 8
+        #   assert_dom "ol" do
+        #     assert_dom "li", 8
         #   end
         #
-        # The selector may be a CSS selector expression (String) or an expression
+        # The selector may be a CSS selector expression (String, Symbol, or Numeric) or an expression
         # with substitution values (Array).
         # Substitution uses a custom pseudo class match. Pass in whatever attribute you want to match (enclosed in quotes) and a ? for the substitution.
-        # assert_select returns nil if called with an invalid css selector.
+        # assert_dom returns nil if called with an invalid css selector.
         #
-        # assert_select "div:match('id', ?)", /\d+/
+        # assert_dom "div:match('id', ?)", "id_string"
+        # assert_dom "div:match('id', ?)", :id_string
+        # assert_dom "div:match('id', ?)", 1
+        # assert_dom "div:match('id', ?)", /\d+/
         #
         # === Equality Tests
         #
@@ -133,32 +135,32 @@ module Rails
         # evaluated the block is called with an array of all matched elements.
         #
         #   # At least one form element
-        #   assert_select "form"
+        #   assert_dom "form"
         #
         #   # Form element includes four input fields
-        #   assert_select "form input", 4
+        #   assert_dom "form input", 4
         #
         #   # Page title is "Welcome"
-        #   assert_select "title", "Welcome"
+        #   assert_dom "title", "Welcome"
         #
         #   # Page title is "Welcome" and there is only one title element
-        #   assert_select "title", {count: 1, text: "Welcome"},
+        #   assert_dom "title", {count: 1, text: "Welcome"},
         #       "Wrong title or more than one title element"
         #
         #   # Page contains no forms
-        #   assert_select "form", false, "This page must contain no forms"
+        #   assert_dom "form", false, "This page must contain no forms"
         #
         #   # Test the content and style
-        #   assert_select "body div.header ul.menu"
+        #   assert_dom "body div.header ul.menu"
         #
         #   # Use substitution values
-        #   assert_select "ol>li:match('id', ?)", /item-\d+/
+        #   assert_dom "ol>li:match('id', ?)", /item-\d+/
         #
         #   # All input fields in the form have a name
-        #   assert_select "form input" do
-        #     assert_select ":match('name', ?)", /.+/  # Not empty
+        #   assert_dom "form input" do
+        #     assert_dom ":match('name', ?)", /.+/  # Not empty
         #   end
-        def assert_select(*args, &block)
+        def assert_dom(*args, &block)
           @selected ||= nil
 
           selector = HTMLSelector.new(args, @selected) { nodeset document_root_element }
@@ -175,6 +177,7 @@ module Rails
             nest_selection(matches, &block) if block_given? && !matches.empty?
           end
         end
+        alias_method :assert_select, :assert_dom
 
         # Extracts the content of an element, treats it as encoded HTML and runs
         # nested assertion on it.
@@ -187,30 +190,30 @@ module Rails
         # element +encoded+. It then calls the block with all un-encoded elements.
         #
         #   # Selects all bold tags from within the title of an Atom feed's entries (perhaps to nab a section name prefix)
-        #   assert_select "feed[xmlns='http://www.w3.org/2005/Atom']" do
+        #   assert_dom "feed[xmlns='http://www.w3.org/2005/Atom']" do
         #     # Select each entry item and then the title item
-        #     assert_select "entry>title" do
+        #     assert_dom "entry>title" do
         #       # Run assertions on the encoded title elements
-        #       assert_select_encoded do
-        #         assert_select "b"
+        #       assert_dom_encoded do
+        #         assert_dom "b"
         #       end
         #     end
         #   end
         #
         #
         #   # Selects all paragraph tags from within the description of an RSS feed
-        #   assert_select "rss[version=2.0]" do
+        #   assert_dom "rss[version=2.0]" do
         #     # Select description element of each feed item.
-        #     assert_select "channel>item>description" do
+        #     assert_dom "channel>item>description" do
         #       # Run assertions on the encoded elements.
-        #       assert_select_encoded do
-        #         assert_select "p"
+        #       assert_dom_encoded do
+        #         assert_dom "p"
         #       end
         #     end
         #   end
-        def assert_select_encoded(element = nil, &block)
+        def assert_dom_encoded(element = nil, &block)
           if !element && !@selected
-            raise ArgumentError, "Element is required when called from a nonnested assert_select"
+            raise ArgumentError, "Element is required when called from a nonnested assert_dom"
           end
 
           content = nodeset(element || @selected).map do |elem|
@@ -224,27 +227,28 @@ module Rails
             if content.empty?
               yield selected
             else
-              assert_select ":root", &block
+              assert_dom ":root", &block
             end
           end
         end
+        alias_method :assert_select_encoded, :assert_dom_encoded
 
         # Extracts the body of an email and runs nested assertions on it.
         #
         # You must enable deliveries for this assertion to work, use:
         #   ActionMailer::Base.perform_deliveries = true
         #
-        #  assert_select_email do
-        #    assert_select "h1", "Email alert"
+        #  assert_dom_email do
+        #    assert_dom "h1", "Email alert"
         #  end
         #
-        #  assert_select_email do
-        #    items = assert_select "ol>li"
+        #  assert_dom_email do
+        #    items = assert_dom "ol>li"
         #    items.each do
         #       # Work with items here...
         #    end
         #  end
-        def assert_select_email(&block)
+        def assert_dom_email(&block)
           deliveries = ActionMailer::Base.deliveries
           assert !deliveries.empty?, "No e-mail in delivery list"
 
@@ -252,25 +256,26 @@ module Rails
             (delivery.parts.empty? ? [delivery] : delivery.parts).each do |part|
               if part["Content-Type"].to_s =~ /^text\/html\W/
                 root = Nokogiri::HTML::DocumentFragment.parse(part.body.to_s)
-                assert_select root, ":root", &block
+                assert_dom root, ":root", &block
               end
             end
           end
         end
+        alias_method :assert_select_email, :assert_dom_email
 
         private
           include CountDescribable
 
           def document_root_element
             raise NotImplementedError, 'Implementing document_root_element makes ' \
-              'assert_select work without needing to specify an element to select from.'
+              'assert_dom work without needing to specify an element to select from.'
           end
 
           # +equals+ must contain :minimum, :maximum and :count keys
           def assert_size_match!(size, equals, css_selector, message = nil)
             min, max, count = equals[:minimum], equals[:maximum], equals[:count]
 
-            message ||= %(Expected #{count_description(min, max, count)} matching "#{css_selector}", found #{size}.)
+            message ||= %(Expected #{count_description(min, max, count)} matching #{css_selector.inspect}, found #{size})
             if count
               assert_equal count, size, message
             else
@@ -280,7 +285,7 @@ module Rails
           end
 
           def nest_selection(selection)
-            # Set @selected to allow nested assert_select.
+            # Set @selected to allow nested assert_dom.
             # Can be nested several levels deep.
             old_selected, @selected = @selected, selection
             yield @selected
@@ -292,6 +297,7 @@ module Rails
             if node.is_a?(Nokogiri::XML::NodeSet)
               node
             else
+              node ||= Nokogiri::HTML::Document.new
               Nokogiri::XML::NodeSet.new(node.document, [node])
             end
           end

data/lib/rails/dom/testing/assertions.rb

@@ -1,18 +1,14 @@
-require 'active_support/concern'
 require 'nokogiri'
+require 'rails/dom/testing/assertions/dom_assertions'
+require 'rails/dom/testing/assertions/selector_assertions'
 
 module Rails
   module Dom
     module Testing
       module Assertions
-        autoload :DomAssertions, 'rails/dom/testing/assertions/dom_assertions'
-        autoload :SelectorAssertions, 'rails/dom/testing/assertions/selector_assertions'
-
-        extend ActiveSupport::Concern
-
         include DomAssertions
         include SelectorAssertions
       end
     end
   end
-end
+end

data/lib/rails/dom/testing/version.rb

@@ -1,7 +1,7 @@
 module Rails
   module Dom
     module Testing
-      VERSION = "2.0.3"
+      VERSION = "2.1.1"
     end
   end
 end

data/test/dom_assertions_test.rb

@@ -47,4 +47,79 @@ class DomAssertionsTest < ActiveSupport::TestCase
       %{<a><b c="2" /></a>}
     )
   end
-end
+
+  def test_dom_equal_with_whitespace_strict
+    canonical = %{<a><b>hello</b> world</a>}
+    assert_dom_not_equal(canonical, %{<a>\n<b>hello\n </b> world</a>}, strict: true)
+    assert_dom_not_equal(canonical, %{<a> \n <b>\n hello</b> world</a>}, strict: true)
+    assert_dom_not_equal(canonical, %{<a>\n\t<b>hello</b> world</a>}, strict: true)
+    assert_dom_equal(canonical, %{<a><b>hello</b> world</a>}, strict: true)
+  end
+
+  def test_dom_equal_with_whitespace
+    canonical = %{<a><b>hello</b> world</a>}
+    assert_dom_equal(canonical, %{<a>\n<b>hello\n </b> world</a>})
+    assert_dom_equal(canonical, %{<a>\n<b>hello </b>\nworld</a>})
+    assert_dom_equal(canonical, %{<a> \n <b>\n hello</b> world</a>})
+    assert_dom_equal(canonical, %{<a> \n <b> hello </b>world</a>})
+    assert_dom_equal(canonical, %{<a> \n <b>hello </b>world\n</a>\n})
+    assert_dom_equal(canonical, %{<a>\n\t<b>hello</b> world</a>})
+    assert_dom_equal(canonical, %{<a>\n\t<b>hello </b>\n\tworld</a>})
+  end
+
+  def test_dom_equal_with_attribute_whitespace
+    canonical = %(<div data-wow="Don't strip this">)
+    assert_dom_equal(canonical, %(<div data-wow="Don't strip this">))
+    assert_dom_not_equal(canonical, %(<div data-wow="Don't  strip this">))
+  end
+
+  def test_dom_equal_with_indentation
+    canonical = %{<a>hello <b>cruel</b> world</a>}
+    assert_dom_equal(canonical, <<-HTML)
+<a>
+  hello
+  <b>cruel</b>
+  world
+</a>
+    HTML
+
+    assert_dom_equal(canonical, <<-HTML)
+<a>
+hello
+<b>cruel</b>
+world
+</a>
+    HTML
+
+    assert_dom_equal(canonical, <<-HTML)
+<a>hello
+  <b>
+    cruel
+  </b>
+  world</a>
+    HTML
+  end
+
+  def test_dom_equal_with_surrounding_whitespace
+    canonical = %{<p>Lorem ipsum dolor</p><p>sit amet, consectetur adipiscing elit</p>}
+    assert_dom_equal(canonical, <<-HTML)
+<p>
+  Lorem
+  ipsum
+  dolor
+</p>
+
+<p>
+  sit amet,
+  consectetur
+  adipiscing elit
+</p>
+    HTML
+  end
+
+  def test_dom_not_equal_with_interior_whitespace
+    with_space    = %{<a><b>hello world</b></a>}
+    without_space = %{<a><b>helloworld</b></a>}
+    assert_dom_not_equal(with_space, without_space)
+  end
+end

data/test/selector_assertions_test.rb

@@ -135,6 +135,21 @@ class AssertSelectTest < ActiveSupport::TestCase
     end
   end
 
+  def test_multiple_substitution_values
+    render_html '<input name="foo[12]" value="34">'
+    assert_select ":match('name', ?):match('value', ?)", /\w+\[\d+\]/, /\d+/
+  end
+
+  def test_substitution_values_with_values_other_than_string_or_regexp
+    render_html %Q{<div id="id_string">symbol</div><div id="1">numeric</div>}
+    assert_select "div:match('id', ?)", :id_string do |elements|
+      assert_equal 1, elements.size
+    end
+    assert_select "div:match('id', ?)", 1 do |elements|
+      assert_equal 1, elements.size
+    end
+  end
+
   def test_assert_select_root_html
     render_html '<a></a>'
 
@@ -302,6 +317,24 @@ EOF
     assert_select '.foo'
   end
 
+  def test_assert_select_with_extra_argument
+    render_html '<html><head><title>Welcome</title></head><body><div></div></body></html>'
+
+    assert_raises ArgumentError do
+      assert_select "title", "Welcome", count: 1
+    end
+
+    assert_select "title", text: "Welcome", count: 1
+  end
+
+  def test_assert_select_on_blank_response
+    render_html ""
+    assert_select "div", 0
+    assert_failure(/Expected exactly 1 element matching \"div\", found 0./) do
+      assert_select "div", 1
+    end
+  end
+
   protected
     def render_html(html)
       fake_render(:html, html)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-dom-testing
 version: !ruby/object:Gem::Version
-  version: 2.0.3
+  version: 2.1.1
 platform: ruby
 authors:
 - Rafael Mendonça França
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-10 00:00:00.000000000 Z
+date: 2023-06-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -31,14 +31,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.2.0
+        version: 5.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.2.0
+        version: 5.0.0
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -122,8 +136,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 3.4.10
 signing_key: 
 specification_version: 4
 summary: Dom and Selector assertions for Rails applications