rails-dom-testing 2.0.3 → 2.2.0

data/test/selector_assertions_test.rb

@@ -1,11 +1,12 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
-require 'test_helper'
-require 'rails/dom/testing/assertions/selector_assertions'
+require "test_helper"
 
 class AssertSelectTest < ActiveSupport::TestCase
   Assertion = Minitest::Assertion
 
+  include DomTestingHelpers
   include Rails::Dom::Testing::Assertions::SelectorAssertions
 
   def assert_failure(message, &block)
@@ -19,19 +20,19 @@ class AssertSelectTest < ActiveSupport::TestCase
   #
 
   def test_assert_select
-    render_html %Q{<div id="1"></div><div id="2"></div>}
+    render_html '<div id="1"></div><div id="2"></div>'
     assert_select "div", 2
-    assert_failure(/Expected at least 1 element matching \"p\", found 0/) { assert_select "p" }
+    assert_failure(/Expected at least 1 element matching "p", found 0/) { assert_select "p" }
   end
 
   def test_equality_integer
-    render_html %Q{<div id="1"></div><div id="2"></div>}
-    assert_failure(/Expected exactly 3 elements matching \"div\", found 2/) { assert_select "div", 3 }
-    assert_failure(/Expected exactly 0 elements matching \"div\", found 2/) { assert_select "div", 0 }
+    render_html '<div id="1"></div><div id="2"></div>'
+    assert_failure(/Expected exactly 3 elements matching "div", found 2/) { assert_select "div", 3 }
+    assert_failure(/Expected exactly 0 elements matching "div", found 2/) { assert_select "div", 0 }
   end
 
   def test_equality_true_false
-    render_html %Q{<div id="1"></div><div id="2"></div>}
+    render_html '<div id="1"></div><div id="2"></div>'
     assert_nothing_raised    { assert_select "div" }
     assert_raise(Assertion) { assert_select "p" }
     assert_nothing_raised    { assert_select "div", true }
@@ -49,21 +50,21 @@ class AssertSelectTest < ActiveSupport::TestCase
   end
 
   def test_equality_false_message
-    render_html %Q{<div id="1"></div><div id="2"></div>}
-    assert_failure(/Expected exactly 0 elements matching \"div\", found 2/) { assert_select "div", false }
+    render_html '<div id="1"></div><div id="2"></div>'
+    assert_failure(/Expected exactly 0 elements matching "div", found 2/) { assert_select "div", false }
   end
 
   def test_equality_string_and_regexp
-    render_html %Q{<div id="1">foo</div><div id="2">foo</div>}
+    render_html '<div id="1">foo</div><div id="2">foo</div>'
     assert_nothing_raised    { assert_select "div", "foo" }
     assert_raise(Assertion) { assert_select "div", "bar" }
-    assert_nothing_raised    { assert_select "div", :text=>"foo" }
-    assert_raise(Assertion) { assert_select "div", :text=>"bar" }
+    assert_nothing_raised    { assert_select "div", text: "foo" }
+    assert_raise(Assertion) { assert_select "div", text: "bar" }
     assert_nothing_raised    { assert_select "div", /(foo|bar)/ }
     assert_raise(Assertion) { assert_select "div", /foobar/ }
-    assert_nothing_raised    { assert_select "div", :text=>/(foo|bar)/ }
-    assert_raise(Assertion) { assert_select "div", :text=>/foobar/ }
-    assert_raise(Assertion) { assert_select "p", :text=>/foobar/ }
+    assert_nothing_raised    { assert_select "div", text: /(foo|bar)/ }
+    assert_raise(Assertion) { assert_select "div", text: /foobar/ }
+    assert_raise(Assertion) { assert_select "p", text: /foobar/ }
   end
 
   def test_equality_of_html
@@ -72,57 +73,57 @@ class AssertSelectTest < ActiveSupport::TestCase
     html = "<em>\"This is <strong>not</strong> a big problem,\"</em> he said."
     assert_nothing_raised    { assert_select "p", text }
     assert_raise(Assertion) { assert_select "p", html }
-    assert_nothing_raised    { assert_select "p", :html=>html }
-    assert_raise(Assertion) { assert_select "p", :html=>text }
+    assert_nothing_raised    { assert_select "p", html: html }
+    assert_raise(Assertion) { assert_select "p", html: text }
     # No stripping for pre.
     render_html %Q{<pre>\n<em>"This is <strong>not</strong> a big problem,"</em> he said.\n</pre>}
     text = "\n\"This is not a big problem,\" he said.\n"
     html = "\n<em>\"This is <strong>not</strong> a big problem,\"</em> he said.\n"
     assert_nothing_raised    { assert_select "pre", text }
     assert_raise(Assertion) { assert_select "pre", html }
-    assert_nothing_raised    { assert_select "pre", :html=>html }
-    assert_raise(Assertion) { assert_select "pre", :html=>text }
+    assert_nothing_raised    { assert_select "pre", html: html }
+    assert_raise(Assertion) { assert_select "pre", html: text }
   end
 
   def test_strip_textarea
-    render_html %Q{<textarea>\n\nfoo\n</textarea>}
+    render_html "<textarea>\n\nfoo\n</textarea>"
     assert_select "textarea", "\nfoo\n"
-    render_html %Q{<textarea>\nfoo</textarea>}
+    render_html "<textarea>\nfoo</textarea>"
     assert_select "textarea", "foo"
   end
 
   def test_counts
-    render_html %Q{<div id="1">foo</div><div id="2">foo</div>}
+    render_html '<div id="1">foo</div><div id="2">foo</div>'
     assert_nothing_raised               { assert_select "div", 2 }
-    assert_failure(/Expected exactly 3 elements matching \"div\", found 2/) do
+    assert_failure(/Expected exactly 3 elements matching "div", found 2/) do
       assert_select "div", 3
     end
     assert_nothing_raised               { assert_select "div", 1..2 }
-    assert_failure(/Expected between 3 and 4 elements matching \"div\", found 2/) do
+    assert_failure(/Expected between 3 and 4 elements matching "div", found 2/) do
       assert_select "div", 3..4
     end
-    assert_nothing_raised               { assert_select "div", :count=>2 }
-    assert_failure(/Expected exactly 3 elements matching \"div\", found 2/) do
-      assert_select "div", :count=>3
+    assert_nothing_raised               { assert_select "div", count: 2 }
+    assert_failure(/Expected exactly 3 elements matching "div", found 2/) do
+      assert_select "div", count: 3
     end
-    assert_nothing_raised               { assert_select "div", :minimum=>1 }
-    assert_nothing_raised               { assert_select "div", :minimum=>2 }
-    assert_failure(/Expected at least 3 elements matching \"div\", found 2/) do
-      assert_select "div", :minimum=>3
+    assert_nothing_raised               { assert_select "div", minimum: 1 }
+    assert_nothing_raised               { assert_select "div", minimum: 2 }
+    assert_failure(/Expected at least 3 elements matching "div", found 2/) do
+      assert_select "div", minimum: 3
     end
-    assert_nothing_raised               { assert_select "div", :maximum=>2 }
-    assert_nothing_raised               { assert_select "div", :maximum=>3 }
-    assert_failure(/Expected at most 1 element matching \"div\", found 2/) do
-      assert_select "div", :maximum=>1
+    assert_nothing_raised               { assert_select "div", maximum: 2 }
+    assert_nothing_raised               { assert_select "div", maximum: 3 }
+    assert_failure(/Expected at most 1 element matching "div", found 2/) do
+      assert_select "div", maximum: 1
     end
-    assert_nothing_raised               { assert_select "div", :minimum=>1, :maximum=>2 }
-    assert_failure(/Expected between 3 and 4 elements matching \"div\", found 2/) do
-      assert_select "div", :minimum=>3, :maximum=>4
+    assert_nothing_raised               { assert_select "div", minimum: 1, maximum: 2 }
+    assert_failure(/Expected between 3 and 4 elements matching "div", found 2/) do
+      assert_select "div", minimum: 3, maximum: 4
     end
   end
 
   def test_substitution_values
-    render_html %Q{<div id="1">foo</div><div id="2">foo</div>}
+    render_html '<div id="1">foo</div><div id="2">foo</div>'
     assert_select "div:match('id', ?)", /\d+/ do |elements|
       assert_equal 2, elements.size
     end
@@ -135,20 +136,40 @@ class AssertSelectTest < ActiveSupport::TestCase
     end
   end
 
+  def test_substitution_value_with_quotes
+    render_html '<input placeholder="placeholder with &quot;quotes&quot;" />'
+    assert_select "input[placeholder=?]", 'placeholder with "quotes"'
+  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 '<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>'
+    render_html "<a></a>"
 
-    assert_select 'a'
+    assert_select "a"
   end
 
   def test_assert_select_root_xml
     render_xml '<rss version="2.0"></rss>'
 
-    assert_select 'rss'
+    assert_select "rss"
   end
 
   def test_nested_assert_select
-    render_html %Q{<div id="1">foo</div><div id="2">foo</div>}
+    render_html '<div id="1">foo</div><div id="2">foo</div>'
     assert_select "div" do |elements|
       assert_equal 2, elements.size
       assert_select elements, "#1"
@@ -166,7 +187,7 @@ class AssertSelectTest < ActiveSupport::TestCase
       end
     end
 
-    assert_failure(/Expected at least 1 element matching \"#4\", found 0\./) do
+    assert_failure(/Expected at least 1 element matching "#4", found 0\./) do
       assert_select "div" do
         assert_select "#4"
       end
@@ -174,18 +195,18 @@ class AssertSelectTest < ActiveSupport::TestCase
   end
 
   def test_assert_select_text_match
-    render_html %Q{<div id="1"><span>foo</span></div><div id="2"><span>bar</span></div>}
+    render_html '<div id="1"><span>foo</span></div><div id="2"><span>bar</span></div>'
     assert_select "div" do
       assert_nothing_raised    { assert_select "div", "foo" }
       assert_nothing_raised    { assert_select "div", "bar" }
       assert_nothing_raised    { assert_select "div", /\w*/ }
-      assert_nothing_raised    { assert_select "div", :text => /\w*/, :count=>2 }
-      assert_raise(Assertion)  { assert_select "div", :text=>"foo", :count=>2 }
-      assert_nothing_raised    { assert_select "div", :html=>"<span>bar</span>" }
-      assert_nothing_raised    { assert_select "div", :html=>"<span>bar</span>" }
-      assert_nothing_raised    { assert_select "div", :html=>/\w*/ }
-      assert_nothing_raised    { assert_select "div", :html=>/\w*/, :count=>2 }
-      assert_raise(Assertion)  { assert_select "div", :html=>"<span>foo</span>", :count=>2 }
+      assert_nothing_raised    { assert_select "div", text: /\w*/, count: 2 }
+      assert_raise(Assertion)  { assert_select "div", text: "foo", count: 2 }
+      assert_nothing_raised    { assert_select "div", html: "<span>bar</span>" }
+      assert_nothing_raised    { assert_select "div", html: "<span>bar</span>" }
+      assert_nothing_raised    { assert_select "div", html: /\w*/ }
+      assert_nothing_raised    { assert_select "div", html: /\w*/, count: 2 }
+      assert_raise(Assertion)  { assert_select "div", html: "<span>foo</span>", count: 2 }
     end
   end
 
@@ -194,13 +215,13 @@ class AssertSelectTest < ActiveSupport::TestCase
   #
 
   def test_css_select
-    render_html %Q{<div id="1"></div><div id="2"></div>}
+    render_html '<div id="1"></div><div id="2"></div>'
     assert_equal 2, css_select("div").size
     assert_equal 0, css_select("p").size
   end
 
   def test_nested_css_select
-    render_html %Q{<div id="1">foo</div><div id="2">foo</div>}
+    render_html '<div id="1">foo</div><div id="2">foo</div>'
     assert_select "div:match('id', ?)", /\d+/ do |elements|
       assert_equal 1, css_select(elements[0], "div").size
       assert_equal 1, css_select(elements[1], "div").size
@@ -209,10 +230,10 @@ class AssertSelectTest < ActiveSupport::TestCase
       assert_equal 2, css_select("div").size
       css_select("div").each do |element|
         # Testing as a group is one thing
-        assert !css_select("#1,#2").empty?
+        assert_not css_select("#1,#2").empty?
         # Testing individually is another
-        assert !css_select("#1").empty?
-        assert !css_select("#2").empty?
+        assert_not css_select("#1").empty?
+        assert_not css_select("#2").empty?
       end
     end
   end
@@ -233,13 +254,13 @@ class AssertSelectTest < ActiveSupport::TestCase
   end
 
   def test_nested_assert_select_with_match_failure_shows_nice_regex
-    render_html %Q{<div id="1">foo</div>}
+    render_html '<div id="1">foo</div>'
 
     error = assert_raises Minitest::Assertion do
       assert_select "div:match('id', ?)", /wups/
     end
 
-    assert_match %Q{div:match('id', /wups/)}, error.message
+    assert_match "div:match('id', /wups/)", error.message
   end
 
   def test_feed_item_encoded
@@ -260,12 +281,11 @@ class AssertSelectTest < ActiveSupport::TestCase
     </item>
   </channel>
 </rss>
-EOF
+    EOF
 
     assert_select "channel item description" do
-
       assert_select_encoded do
-        assert_select "p", :count=>2, :text=>/Test/
+        assert_select "p", count: 2, text: /Test/
       end
 
       # Test individually.
@@ -287,19 +307,83 @@ EOF
     end
   end
 
+  def test_feed_item_encoded_with_html_version
+    # https://html.spec.whatwg.org/multipage/parsing.html#an-introduction-to-error-handling-and-strange-cases-in-the-parser
+    # we use these results to assert that we're invoking the expected parser.
+    input = CGI.escapeHTML("<p>1<b>2<i>3</b>4</i>5</p>")
+    html4_result = jruby? ? "<p>1<b>2<i>3</i></b><i>4</i>5</p>" : "<p>1<b>2<i>3</i></b>45</p>"
+    html5_result = jruby? ? nil                                 : "<p>1<b>2<i>3</i></b><i>4</i>5</p>"
+
+    render_xml(<<~XML)
+      <root>
+        <contents>#{input}</contents>
+      </root>
+    XML
+
+    with_default_html_version(:html4) do
+      assert_select "root contents" do
+        assert_select_encoded do |contents|
+          assert_equal(html4_result, contents.to_html)
+        end
+
+        assert_select_encoded(html_version: :html4) do |contents|
+          assert_equal(html4_result, contents.to_html)
+        end
+
+        assert_select_encoded(html_version: :html5) do |contents|
+          assert_equal(html5_result, contents.to_html)
+        end if Rails::Dom::Testing.html5_support?
+      end
+    end
+
+    with_default_html_version(:html5) do
+      assert_select "root contents" do
+        assert_select_encoded do |contents|
+          assert_equal(html5_result, contents.to_html)
+        end if Rails::Dom::Testing.html5_support?
+
+        assert_select_encoded(html_version: :html4) do |contents|
+          assert_equal(html4_result, contents.to_html)
+        end
+
+        assert_select_encoded(html_version: :html5) do |contents|
+          assert_equal(html5_result, contents.to_html)
+        end if Rails::Dom::Testing.html5_support?
+      end
+    end
+  end
+
   def test_body_not_present_in_empty_document
-    render_html '<div></div>'
-    assert_select 'body', 0
+    render_html "<div></div>"
+    assert_select "body", 0
   end
 
   def test_body_class_can_be_tested
     render_html '<body class="foo"></body>'
-    assert_select '.foo'
+    assert_select ".foo"
   end
 
   def test_body_class_can_be_tested_with_html
     render_html '<html><body class="foo"><div></div></body></html>'
-    assert_select '.foo'
+    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
@@ -315,7 +399,7 @@ EOF
       @html_document = if content_type == :xml
         Nokogiri::XML::Document.parse(content)
       else
-        Nokogiri::HTML::Document.parse(content)
+        Rails::Dom::Testing.html_document.parse(content)
       end
     end
 

data/test/test_helper.rb

@@ -1,6 +1,23 @@
-require 'nokogiri'
-require 'active_support'
-require 'active_support/test_case'
-require 'minitest/autorun'
+# frozen_string_literal: true
+
+require "rails-dom-testing"
+require "active_support/test_case"
+require "minitest/autorun"
 
 ActiveSupport::TestCase.test_order = :random
+
+module DomTestingHelpers
+  def jruby?
+    !! Nokogiri.jruby?
+  end
+
+  def with_default_html_version(version)
+    old_version = Rails::Dom::Testing.default_html_version
+    begin
+      Rails::Dom::Testing.default_html_version = version
+      yield
+    ensure
+      Rails::Dom::Testing.default_html_version = old_version
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-dom-testing
 version: !ruby/object:Gem::Version
-  version: 2.0.3
+  version: 2.2.0
 platform: ruby
 authors:
 - Rafael Mendonça França
@@ -9,50 +9,50 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-10 00:00:00.000000000 Z
+date: 2023-08-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: nokogiri
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: 5.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: 5.0.0
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.2.0
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.2.0
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: nokogiri
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
-  type: :development
+        version: '1.6'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '1.6'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -67,22 +67,8 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-description: " This gem can compare doms and assert certain elements exists in doms
-  using Nokogiri. "
+description: This gem can compare doms and assert certain elements exists in doms
+  using Nokogiri.
 email:
 - rafaelmfranca@gmail.com
 - kaspth@gmail.com
@@ -93,14 +79,16 @@ files:
 - MIT-LICENSE
 - README.md
 - lib/rails-dom-testing.rb
+- lib/rails/dom/testing.rb
 - lib/rails/dom/testing/assertions.rb
 - lib/rails/dom/testing/assertions/dom_assertions.rb
 - lib/rails/dom/testing/assertions/selector_assertions.rb
-- lib/rails/dom/testing/assertions/selector_assertions/count_describable.rb
 - lib/rails/dom/testing/assertions/selector_assertions/html_selector.rb
 - lib/rails/dom/testing/assertions/selector_assertions/substitution_context.rb
+- lib/rails/dom/testing/railtie.rb
 - lib/rails/dom/testing/version.rb
 - test/dom_assertions_test.rb
+- test/parser_selection_test.rb
 - test/selector_assertions_test.rb
 - test/test_helper.rb
 homepage: https://github.com/rails/rails-dom-testing
@@ -115,19 +103,19 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !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
 test_files:
 - test/dom_assertions_test.rb
+- test/parser_selection_test.rb
 - test/selector_assertions_test.rb
 - test/test_helper.rb

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

@@ -1,32 +0,0 @@
-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)
-                  "between #{min} and #{max} elements"
-                elsif min && max && max == min && count
-                  "exactly #{count} #{pluralize_element(min)}"
-                elsif min && !(min == 1 && max == 1)
-                  "at least #{min} #{pluralize_element(min)}"
-                elsif max
-                  "at most #{max} #{pluralize_element(max)}"
-                end
-              end
-
-              def pluralize_element(quantity)
-                quantity == 1 ? 'element' : 'elements'
-              end
-          end
-        end
-      end
-    end
-  end
-end