rails-dom-testing 2.1.0 → 2.2.0

data/test/dom_assertions_test.rb

@@ -1,5 +1,6 @@
-require 'test_helper'
-require 'rails/dom/testing/assertions/dom_assertions'
+# frozen_string_literal: true
+
+require "test_helper"
 
 class DomAssertionsTest < ActiveSupport::TestCase
   Assertion = Minitest::Assertion
@@ -11,7 +12,7 @@ class DomAssertionsTest < ActiveSupport::TestCase
   end
 
   def test_dom_equal
-    html = '<a></a>'
+    html = "<a></a>"
     assert_dom_equal(html, html.dup)
   end
 
@@ -22,7 +23,7 @@ class DomAssertionsTest < ActiveSupport::TestCase
   end
 
   def test_dom_not_equal
-    assert_dom_not_equal('<a></a>', '<b></b>')
+    assert_dom_not_equal("<a></a>", "<b></b>")
   end
 
   def test_unequal_doms_attributes_with_different_order_and_values
@@ -35,7 +36,7 @@ class DomAssertionsTest < ActiveSupport::TestCase
     message = "This is my message."
 
     e = assert_raises(Assertion) do
-      assert_dom_equal('<a></a>', '<b></b>', message)
+      assert_dom_equal("<a></a>", "<b></b>", message)
     end
 
     assert_equal e.message, message
@@ -123,3 +124,90 @@ world
     assert_dom_not_equal(with_space, without_space)
   end
 end
+
+class DomAssertionsHtmlParserSelectionTest < ActiveSupport::TestCase
+  include DomTestingHelpers
+  include Rails::Dom::Testing::Assertions::DomAssertions
+
+  def setup
+    super
+
+    # 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 = "<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>"
+  end
+
+  test "default value is html4" do
+    assert_equal(:html4, Rails::Dom::Testing.default_html_version)
+  end
+
+  test "default html4, no version specified" do
+    with_default_html_version(:html4) do
+      assert_dom_equal(@html4_result, @input)
+      assert_dom_not_equal(@html5_result, @input)
+    end
+  end
+
+  test "default html4, html4 specified" do
+    with_default_html_version(:html4) do
+      assert_dom_equal(@html4_result, @input, html_version: :html4)
+      assert_dom_not_equal(@html5_result, @input, html_version: :html4)
+    end
+  end
+
+  test "default html4, html5 specified" do
+    skip("html5 is not supported") unless Rails::Dom::Testing.html5_support?
+
+    with_default_html_version(:html4) do
+      assert_dom_equal(@html5_result, @input, html_version: :html5)
+      assert_dom_not_equal(@html4_result, @input, html_version: :html5)
+    end
+  end
+
+  test "default html5, no version specified" do
+    skip("html5 is not supported") unless Rails::Dom::Testing.html5_support?
+
+    with_default_html_version(:html5) do
+      assert_dom_equal(@html5_result, @input)
+      assert_dom_not_equal(@html4_result, @input)
+    end
+  end
+
+  test "default html5, html4 specified" do
+    with_default_html_version(:html5) do
+      assert_dom_equal(@html4_result, @input, html_version: :html4)
+      assert_dom_not_equal(@html5_result, @input, html_version: :html4)
+    end
+  end
+
+  test "default html5, html5 specified" do
+    skip("html5 is not supported") unless Rails::Dom::Testing.html5_support?
+
+    with_default_html_version(:html5) do
+      assert_dom_equal(@html5_result, @input, html_version: :html5)
+      assert_dom_not_equal(@html4_result, @input, html_version: :html5)
+    end
+  end
+
+  test "raise NotImplementedError html5 when not supported" do
+    Rails::Dom::Testing.stub(:html5_support?, false) do
+      with_default_html_version(:html5) do
+        assert_raises(NotImplementedError) { assert_dom_equal("a", "b") }
+        assert_raises(NotImplementedError) { assert_dom_equal("a", "b", html_version: :html5) }
+        assert_nothing_raised { assert_dom_equal(@html4_result, @input, html_version: :html4) }
+      end
+    end
+  end
+
+  test "default set to invalid" do
+    with_default_html_version(:html9) do
+      assert_raises(ArgumentError) { assert_dom_equal("a", "b") }
+    end
+  end
+
+  test "invalid version specified" do
+    assert_raises(ArgumentError) { assert_dom_equal("a", "b", html_version: :html9) }
+  end
+end

data/test/parser_selection_test.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class DomTestingParserSelectionTest < ActiveSupport::TestCase
+  include DomTestingHelpers
+
+  test "with default html4" do
+    with_default_html_version(:html4) do
+      assert_equal(Nokogiri::HTML4::Document, Rails::Dom::Testing.html_document)
+      assert_equal(Nokogiri::HTML4::DocumentFragment, Rails::Dom::Testing.html_document_fragment)
+
+      assert_equal(Nokogiri::HTML4::Document, Rails::Dom::Testing.html_document(html_version: :html4))
+      assert_equal(Nokogiri::HTML4::DocumentFragment, Rails::Dom::Testing.html_document_fragment(html_version: :html4))
+
+      if Rails::Dom::Testing.html5_support?
+        assert_equal(Nokogiri::HTML5::Document, Rails::Dom::Testing.html_document(html_version: :html5))
+        assert_equal(Nokogiri::HTML5::DocumentFragment, Rails::Dom::Testing.html_document_fragment(html_version: :html5))
+      else
+        assert_raises(NotImplementedError) { Rails::Dom::Testing.html_document(html_version: :html5) }
+        assert_raises(NotImplementedError) { Rails::Dom::Testing.html_document_fragment(html_version: :html5) }
+      end
+
+      assert_raises(ArgumentError) { Rails::Dom::Testing.html_document(html_version: :html9) }
+      assert_raises(ArgumentError) { Rails::Dom::Testing.html_document_fragment(html_version: :html9) }
+    end
+  end
+
+  test "with default html5" do
+    with_default_html_version(:html5) do
+      if Rails::Dom::Testing.html5_support?
+        assert_equal(Nokogiri::HTML5::Document, Rails::Dom::Testing.html_document)
+        assert_equal(Nokogiri::HTML5::DocumentFragment, Rails::Dom::Testing.html_document_fragment)
+      else
+        assert_raises(NotImplementedError) { Rails::Dom::Testing.html_document }
+        assert_raises(NotImplementedError) { Rails::Dom::Testing.html_document_fragment }
+      end
+
+      assert_equal(Nokogiri::HTML4::Document, Rails::Dom::Testing.html_document(html_version: :html4))
+      assert_equal(Nokogiri::HTML4::DocumentFragment, Rails::Dom::Testing.html_document_fragment(html_version: :html4))
+
+      if Rails::Dom::Testing.html5_support?
+        assert_equal(Nokogiri::HTML5::Document, Rails::Dom::Testing.html_document(html_version: :html5))
+        assert_equal(Nokogiri::HTML5::DocumentFragment, Rails::Dom::Testing.html_document_fragment(html_version: :html5))
+      else
+        assert_raises(NotImplementedError) { Rails::Dom::Testing.html_document(html_version: :html5) }
+        assert_raises(NotImplementedError) { Rails::Dom::Testing.html_document_fragment(html_version: :html5) }
+      end
+
+      assert_raises(ArgumentError) { Rails::Dom::Testing.html_document(html_version: :html9) }
+      assert_raises(ArgumentError) { Rails::Dom::Testing.html_document_fragment(html_version: :html9) }
+    end
+  end
+
+  test "with invalid default" do
+    with_default_html_version(:html8) do
+      assert_raises(ArgumentError) { Rails::Dom::Testing.html_document }
+      assert_raises(ArgumentError) { Rails::Dom::Testing.html_document_fragment }
+
+      assert_equal(Nokogiri::HTML4::Document, Rails::Dom::Testing.html_document(html_version: :html4))
+      assert_equal(Nokogiri::HTML4::DocumentFragment, Rails::Dom::Testing.html_document_fragment(html_version: :html4))
+
+      if Rails::Dom::Testing.html5_support?
+        assert_equal(Nokogiri::HTML5::Document, Rails::Dom::Testing.html_document(html_version: :html5))
+        assert_equal(Nokogiri::HTML5::DocumentFragment, Rails::Dom::Testing.html_document_fragment(html_version: :html5))
+      else
+        assert_raises(NotImplementedError) { Rails::Dom::Testing.html_document(html_version: :html5) }
+        assert_raises(NotImplementedError) { Rails::Dom::Testing.html_document_fragment(html_version: :html5) }
+      end
+
+      assert_raises(ArgumentError) { Rails::Dom::Testing.html_document(html_version: :html9) }
+      assert_raises(ArgumentError) { Rails::Dom::Testing.html_document_fragment(html_version: :html9) }
+    end
+  end
+end

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,13 +136,18 @@ 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 %Q{<div id="id_string">symbol</div><div id="1">numeric</div>}
+    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
@@ -151,19 +157,19 @@ class AssertSelectTest < ActiveSupport::TestCase
   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"
@@ -181,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
@@ -189,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
 
@@ -209,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
@@ -224,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
@@ -248,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
@@ -275,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.
@@ -302,23 +307,69 @@ 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>'
+    render_html "<html><head><title>Welcome</title></head><body><div></div></body></html>"
 
     assert_raises ArgumentError do
       assert_select "title", "Welcome", count: 1
@@ -330,7 +381,7 @@ EOF
   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_failure(/Expected exactly 1 element matching "div", found 0./) do
       assert_select "div", 1
     end
   end
@@ -348,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