rails-dom-testing 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e4c5e946843592cec1b0b7e17a9dc5fe9b2b0ceb
+  data.tar.gz: 4cae76910af7476691d495a0ab84863e363824e3
+SHA512:
+  metadata.gz: d4ead231de2ed2c888eba70d866eae3a58a7eb853c5863b67278a87e4b164beae052af93c3c6c36b51ef198964a7613b8c874ee9a3fc60ec0168484ce92b5e10
+  data.tar.gz: 7744ed519a6cff2f3e77395aced9a5d104e034ebddb7370897f53ad68d55f00917bfff1891fe8d4f494754f23630b7899c0afd1147c49dbbf7b2460dd8feb5a8

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+# 1.0.0
+
+* First Release.

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Kasper Timm Hansen
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,66 @@
+# Rails::Dom::Testing
+[![Build Status](https://travis-ci.org/rails/rails-dom-testing.svg)](https://travis-ci.org/rails/rails-dom-testing)
+
+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`.
+
+
+## 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
+
+```ruby
+assert_dom_equal '<h1>Lingua França</h1>', '<h1>Lingua França</h1>'
+
+assert_dom_not_equal '<h1>Portuguese</h1>', '<h1>Danish</h1>'
+```
+
+### Selector Assertions
+
+```ruby
+# 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'
+
+# elements in CDATA encoded sections can also be selected
+assert_select_encoded '#out-of-your-element'
+
+# assert elements within an html email exists
+assert_select_email '#you-got-mail'
+```
+
+The documentation in [selector_assertions.rb](https://github.com/kaspth/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.
+
+## Read more
+
+Under the hood the doms are parsed with Nokogiri and you'll generally be working with these two classes:
+- [`Nokogiri::XML::Node`](http://nokogiri.org/Nokogiri/XML/Node.html)
+- [`Nokogiri::XML::NodeSet`](http://nokogiri.org/Nokogiri/XML/NodeSet.html)
+
+Read more about Nokogiri:
+- [Nokogiri](http://nokogiri.org)
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/lib/rails-dom-testing.rb

@@ -0,0 +1 @@
+require 'rails/dom/testing/assertions'

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

@@ -0,0 +1,18 @@
+require 'active_support/concern'
+require 'nokogiri'
+
+module Rails
+  module Dom
+    module Testing
+      module Assertions
+        autoload :DomAssertions, 'rails/dom/testing/assertions/dom_assertions'
+        autoload :SelectorAssertions, 'rails/dom/testing/assertions/selector_assertions'
+
+        extend ActiveSupport::Concern
+
+        include DomAssertions
+        include SelectorAssertions
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+module Rails
+  module Dom
+    module Testing
+      module Assertions
+        module DomAssertions
+          # \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)
+            message ||= "Expected: #{expected}\nActual: #{actual}"
+            assert compare_doms(expected_dom, actual_dom), 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)
+            message ||= "Expected: #{expected}\nActual: #{actual}"
+            assert_not compare_doms(expected_dom, actual_dom), message
+          end
+
+          protected
+
+            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])
+              end
+
+              true
+            end
+
+            def equal_children?(child, other_child)
+              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)
+              else
+                child.to_s == other_child.to_s
+              end
+            end
+
+            def equal_attribute_nodes?(nodes, other_nodes)
+              return false unless nodes.size == other_nodes.size
+
+              nodes = nodes.sort_by(&:name)
+              other_nodes = other_nodes.sort_by(&:name)
+
+              nodes.each_with_index do |attr, i|
+                return false unless equal_attribute?(attr, other_nodes[i])
+              end
+
+              true
+            end
+
+            def equal_attribute?(attr, other_attr)
+              attr.name == other_attr.name && attr.value == other_attr.value
+            end
+
+          private
+
+            def fragment(text)
+              Nokogiri::HTML::DocumentFragment.parse(text)
+            end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,339 @@
+require 'active_support/deprecation'
+require_relative 'selector_assertions/html_selector'
+
+module Rails
+  module Dom
+    module Testing
+      module Assertions
+        # Adds the +assert_select+ method for use in Rails functional
+        # test cases, which can be used to make assertions on the response HTML of a controller
+        # action. You can also call +assert_select+ within another +assert_select+ to
+        # make assertions on elements selected by the enclosing assertion.
+        #
+        # Use +css_select+ to select elements without making an assertions, either
+        # from the response HTML or elements selected by the enclosing assertion.
+        #
+        # In addition to HTML responses, you can make the following assertions:
+        #
+        # * +assert_select_encoded+ - Assertions on HTML encoded inside XML, for example for dealing with feed item descriptions.
+        # * +assert_select_email+ - Assertions on the HTML body of an e-mail.
+        module SelectorAssertions
+
+        # Select and return all matching elements.
+        #
+        # If called with a single argument, uses that argument as a selector.
+        # Called without an element +css_select+ selects from
+        # the element returned in +document_root_element+
+        #
+        # The default implementation of +document_root_element+ raises an exception explaining this.
+        #
+        # Returns an empty Nokogiri::XML::NodeSet if no match is found.
+        #
+        # If called with two arguments, uses the first argument as the root
+        # element and the second argument as the selector. Attempts to match the
+        # root element and any of its children.
+        # Returns an empty Nokogiri::XML::NodeSet if no match is found.
+        #
+        # The selector may be a CSS selector expression (String).
+        # css_select returns nil if called with an invalid css selector.
+        #
+        #   # Selects all div tags
+        #   divs = css_select("div")
+        #
+        #   # Selects all paragraph tags and does something interesting
+        #   pars = css_select("p")
+        #   pars.each do |par|
+        #     # Do something fun with paragraphs here...
+        #   end
+        #
+        #   # Selects all list items in unordered lists
+        #   items = css_select("ul>li")
+        #
+        #   # Selects all form tags and then all inputs inside the form
+        #   forms = css_select("form")
+        #   forms.each do |form|
+        #     inputs = css_select(form, "input")
+        #     ...
+        #   end
+        def css_select(*args)
+          raise ArgumentError, "you at least need a selector argument" if args.empty?
+
+          root = args.size == 1 ? document_root_element : args.shift
+          selector = args.first
+
+          catch_invalid_selector do
+            nodeset(root).css(selector)
+          end
+        end
+
+        # An assertion that selects elements and makes one or more equality tests.
+        #
+        # If the first argument is an element, selects all matching elements
+        # starting from (and including) that element and all its children in
+        # depth-first order.
+        #
+        # If no element is specified +assert_select+ selects from
+        # the element returned in +document_root_element+
+        # unless +assert_select+ is called from within an +assert_select+ block.
+        # Override +document_root_element+ to tell +assert_select+ what to select from.
+        # The default implementation raises an exception explaining this.
+        #
+        # When called with a block +assert_select+ passes an array of selected elements
+        # to the block. Calling +assert_select+ from the block, with no element specified,
+        # runs the assertion on the complete set of elements selected by the enclosing assertion.
+        # Alternatively the array may be iterated through so that +assert_select+ can be called
+        # separately for each element.
+        #
+        #
+        # ==== Example
+        # If the response contains two ordered lists, each with four list elements then:
+        #   assert_select "ol" do |elements|
+        #     elements.each do |element|
+        #       assert_select element, "li", 4
+        #     end
+        #   end
+        #
+        # will pass, as will:
+        #   assert_select "ol" do
+        #     assert_select "li", 8
+        #   end
+        #
+        # The selector may be a CSS selector expression (String) or an expression
+        # with substitution values (Array).
+        # Substitution uses a custom pseudo class match. Pass in whatever attribute you want to match (enclosed in quotes) and a ? for the substitution.
+        # assert_select returns nil if called with an invalid css selector.
+        #
+        # assert_select "div:match('id', ?)", /\d+/
+        #
+        # === Equality Tests
+        #
+        # The equality test may be one of the following:
+        # * <tt>true</tt> - Assertion is true if at least one element selected.
+        # * <tt>false</tt> - Assertion is true if no element selected.
+        # * <tt>String/Regexp</tt> - Assertion is true if the text value of at least
+        #   one element matches the string or regular expression.
+        # * <tt>Integer</tt> - Assertion is true if exactly that number of
+        #   elements are selected.
+        # * <tt>Range</tt> - Assertion is true if the number of selected
+        #   elements fit the range.
+        # If no equality test specified, the assertion is true if at least one
+        # element selected.
+        #
+        # To perform more than one equality tests, use a hash with the following keys:
+        # * <tt>:text</tt> - Narrow the selection to elements that have this text
+        #   value (string or regexp).
+        # * <tt>:html</tt> - Narrow the selection to elements that have this HTML
+        #   content (string or regexp).
+        # * <tt>:count</tt> - Assertion is true if the number of selected elements
+        #   is equal to this value.
+        # * <tt>:minimum</tt> - Assertion is true if the number of selected
+        #   elements is at least this value.
+        # * <tt>:maximum</tt> - Assertion is true if the number of selected
+        #   elements is at most this value.
+        #
+        # If the method is called with a block, once all equality tests are
+        # evaluated the block is called with an array of all matched elements.
+        #
+        #   # At least one form element
+        #   assert_select "form"
+        #
+        #   # Form element includes four input fields
+        #   assert_select "form input", 4
+        #
+        #   # Page title is "Welcome"
+        #   assert_select "title", "Welcome"
+        #
+        #   # Page title is "Welcome" and there is only one title element
+        #   assert_select "title", {count: 1, text: "Welcome"},
+        #       "Wrong title or more than one title element"
+        #
+        #   # Page contains no forms
+        #   assert_select "form", false, "This page must contain no forms"
+        #
+        #   # Test the content and style
+        #   assert_select "body div.header ul.menu"
+        #
+        #   # Use substitution values
+        #   assert_select "ol>li:match('id', ?)", /item-\d+/
+        #
+        #   # All input fields in the form have a name
+        #   assert_select "form input" do
+        #     assert_select ":match('name', ?)", /.+/  # Not empty
+        #   end
+        def assert_select(*args, &block)
+          @selected ||= nil
+
+          root = determine_root_from(args, @selected)
+          selector = HTMLSelector.new(root, args)
+
+          matches = nil
+          catch_invalid_selector do
+            matches = selector.select
+
+            assert_size_match!(matches.size, selector.equality_tests, selector.source, selector.message)
+          end
+
+          nest_selection(matches, &block) if block_given? && !matches.empty?
+
+          matches
+        end
+
+        def count_description(min, max, count) #:nodoc:
+          pluralize = lambda {|word, quantity| word << (quantity == 1 ? '' : 's')}
+
+          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
+
+        # Extracts the content of an element, treats it as encoded HTML and runs
+        # nested assertion on it.
+        #
+        # You typically call this method within another assertion to operate on
+        # all currently selected elements. You can also pass an element or array
+        # of elements.
+        #
+        # The content of each element is un-encoded, and wrapped in the root
+        # element +encoded+. It then calls the block with all un-encoded elements.
+        #
+        #   # Selects all bold tags from within the title of an Atom feed's entries (perhaps to nab a section name prefix)
+        #   assert_select "feed[xmlns='http://www.w3.org/2005/Atom']" do
+        #     # Select each entry item and then the title item
+        #     assert_select "entry>title" do
+        #       # Run assertions on the encoded title elements
+        #       assert_select_encoded do
+        #         assert_select "b"
+        #       end
+        #     end
+        #   end
+        #
+        #
+        #   # Selects all paragraph tags from within the description of an RSS feed
+        #   assert_select "rss[version=2.0]" do
+        #     # Select description element of each feed item.
+        #     assert_select "channel>item>description" do
+        #       # Run assertions on the encoded elements.
+        #       assert_select_encoded do
+        #         assert_select "p"
+        #       end
+        #     end
+        #   end
+        def assert_select_encoded(element = nil, &block)
+          if !element && !@selected
+            raise ArgumentError, "Element is required when called from a nonnested assert_select"
+          end
+
+          content = nodeset(element || @selected).map do |elem|
+            elem.children.select(&:cdata?).map(&:content)
+          end.join
+
+          selected = Nokogiri::HTML::DocumentFragment.parse(content)
+          nest_selection(selected) do
+            if content.empty?
+              yield selected
+            else
+              assert_select ":root", &block
+            end
+          end
+        end
+
+        # Extracts the body of an email and runs nested assertions on it.
+        #
+        # You must enable deliveries for this assertion to work, use:
+        #   ActionMailer::Base.perform_deliveries = true
+        #
+        #  assert_select_email do
+        #    assert_select "h1", "Email alert"
+        #  end
+        #
+        #  assert_select_email do
+        #    items = assert_select "ol>li"
+        #    items.each do
+        #       # Work with items here...
+        #    end
+        #  end
+        def assert_select_email(&block)
+          deliveries = ActionMailer::Base.deliveries
+          assert !deliveries.empty?, "No e-mail in delivery list"
+
+          deliveries.each do |delivery|
+            (delivery.parts.empty? ? [delivery] : delivery.parts).each do |part|
+              if part["Content-Type"].to_s =~ /^text\/html\W/
+                root = Nokogiri::HTML::DocumentFragment.parse(part.body.to_s)
+                assert_select root, ":root", &block
+              end
+            end
+          end
+        end
+
+        protected
+
+          def document_root_element
+            raise NotImplementedError, "Implementing document_root_element makes assert_select work without needing to specify an element to select from."
+          end
+
+          def catch_invalid_selector
+            begin
+              yield
+            rescue Nokogiri::CSS::SyntaxError => e
+              ActiveSupport::Deprecation.warn("The assertion was not run because of an invalid css selector.\n#{e}")
+              return
+            end
+          end
+
+          # +equals+ must contain :minimum, :maximum and :count keys
+          def assert_size_match!(size, equals, css_selector, message = nil)
+            min, max, count = equals[:minimum], equals[:maximum], equals[:count]
+
+            message ||= %(Expected #{count_description(min, max, count)} matching "#{css_selector}", found #{size}.)
+            if count
+              assert_equal count, size, message
+            else
+              assert_operator size, :>=, min, message if min
+              assert_operator size, :<=, max, message if max
+            end
+          end
+
+          def determine_root_from(args, previous_selection = nil)
+            possible_root = args.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 HTMLSelector.can_select_from?(possible_root)
+              args.shift # remove the root, so selector is the first argument
+              possible_root
+            elsif previous_selection
+              previous_selection
+            else
+              document_root_element
+            end
+          end
+
+          def nest_selection(selection)
+            # Set @selected to allow nested assert_select.
+            # Can be nested several levels deep.
+            begin
+              old_selected, @selected = @selected, selection
+              yield @selected
+            ensure
+              @selected = old_selected
+            end
+          end
+
+          def nodeset(node)
+            if node.is_a?(Nokogiri::XML::NodeSet)
+              node
+            else
+              Nokogiri::XML::NodeSet.new(node.document, [node])
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+require_relative 'substitution_context'
+
+class HTMLSelector #:nodoc:
+  NO_STRIP = %w{pre script style textarea}
+  attr_accessor :root, :selector, :equality_tests, :message
+
+  alias :source :selector
+
+  def initialize(root, args)
+    @root = root
+    @selector = extract_selector(args)
+
+    @equality_tests = equality_tests_from(args.shift)
+    @message = args.shift
+
+    if args.shift
+      raise ArgumentError, "Not expecting that last argument, you either have too many arguments, or they're the wrong type"
+    end
+  end
+
+  class << self
+    def can_select_from?(selector)
+      selector.respond_to?(:css)
+    end
+  end
+
+  def select
+    filter root.css(selector, context)
+  end
+
+  def filter(matches)
+    match_with = equality_tests[:text] || equality_tests[:html]
+    return matches if matches.empty? || !match_with
+
+    content_mismatch = nil
+    text_matches = equality_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
+
+    self.message ||= content_mismatch if remaining.empty?
+    Nokogiri::XML::NodeSet.new(matches.document, remaining)
+  end
+
+  def extract_selector(values)
+    selector = values.shift
+
+    unless selector.is_a? String
+      raise ArgumentError, "Expecting a selector as the first argument"
+    end
+
+    context.substitute!(selector, values)
+  end
+
+  def equality_tests_from(comparator)
+    comparisons = {}
+    case comparator
+      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
+
+  def context
+    @context ||= SubstitutionContext.new
+  end
+end

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

@@ -0,0 +1,28 @@
+class SubstitutionContext
+  def initialize(substitute = '?')
+    @substitute = substitute
+    @regexes = []
+  end
+
+  def add_regex(regex)
+    # Nokogiri doesn't like arbitrary values without quotes, hence inspect.
+    return regex.inspect unless regex.is_a?(Regexp)
+    @regexes.push(regex)
+    last_id.to_s # avoid implicit conversions of Fixnum to String
+  end
+
+  def last_id
+    @regexes.count - 1
+  end
+
+  def match(matches, attribute, id)
+    matches.find_all { |node| node[attribute] =~ @regexes[id] }
+  end
+
+  def substitute!(selector, values)
+    while !values.empty? && selector.index(@substitute)
+      selector.sub!(@substitute, add_regex(values.shift))
+    end
+    selector
+  end
+end

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

@@ -0,0 +1,7 @@
+module Rails
+  module Dom
+    module Testing
+      VERSION = "1.0.0"
+    end
+  end
+end

data/test/dom_assertions_test.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+require 'rails/dom/testing/assertions/dom_assertions'
+
+class DomAssertionsTest < ActiveSupport::TestCase
+  Assertion = Minitest::Assertion
+
+  include Rails::Dom::Testing::Assertions::DomAssertions
+
+  def test_responds_to_assert_dom_equal
+    assert respond_to?(:assert_dom_equal)
+  end
+
+  def test_dom_equal
+    html = '<a></a>'
+    assert_dom_equal(html, html.dup)
+  end
+
+  def test_equal_doms_with_different_order_attributes
+    attributes = %{<a b="hello" c="hello"></a>}
+    reverse_attributes = %{<a c="hello" b="hello"></a>}
+    assert_dom_equal(attributes, reverse_attributes)
+  end
+
+  def test_dom_not_equal
+    assert_dom_not_equal('<a></a>', '<b></b>')
+  end
+
+  def test_unequal_doms_attributes_with_different_order_and_values
+    attributes = %{<a b="hello" c="hello"></a>}
+    reverse_attributes = %{<a c="hello" b="goodbye"></a>}
+    assert_dom_not_equal(attributes, reverse_attributes)
+  end
+
+  def test_custom_message_is_used_in_failures
+    message = "This is my message."
+
+    e = assert_raises(Assertion) do
+      assert_dom_equal('<a></a>', '<b></b>', message)
+    end
+
+    assert_equal e.message, message
+  end
+end

data/test/selector_assertions_test.rb

@@ -0,0 +1,281 @@
+# encoding: utf-8
+
+require 'test_helper'
+require 'rails/dom/testing/assertions/selector_assertions'
+
+class AssertSelectTest < ActiveSupport::TestCase
+  Assertion = Minitest::Assertion
+
+  include Rails::Dom::Testing::Assertions::SelectorAssertions
+
+  def assert_failure(message, &block)
+    e = assert_raises(Assertion, &block)
+    assert_match(message, e.message) if Regexp === message
+    assert_equal(message, e.message) if String === message
+  end
+
+  #
+  # Test assert select.
+  #
+
+  def test_assert_select
+    render_html %Q{<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" }
+  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 }
+  end
+
+  def test_equality_true_false
+    render_html %Q{<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 }
+    assert_raise(Assertion) { assert_select "p", true }
+    assert_raise(Assertion) { assert_select "div", false }
+    assert_nothing_raised    { assert_select "p", false }
+  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 }
+  end
+
+  def test_equality_string_and_regexp
+    render_html %Q{<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", /(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/ }
+  end
+
+  def test_equality_of_html
+    render_html %Q{<p>\n<em>"This is <strong>not</strong> a big problem,"</em> he said.\n</p>}
+    text = "\"This is not a big problem,\" he said."
+    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 }
+    # 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 }
+  end
+
+  def test_strip_textarea
+    render_html %Q{<textarea>\n\nfoo\n</textarea>}
+    assert_select "textarea", "\nfoo\n"
+    render_html %Q{<textarea>\nfoo</textarea>}
+    assert_select "textarea", "foo"
+  end
+
+  def test_counts
+    render_html %Q{<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_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_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
+    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
+    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
+    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
+    end
+  end
+
+  def test_substitution_values
+    render_html %Q{<div id="1">foo</div><div id="2">foo</div>}
+    assert_select "div:match('id', ?)", /\d+/ do |elements|
+      assert_equal 2, elements.size
+    end
+    assert_select "div" do
+      assert_select ":match('id', ?)", /\d+/ do |elements|
+        assert_equal 2, elements.size
+        assert_select "#1"
+        assert_select "#2"
+      end
+    end
+  end
+
+  def test_nested_assert_select
+    render_html %Q{<div id="1">foo</div><div id="2">foo</div>}
+    assert_select "div" do |elements|
+      assert_equal 2, elements.size
+      assert_select elements, "#1"
+      assert_select elements, "#2"
+    end
+    assert_select "div" do
+      assert_select "div" do |elements|
+        assert_equal 2, elements.size
+        # Testing in a group is one thing
+        assert_select "#1,#2"
+        # Testing individually is another.
+        assert_select "#1"
+        assert_select "#2"
+        assert_select "#3", false
+      end
+    end
+
+    assert_failure(/Expected at least 1 element matching \"#4\", found 0\./) do
+      assert_select "div" do
+        assert_select "#4"
+      end
+    end
+  end
+
+  def test_assert_select_text_match
+    render_html %Q{<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 }
+    end
+  end
+
+  #
+  # Test css_select.
+  #
+
+  def test_css_select
+    render_html %Q{<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>}
+    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
+    end
+    assert_select "div" do
+      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?
+        # Testing individually is another
+        assert !css_select("#1").empty?
+        assert !css_select("#2").empty?
+      end
+    end
+  end
+
+  # testing invalid selectors
+  def test_assert_select_with_invalid_selector
+    render_html '<a href="http://example.com">hello</a>'
+    assert_deprecated do
+      assert_nil assert_select("[href=http://example.com]")
+    end
+  end
+
+  def test_css_select_with_invalid_selector
+    render_html '<a href="http://example.com">hello</a>'
+    assert_deprecated do
+      assert_nil css_select("[href=http://example.com]")
+    end
+  end
+
+  def test_feed_item_encoded
+    render_xml <<-EOF
+<rss version="2.0">
+  <channel>
+    <item>
+      <description>
+        <![CDATA[
+          <p>Test 1</p>
+        ]]>
+      </description>
+    </item>
+    <item>
+      <description>
+        <![CDATA[
+          <p>Test 2</p>
+        ]]>
+      </description>
+    </item>
+  </channel>
+</rss>
+EOF
+    assert_select "channel item description" do
+
+      assert_select_encoded do
+        assert_select "p", :count=>2, :text=>/Test/
+      end
+
+      # Test individually.
+      assert_select "description" do |elements|
+        assert_select_encoded elements[0] do
+          assert_select "p", "Test 1"
+        end
+        assert_select_encoded elements[1] do
+          assert_select "p", "Test 2"
+        end
+      end
+    end
+
+    # Test that we only un-encode element itself.
+    assert_select "channel item" do
+      assert_select_encoded do
+        assert_select "p", 0
+      end
+    end
+  end
+
+  protected
+    def render_html(html)
+      fake_render(:html, html)
+    end
+
+    def render_xml(xml)
+      fake_render(:xml, xml)
+    end
+
+    def fake_render(content_type, content)
+      @html_document = if content_type == :xml
+        Nokogiri::XML::Document.parse(content)
+      else
+        Nokogiri::HTML::Document.parse(content)
+      end
+    end
+
+    def document_root_element
+      @html_document.root
+    end
+end

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require 'nokogiri'
+require 'active_support/test_case'
+require 'minitest/autorun'

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: rails-dom-testing
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Rafael Mendonça França
+- Kasper Timm Hansen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+- !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: " Dom and Selector assertions for Rails applications "
+email:
+- rafaelmfranca@gmail.com
+- kaspth@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- 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/html_selector.rb
+- lib/rails/dom/testing/assertions/selector_assertions/substitution_context.rb
+- lib/rails/dom/testing/version.rb
+- test/dom_assertions_test.rb
+- test/selector_assertions_test.rb
+- test/test_helper.rb
+homepage: https://github.com/kaspth/rails-dom-testing
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: This gem can compare doms and assert certain elements exists in doms using
+  Nokogiri.
+test_files:
+- test/dom_assertions_test.rb
+- test/selector_assertions_test.rb
+- test/test_helper.rb