rails-dom-testing 2.0.3 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 0af31466148a2f967def0233933062ca454b1bcb
-  data.tar.gz: 825ff206fc31a115d41c567614331e779ccc8d92
+SHA256:
+  metadata.gz: d8720c7b560a8e3acaa5ae87a7dbfb587fe47c156d8f49b9d319b2c089a3d987
+  data.tar.gz: f482fcae81574f5fedc71d6e46ce372f8f273eac9df50a40d565696db1a02209
 SHA512:
-  metadata.gz: 51291b7d5bf443fa4df3b9fa38ef92b84ecef5e434a77b9681f2b63bd3188aaf59d13b722e08a27e1f3a21fb1a2872d42a05a92e838c072d0059983edc4b6878
-  data.tar.gz: af4705e0a6acb6d1009ad3cdec42ab3dfc3eedb9e4a8ec28a4b112bbd0f1e53badfd8fa853a7146644d445c876b71b89fb4dd269e875e366c5d33f5850c55767
+  metadata.gz: bb404e501783f50dfd614101ee141ccc08665e2410fbd3c2e62c6859e4ed2edd2097169373b86d6deaefb63192385cf895d1ae0c512c69f65de760d38a8b6542
+  data.tar.gz: afc3f0247a26905b8aeb37fd94a9a0bd79f09b2ed334b539129f9566d3c25aed44e0e3a6a34f73c4ad0c6c485a24ae30e205b0aac14ff7e60b942be5d32d7663

data/README.md

@@ -2,29 +2,9 @@
 
 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:
-
-Nokogiri is slightly stricter about the format of CSS selectors than the previous implementation.
-
-Check the 4.2 release notes [section on `assert_select`](http://edgeguides.rubyonrails.org/4_2_release_notes.html#assert-select) for help.
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-    gem 'rails-dom-testing'
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install rails-dom-testing
-
 ## Usage
 
 ### Dom Assertions
@@ -41,21 +21,59 @@ 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.
 
+### HTML versions
+
+By default, assertions will use Nokogiri's HTML4 parser.
+
+If `Rails::Dom::Testing.default_html_version` is set to `:html5`, then the assertions will use
+Nokogiri's HTML5 parser. (If the HTML5 parser is not available on your platform, then a
+`NotImplementedError` will be raised.)
+
+When testing in a Rails application, the parser default can also be set by setting
+`Rails.application.config.dom_testing_default_html_version`.
+
+Some assertions support an `html_version:` keyword argument which can override the default for that
+assertion. For example:
+
+``` ruby
+# compare DOMs built with the HTML5 parser
+assert_dom_equal(expected, actual, html_version: :html5)
+
+# compare DOMs built with the HTML4 parser
+assert_dom_not_equal(expected, actual, html_version: :html4)
+```
+
+Please see documentation for individual assertions for more details.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rails-dom-testing'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rails-dom-testing
+
 ## 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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rails
   module Dom
     module Testing
@@ -6,44 +8,107 @@ module Rails
           # \Test two HTML strings for equivalency (e.g., equal even when attributes are in another order)
           #
           #   # 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)
-            expected_dom, actual_dom = fragment(expected), fragment(actual)
+          #   assert_dom_equal(
+          #     '<a href="http://www.example.com">Apples</a>',
+          #     link_to("Apples", "http://www.example.com"),
+          #   )
+          #
+          # By default, the matcher will not pay attention to whitespace in text nodes (e.g., spaces
+          # and newlines). If you want stricter matching with exact matching for whitespace, pass
+          # <tt>strict: true</tt>:
+          #
+          #   # these assertions will both pass
+          #   assert_dom_equal     "<div>\nfoo\n\</div>", "<div>foo</div>", strict: false
+          #   assert_dom_not_equal "<div>\nfoo\n\</div>", "<div>foo</div>", strict: true
+          #
+          # The DOMs are created using an HTML parser specified by
+          # Rails::Dom::Testing.default_html_version (either :html4 or :html5).
+          #
+          # When testing in a Rails application, the parser default can also be set by setting
+          # +Rails.application.config.dom_testing_default_html_version+.
+          #
+          # If you want to specify the HTML parser just for a particular assertion, pass
+          # <tt>html_version: :html4</tt> or <tt>html_version: :html5</tt> keyword arguments:
+          #
+          #   assert_dom_equal expected, actual, html_version: :html5
+          #
+          def assert_dom_equal(expected, actual, message = nil, strict: false, html_version: nil)
+            expected_dom, actual_dom = fragment(expected, html_version: html_version), fragment(actual, html_version: html_version)
             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)
-            expected_dom, actual_dom = fragment(expected), fragment(actual)
+          #   assert_dom_not_equal(
+          #     '<a href="http://www.example.com">Apples</a>',
+          #     link_to("Oranges", "http://www.example.com"),
+          #   )
+          #
+          # By default, the matcher will not pay attention to whitespace in text nodes (e.g., spaces
+          # and newlines). If you want stricter matching with exact matching for whitespace, pass
+          # <tt>strict: true</tt>:
+          #
+          #   # these assertions will both pass
+          #   assert_dom_equal     "<div>\nfoo\n\</div>", "<div>foo</div>", strict: false
+          #   assert_dom_not_equal "<div>\nfoo\n\</div>", "<div>foo</div>", strict: true
+          #
+          # The DOMs are created using an HTML parser specified by
+          # Rails::Dom::Testing.default_html_version (either :html4 or :html5).
+          #
+          # When testing in a Rails application, the parser default can also be set by setting
+          # +Rails.application.config.dom_testing_default_html_version+.
+          #
+          # If you want to specify the HTML parser just for a particular assertion, pass
+          # <tt>html_version: :html4</tt> or <tt>html_version: :html5</tt> keyword arguments:
+          #
+          #   assert_dom_not_equal expected, actual, html_version: :html5
+          #
+          def assert_dom_not_equal(expected, actual, message = nil, strict: false, html_version: nil)
+            expected_dom, actual_dom = fragment(expected, html_version: html_version), fragment(actual, html_version: html_version)
             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, strict)
+              expected_children = extract_children(expected, strict)
+              actual_children   = extract_children(actual, strict)
+              return false unless expected_children.size == actual_children.size
 
-            def compare_doms(expected, actual)
-              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
 
@@ -65,9 +130,8 @@ module Rails
             end
 
           private
-
-            def fragment(text)
-              Nokogiri::HTML::DocumentFragment.parse(text)
+            def fragment(text, html_version: nil)
+              Rails::Dom::Testing.html_document_fragment(html_version: html_version).parse(text)
             end
         end
       end

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

@@ -1,114 +1,132 @@
-require 'active_support/core_ext/module/attribute_accessors'
-require_relative 'substitution_context'
-
-class HTMLSelector #:nodoc:
-  attr_reader :css_selector, :tests, :message
-
-  def initialize(values, previous_selection = nil, &root_fallback)
-    @values = values
-    @root = extract_root(previous_selection, root_fallback)
-    extract_selectors
-    @tests = extract_equality_tests
-    @message = @values.shift
-
-    if @values.shift
-      raise ArgumentError, "Not expecting that last argument, you either have too many arguments, or they're the wrong type"
-    end
-  end
-
-  def selecting_no_body? #:nodoc:
-    # Nokogiri gives the document a body element. Which means we can't
-    # run an assertion expecting there to not be a body.
-    @selector == 'body' && @tests[:count] == 0
-  end
-
-  def select
-    filter @root.css(@selector, context)
-  end
-
-  private
-
-  NO_STRIP = %w{pre script style textarea}
-
-  mattr_reader(:context) { SubstitutionContext.new }
-
-  def filter(matches)
-    match_with = tests[:text] || tests[:html]
-    return matches if matches.empty? || !match_with
-
-    content_mismatch = nil
-    text_matches = tests.has_key?(:text)
-    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.strip! unless NO_STRIP.include?(match.name)
-      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)
-      true
-    end
-
-    @message ||= content_mismatch if remaining.empty?
-    Nokogiri::XML::NodeSet.new(matches.document, remaining)
-  end
-
-  def extract_root(previous_selection, root_fallback)
-    possible_root = @values.first
-
-    if possible_root == nil
-      raise ArgumentError, 'First argument is either selector or element ' \
-        'to select, but nil found. Perhaps you called assert_select with ' \
-        'an element that does not exist?'
-    elsif possible_root.respond_to?(:css)
-      @values.shift # remove the root, so selector is the first argument
-      possible_root
-    elsif previous_selection
-      previous_selection
-    else
-      root_fallback.call
-    end
-  end
-
-  def extract_selectors
-    selector = @values.shift
-
-    unless selector.is_a? String
-      raise ArgumentError, "Expecting a selector as the first argument"
-    end
-
-    @css_selector = context.substitute!(selector, @values.dup, true)
-    @selector     = context.substitute!(selector, @values)
-  end
-
-  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"
-    end
-
-    # By default we're looking for at least one match.
-    if comparisons[:count]
-      comparisons[:minimum] = comparisons[:maximum] = comparisons[:count]
-    else
-      comparisons[:minimum] ||= 1
+# frozen_string_literal: true
+
+require "minitest"
+
+require_relative "substitution_context"
+
+module Rails
+  module Dom
+    module Testing
+      module Assertions
+        module SelectorAssertions
+          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)
+              extract_selectors
+              @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
+            end
+
+            def selecting_no_body? # :nodoc:
+              # Nokogiri gives the document a body element. Which means we can't
+              # run an assertion expecting there to not be a body.
+              @selector == "body" && @tests[:count] == 0
+            end
+
+            def select
+              filter @root.css(@selector, context)
+            end
+
+            private
+              NO_STRIP = %w{pre script style textarea}
+
+              mattr_reader(:context) { SubstitutionContext.new }
+
+              def filter(matches)
+                match_with = tests[:text] || tests[:html]
+                return matches if matches.empty? || !match_with
+
+                content_mismatch = nil
+                text_matches = tests.has_key?(:text)
+                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.strip! unless NO_STRIP.include?(match.name)
+                  content.delete_prefix!("\n") if text_matches && match.name == "textarea"
+
+                  next if regex_matching ? (content =~ match_with) : (content == match_with)
+                  content_mismatch ||= diff(match_with, content)
+                  true
+                end
+
+                @message ||= content_mismatch if remaining.empty?
+                Nokogiri::XML::NodeSet.new(matches.document, remaining)
+              end
+
+              def extract_root(previous_selection, root_fallback)
+                possible_root = @values.first
+
+                if possible_root == nil
+                  raise ArgumentError, "First argument is either selector or element " \
+                    "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
+                  possible_root
+                elsif previous_selection
+                  previous_selection
+                else
+                  root_fallback.call
+                end
+              end
+
+              def extract_selectors
+                selector = @values.shift
+
+                unless selector.is_a? String
+                  raise ArgumentError, "Expecting a selector as the first argument"
+                end
+
+                @css_selector = context.substitute!(selector, @values.dup, true)
+                @selector     = context.substitute!(selector, @values)
+              end
+
+              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"
+                end
+
+                # By default we're looking for at least one match.
+                if comparisons[:count]
+                  comparisons[:minimum] = comparisons[:maximum] = comparisons[:count]
+                else
+                  comparisons[:minimum] ||= 1
+                end
+                comparisons
+              end
+          end
+        end
+      end
     end
-    comparisons
   end
 end

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

@@ -1,33 +1,44 @@
-class SubstitutionContext
-  def initialize
-    @substitute = '?'
-  end
+# frozen_string_literal: true
 
-  def substitute!(selector, values, format_for_presentation = false)
-    selector = selector.dup
+module Rails
+  module Dom
+    module Testing
+      module Assertions
+        module SelectorAssertions
+          class SubstitutionContext # :nodoc:
+            def initialize
+              @substitute = "?"
+            end
 
-    while !values.empty? && substitutable?(values.first) && selector.index(@substitute)
-      selector.sub! @substitute, matcher_for(values.shift, format_for_presentation)
-    end
+            def substitute!(selector, values, format_for_presentation = false)
+              selector.gsub @substitute do |match|
+                next match[0] if values.empty? || !substitutable?(values.first)
+                matcher_for(values.shift, format_for_presentation)
+              end
+            end
 
-    selector
-  end
+            def match(matches, attribute, matcher)
+              matches.find_all { |node| node[attribute] =~ Regexp.new(matcher) }
+            end
 
-  def match(matches, attribute, matcher)
-    matches.find_all { |node| node[attribute] =~ Regexp.new(matcher) }
-  end
+            private
+              def matcher_for(value, format_for_presentation)
+                # Nokogiri doesn't like arbitrary values without quotes, hence inspect.
+                if format_for_presentation
+                  value.inspect # Avoid to_s so Regexps aren't put in quotes.
+                elsif value.is_a?(Regexp)
+                  "\"#{value}\""
+                else
+                  value.to_s.inspect
+                end
+              end
 
-  private
-    def matcher_for(value, format_for_presentation)
-      # Nokogiri doesn't like arbitrary values without quotes, hence inspect.
-      if format_for_presentation
-        value.inspect # Avoid to_s so Regexps aren't put in quotes.
-      else
-        value.to_s.inspect
+              def substitutable?(value)
+                [ Symbol, Numeric, String, Regexp ].any? { |type| value.is_a? type }
+              end
+          end
+        end
       end
     end
-
-    def substitutable?(value)
-      value.is_a?(String) || value.is_a?(Regexp)
-    end
+  end
 end