rails-dom-testing 2.0.3 → 2.2.0

data/lib/rails/dom/testing.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+require "active_support"
+require "active_support/core_ext/module/attribute_accessors"
+
+require "rails/dom/testing/assertions"
+
+module Rails
+  module Dom
+    module Testing
+      mattr_accessor :default_html_version, default: :html4
+
+      class << self
+        def html5_support?
+          defined?(Nokogiri::HTML5)
+        end
+
+        def html_document(html_version: nil)
+          parser_classes = { html4: Nokogiri::HTML4::Document }
+          parser_classes[:html5] = Nokogiri::HTML5::Document if html5_support?
+
+          choose_html_parser(parser_classes, html_version: html_version)
+        end
+
+        def html_document_fragment(html_version: nil)
+          parser_classes = { html4: Nokogiri::HTML4::DocumentFragment }
+          parser_classes[:html5] = Nokogiri::HTML5::DocumentFragment if html5_support?
+
+          choose_html_parser(parser_classes, html_version: html_version)
+        end
+
+        private
+          def choose_html_parser(parser_classes, html_version: nil)
+            html_version ||= Rails::Dom::Testing.default_html_version
+
+            case html_version
+            when :html4
+              parser_classes[:html4]
+            when :html5
+              unless Rails::Dom::Testing.html5_support?
+                raise NotImplementedError, "html5 parser is not supported on this platform"
+              end
+              parser_classes[:html5]
+            else
+              raise ArgumentError, "html_version must be :html4 or :html5, received #{html_version.inspect}"
+            end
+          end
+      end
+    end
+  end
+end

data/lib/rails-dom-testing.rb

@@ -1 +1,4 @@
-require 'rails/dom/testing/assertions'
+# frozen_string_literal: true
+
+require "rails/dom/testing"
+require "rails/dom/testing/railtie" if defined?(Rails::Railtie)

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
@@ -47,4 +48,166 @@ 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
+
+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