rails-dom-testing 2.2.0 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d8720c7b560a8e3acaa5ae87a7dbfb587fe47c156d8f49b9d319b2c089a3d987
-  data.tar.gz: f482fcae81574f5fedc71d6e46ce372f8f273eac9df50a40d565696db1a02209
+  metadata.gz: 92842b3fcd4006daf9f8047da3d90a171ead6f39900c2d4f491d3c3ac0658845
+  data.tar.gz: 67b13526065e8c54acc109945f9566947f1976c601e44bb2295eaab79d7fcfe4
 SHA512:
-  metadata.gz: bb404e501783f50dfd614101ee141ccc08665e2410fbd3c2e62c6859e4ed2edd2097169373b86d6deaefb63192385cf895d1ae0c512c69f65de760d38a8b6542
-  data.tar.gz: afc3f0247a26905b8aeb37fd94a9a0bd79f09b2ed334b539129f9566d3c25aed44e0e3a6a34f73c4ad0c6c485a24ae30e205b0aac14ff7e60b942be5d32d7663
+  metadata.gz: d16235fedf30e46ccc6f0fc4463f567917d12084d6d8a0b67cfce316ae7cdd5100b78d84f314e856ff56904e4ffa628628e0c2b5fee11cf1b287ddffdb04431c
+  data.tar.gz: 93e996ac52d49ead86b8a04ae43299303c3c02231adc0911158142e7defb49e5afc3b4584f66bb437e9983d910fc70f8bacdddfb79f648c8f1f27cd003532b87

data/README.md

@@ -24,6 +24,9 @@ css_select '.hello' # => Nokogiri::XML::NodeSet of elements with hello class
 # select from a supplied node. assert_dom asserts elements exist.
 assert_dom document_root_element.at('.hello'), '.goodbye'
 
+# select from a supplied node. assert_not_dom asserts elements do not exist.
+assert_not_dom document_root_element.at('.hello'), '.goodbye'
+
 # elements in CDATA encoded sections can also be selected
 assert_dom_encoded '#out-of-your-element'
 

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

@@ -70,6 +70,7 @@ module Rails
             message ||= "Expected: #{expected}\nActual: #{actual}"
             assert_not compare_doms(expected_dom, actual_dom, strict), message
           end
+          alias_method :refute_dom_equal, :assert_dom_not_equal
 
           protected
             def compare_doms(expected, actual, strict)

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

@@ -14,11 +14,11 @@ module Rails
 
             include Minitest::Assertions
 
-            def initialize(values, previous_selection = nil, &root_fallback)
+            def initialize(values, previous_selection = nil, refute: false, &root_fallback)
               @values = values
               @root = extract_root(previous_selection, root_fallback)
               extract_selectors
-              @tests = extract_equality_tests
+              @tests = extract_equality_tests(refute)
               @message = @values.shift
 
               if @message.is_a?(Hash)
@@ -51,14 +51,16 @@ module Rails
 
                 content_mismatch = nil
                 text_matches = tests.has_key?(:text)
+                html_matches = tests.has_key?(:html)
                 regex_matching = match_with.is_a?(Regexp)
 
                 remaining = matches.reject do |match|
                   # Preserve markup with to_s for html elements
-                  content = text_matches ? match.text : match.children.to_s
+                  content = text_matches ? match.text : match.inner_html
 
                   content.strip! unless NO_STRIP.include?(match.name)
                   content.delete_prefix!("\n") if text_matches && match.name == "textarea"
+                  collapse_html_whitespace!(content) unless NO_STRIP.include?(match.name) || html_matches
 
                   next if regex_matching ? (content =~ match_with) : (content == match_with)
                   content_mismatch ||= diff(match_with, content)
@@ -97,7 +99,7 @@ module Rails
                 @selector     = context.substitute!(selector, @values)
               end
 
-              def extract_equality_tests
+              def extract_equality_tests(refute)
                 comparisons = {}
                 case comparator = @values.shift
                 when Hash
@@ -113,7 +115,16 @@ module Rails
                   comparisons[:count] = 0
                 when NilClass, TrueClass
                   comparisons[:minimum] = 1
-                else raise ArgumentError, "I don't understand what you're trying to match"
+                else
+                  raise ArgumentError, "I don't understand what you're trying to match"
+                end
+
+                if refute
+                  if comparisons[:count] || (comparisons[:minimum] && !comparator.nil?) || comparisons[:maximum]
+                    raise ArgumentError, "Cannot use true, false, Integer, Range, :count, :minimum and :maximum when asserting that a selector does not match"
+                  end
+
+                  comparisons[:count] = 0
                 end
 
                 # By default we're looking for at least one match.
@@ -122,8 +133,19 @@ module Rails
                 else
                   comparisons[:minimum] ||= 1
                 end
+
+                if comparisons[:minimum] && comparisons[:maximum] && comparisons[:minimum] > comparisons[:maximum]
+                  raise ArgumentError, "Range begin or :minimum cannot be greater than Range end or :maximum"
+                end
+
+                @strict = comparisons[:strict]
+
                 comparisons
               end
+
+              def collapse_html_whitespace!(text)
+                text.gsub!(/\s+/, " ")
+              end
           end
         end
       end

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

@@ -164,20 +164,53 @@ module Rails
             @selected ||= nil
 
             selector = HTMLSelector.new(args, @selected) { nodeset document_root_element }
+            dom_assertions(selector, &block)
+          end
+          alias_method :assert_select, :assert_dom
+
+          # The negated form of +assert_dom+.
+          #
+          # === Equality Tests
+          #
+          # Supports the same equality tests as +assert_dom+ except for:
+          # * <tt>true</tt>
+          # * <tt>false</tt>
+          # * <tt>Integer</tt>
+          # * <tt>Range</tt>
+          # * <tt>:count</tt>
+          # * <tt>:minimum</tt>
+          # * <tt>:maximum</tt>
+          def assert_not_dom(*args, &block)
+            @selected ||= nil
 
+            selector = HTMLSelector.new(args, @selected, refute: true) { nodeset document_root_element }
+            dom_assertions(selector, &block)
+          end
+          alias_method :refute_dom, :assert_not_dom
+          alias_method :assert_not_select, :assert_not_dom
+          alias_method :refute_select, :assert_not_dom
+
+          private def dom_assertions(selector, &block)
             if selector.selecting_no_body?
               assert true
               return
             end
 
+            count, max = selector.tests.slice(:count, :maximum).values
+
             selector.select.tap do |matches|
               assert_size_match!(matches.size, selector.tests,
                 selector.css_selector, selector.message)
 
-              nest_selection(matches, &block) if block_given? && !matches.empty?
+              if block_given?
+                if count&.zero? || max&.zero?
+                  raise ArgumentError, "Cannot be called with a block when asserting that a selector does not match"
+                end
+
+                nest_selection(matches, &block) unless matches.empty?
+              end
             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.

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

@@ -3,7 +3,7 @@
 module Rails
   module Dom
     module Testing
-      VERSION = "2.2.0"
+      VERSION = "2.3.0"
     end
   end
 end

data/test/selector_assertions_test.rb

@@ -16,7 +16,7 @@ class AssertSelectTest < ActiveSupport::TestCase
   end
 
   #
-  # Test assert select.
+  # Test assert_select.
   #
 
   def test_assert_select
@@ -122,6 +122,19 @@ class AssertSelectTest < ActiveSupport::TestCase
     end
   end
 
+  def test_zero_counts_with_block
+    render_html "<div>foo</div>"
+
+    errors = [
+      assert_raises(ArgumentError) { assert_select("p", false) { nil } },
+      assert_raises(ArgumentError) { assert_select("p", 0) { nil } },
+      assert_raises(ArgumentError) { assert_select("p", count: 0) { nil } },
+      assert_raises(ArgumentError) { assert_select("p", 0..0) { nil } },
+      assert_raises(ArgumentError) { assert_select("p", minimum: 0, maximum: 0) { nil } }
+    ]
+    assert_equal ["Cannot be called with a block when asserting that a selector does not match"], errors.map(&:message).uniq
+  end
+
   def test_substitution_values
     render_html '<div id="1">foo</div><div id="2">foo</div>'
     assert_select "div:match('id', ?)", /\d+/ do |elements|
@@ -210,6 +223,115 @@ class AssertSelectTest < ActiveSupport::TestCase
     end
   end
 
+  def test_assert_select_with_invalid_range
+    render_html "<div>foo</div>"
+    error = assert_raises(ArgumentError) { assert_select("div", 2..1) { nil } }
+    assert_equal "Range begin or :minimum cannot be greater than Range end or :maximum", error.message
+  end
+
+  def test_assert_select_with_invalid_minimum_and_maximum
+    render_html "<div>foo</div>"
+    error = assert_raises(ArgumentError) { assert_select("div", maximum: 0) { nil } }
+    assert_equal "Range begin or :minimum cannot be greater than Range end or :maximum", error.message
+    error = assert_raises(ArgumentError) { assert_select("div", minimum: 2, maximum: 1) { nil } }
+    assert_equal "Range begin or :minimum cannot be greater than Range end or :maximum", error.message
+  end
+
+  def test_assert_select_text_equality_collapses_whitespace
+    render_html "<p>Some\n   line-broken\n   text</p>"
+
+    assert_nothing_raised do
+      assert_select "p", {
+        text: "Some line-broken text",
+      }, "Whitespace was not collapsed from text"
+    end
+
+    render_html "<p>Some<br><br>line-broken<br><br>text</p>"
+
+    assert_nothing_raised do
+      assert_select "p", {
+        text: "Someline-brokentext",
+      }, "<br> was not removed from text"
+    end
+  end
+
+  def test_assert_select_html_equality_respects_whitespace
+    render_html "<p>Some\n   line-broken\n   text</p>"
+
+    assert_nothing_raised do
+      assert_select "p", {
+        html: "Some\n   line-broken\n   text",
+      }, "Whitespace was collapsed from html"
+    end
+
+    render_html "<p>Some<br><br>line-broken<br><br>text</p>"
+
+    assert_nothing_raised do
+      assert_select "p", {
+        html: "Some<br><br>line-broken<br><br>text",
+      }, "<br> was removed from html"
+    end
+  end
+
+  #
+  # Test assert_not_select.
+  #
+
+  def test_assert_not_select
+    render_html '<div id="1"></div>'
+    assert_not_select "p"
+    assert_failure(/Expected exactly 0 elements matching "div", found 1/) { assert_not_select "div" }
+    assert_failure(/Expected exactly 0 elements matching "div#1", found 1/) { assert_not_select "div#1" }
+  end
+
+  def test_assert_not_select_with_true
+    render_html '<div id="1"></div>'
+    error = assert_raises(ArgumentError) { assert_not_select "div", true }
+    assert_equal "Cannot use true, false, Integer, Range, :count, :minimum and :maximum when asserting that a selector does not match", error.message
+  end
+
+  def test_assert_not_select_with_false
+    render_html '<div id="1"></div>'
+    error = assert_raises(ArgumentError) { assert_not_select "div", false }
+    assert_equal "Cannot use true, false, Integer, Range, :count, :minimum and :maximum when asserting that a selector does not match", error.message
+  end
+
+  def test_assert_not_select_with_integer
+    render_html '<div id="1"></div>'
+    error = assert_raises(ArgumentError) { assert_not_select "div", 1 }
+    assert_equal "Cannot use true, false, Integer, Range, :count, :minimum and :maximum when asserting that a selector does not match", error.message
+  end
+
+  def test_assert_not_select_with_range
+    render_html '<div id="1"></div>'
+    error = assert_raises(ArgumentError) { assert_not_select "div", 1..5 }
+    assert_equal "Cannot use true, false, Integer, Range, :count, :minimum and :maximum when asserting that a selector does not match", error.message
+  end
+
+  def test_assert_not_select_with_count
+    render_html '<div id="1"></div>'
+    error = assert_raises(ArgumentError) { assert_not_select "div", count: 1 }
+    assert_equal "Cannot use true, false, Integer, Range, :count, :minimum and :maximum when asserting that a selector does not match", error.message
+  end
+
+  def test_assert_not_select_with_minimum
+    render_html '<div id="1"></div>'
+    error = assert_raises(ArgumentError) { assert_not_select "div", minimum: 1 }
+    assert_equal "Cannot use true, false, Integer, Range, :count, :minimum and :maximum when asserting that a selector does not match", error.message
+  end
+
+  def test_assert_not_select_with_maximum
+    render_html '<div id="1"></div>'
+    error = assert_raises(ArgumentError) { assert_not_select "div", maximum: 1 }
+    assert_equal "Cannot use true, false, Integer, Range, :count, :minimum and :maximum when asserting that a selector does not match", error.message
+  end
+
+  def test_assert_not_select_with_block
+    render_html "<div>foo</div>"
+    error = assert_raises(ArgumentError) { assert_not_select("p") { nil } }
+    assert_equal "Cannot be called with a block when asserting that a selector does not match", error.message
+  end
+
   #
   # Test css_select.
   #

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails-dom-testing
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.3.0
 platform: ruby
 authors:
 - Rafael Mendonça França
 - Kasper Timm Hansen
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-08-03 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -95,7 +94,6 @@ homepage: https://github.com/rails/rails-dom-testing
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -110,8 +108,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
-signing_key: 
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Dom and Selector assertions for Rails applications
 test_files: